diff --git a/cc/BitmapCanvasLayerTextureUpdater.h b/cc/BitmapCanvasLayerTextureUpdater.h index 8cf4e2539b5ec1..bf8f6fe4ecd9ba 100644 --- a/cc/BitmapCanvasLayerTextureUpdater.h +++ b/cc/BitmapCanvasLayerTextureUpdater.h @@ -1,57 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef BitmapCanvasLayerTextureUpdater_h -#define BitmapCanvasLayerTextureUpdater_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "CanvasLayerTextureUpdater.h" - -class SkCanvas; - -namespace cc { - -class LayerPainterChromium; - -// This class rasterizes the contentRect into a skia bitmap canvas. It then updates -// textures by copying from the canvas into the texture, using MapSubImage if -// possible. -class BitmapCanvasLayerTextureUpdater : public CanvasLayerTextureUpdater { -public: - class Texture : public LayerTextureUpdater::Texture { - public: - Texture(BitmapCanvasLayerTextureUpdater*, scoped_ptr); - virtual ~Texture(); - - virtual void updateRect(CCResourceProvider*, const IntRect& sourceRect, const IntSize& destOffset) OVERRIDE; - - private: - BitmapCanvasLayerTextureUpdater* textureUpdater() { return m_textureUpdater; } - - BitmapCanvasLayerTextureUpdater* m_textureUpdater; - }; - - static PassRefPtr create(PassOwnPtr); - virtual ~BitmapCanvasLayerTextureUpdater(); - - virtual PassOwnPtr createTexture(CCPrioritizedTextureManager*) OVERRIDE; - virtual SampledTexelFormat sampledTexelFormat(GC3Denum textureFormat) OVERRIDE; - virtual void prepareToUpdate(const IntRect& contentRect, const IntSize& tileSize, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, CCRenderingStats&) OVERRIDE; - void updateTextureRect(CCResourceProvider*, CCPrioritizedTexture*, const IntRect& sourceRect, const IntSize& destOffset); - - virtual void setOpaque(bool) OVERRIDE; - -protected: - explicit BitmapCanvasLayerTextureUpdater(PassOwnPtr); - - OwnPtr m_canvas; - IntSize m_canvasSize; - bool m_opaque; -}; - -} // namespace cc -#endif // USE(ACCELERATED_COMPOSITING) -#endif // BitmapCanvasLayerTextureUpdater_h +// Temporary forwarding header +#include "cc/bitmap_canvas_layer_texture_updater.h" diff --git a/cc/BitmapSkPictureCanvasLayerTextureUpdater.h b/cc/BitmapSkPictureCanvasLayerTextureUpdater.h index 140f9beab6c707..2e6dc4477f4846 100644 --- a/cc/BitmapSkPictureCanvasLayerTextureUpdater.h +++ b/cc/BitmapSkPictureCanvasLayerTextureUpdater.h @@ -1,45 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef BitmapSkPictureCanvasLayerTextureUpdater_h -#define BitmapSkPictureCanvasLayerTextureUpdater_h - -#if USE(ACCELERATED_COMPOSITING) -#include "SkBitmap.h" -#include "SkPictureCanvasLayerTextureUpdater.h" - -namespace cc { - -// This class records the contentRect into an SkPicture, then software rasterizes -// the SkPicture into bitmaps for each tile. This implements CCSettings::perTilePainting. -class BitmapSkPictureCanvasLayerTextureUpdater : public SkPictureCanvasLayerTextureUpdater { -public: - class Texture : public CanvasLayerTextureUpdater::Texture { - public: - Texture(BitmapSkPictureCanvasLayerTextureUpdater*, scoped_ptr); - - virtual void prepareRect(const IntRect& sourceRect, CCRenderingStats&) OVERRIDE; - virtual void updateRect(CCResourceProvider*, const IntRect& sourceRect, const IntSize& destOffset) OVERRIDE; - - private: - BitmapSkPictureCanvasLayerTextureUpdater* textureUpdater() { return m_textureUpdater; } - - SkBitmap m_bitmap; - BitmapSkPictureCanvasLayerTextureUpdater* m_textureUpdater; - }; - - static PassRefPtr create(PassOwnPtr); - virtual ~BitmapSkPictureCanvasLayerTextureUpdater(); - - virtual PassOwnPtr createTexture(CCPrioritizedTextureManager*) OVERRIDE; - virtual SampledTexelFormat sampledTexelFormat(GC3Denum textureFormat) OVERRIDE; - void paintContentsRect(SkCanvas*, const IntRect& sourceRect, CCRenderingStats&); - -private: - explicit BitmapSkPictureCanvasLayerTextureUpdater(PassOwnPtr); -}; -} // namespace cc -#endif // USE(ACCELERATED_COMPOSITING) -#endif // BitmapSkPictureCanvasLayerTextureUpdater_h +// Temporary forwarding header +#include "cc/bitmap_skpicture_canvas_layer_texture_updater.h" diff --git a/cc/CCActiveAnimation.h b/cc/CCActiveAnimation.h index b8d3607d9b1e7d..e5737a856ce1ff 100644 --- a/cc/CCActiveAnimation.h +++ b/cc/CCActiveAnimation.h @@ -2,160 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCActiveAnimation_h -#define CCActiveAnimation_h - -#include "base/basictypes.h" -#include "base/memory/scoped_ptr.h" - -namespace cc { - -class CCAnimationCurve; - -// A CCActiveAnimation, contains all the state required to play a CCAnimationCurve. -// Specifically, the affected property, the run state (paused, finished, etc.), -// loop count, last pause time, and the total time spent paused. -class CCActiveAnimation { -public: - // Animations begin in one of the 'waiting' states. Animations waiting for the next tick - // will start the next time the controller animates. Animations waiting for target - // availibility will run as soon as their target property is free (and all the animations - // animating with it are also able to run). Animations waiting for their start time to - // come have be scheduled to run at a particular point in time. When this time arrives, - // the controller will move the animations into the Running state. Running animations - // may toggle between Running and Paused, and may be stopped by moving into either the - // Aborted or Finished states. A Finished animation was allowed to run to completion, but - // an Aborted animation was not. - enum RunState { - WaitingForNextTick = 0, - WaitingForTargetAvailability, - WaitingForStartTime, - WaitingForDeletion, - Running, - Paused, - Finished, - Aborted, - // This sentinel must be last. - RunStateEnumSize - }; - - enum TargetProperty { - Transform = 0, - Opacity, - // This sentinel must be last. - TargetPropertyEnumSize - }; - - static scoped_ptr create(scoped_ptr, int animationId, int groupId, TargetProperty); - - virtual ~CCActiveAnimation(); - - int id() const { return m_id; } - int group() const { return m_group; } - TargetProperty targetProperty() const { return m_targetProperty; } - - RunState runState() const { return m_runState; } - void setRunState(RunState, double monotonicTime); - - // This is the number of times that the animation will play. If this - // value is zero the animation will not play. If it is negative, then - // the animation will loop indefinitely. - int iterations() const { return m_iterations; } - void setIterations(int n) { m_iterations = n; } - - double startTime() const { return m_startTime; } - void setStartTime(double monotonicTime) { m_startTime = monotonicTime; } - bool hasSetStartTime() const { return m_startTime; } - - double timeOffset() const { return m_timeOffset; } - void setTimeOffset(double monotonicTime) { m_timeOffset = monotonicTime; } - - void suspend(double monotonicTime); - void resume(double monotonicTime); - - // If alternatesDirection is true, on odd numbered iterations we reverse the curve. - bool alternatesDirection() const { return m_alternatesDirection; } - void setAlternatesDirection(bool alternates) { m_alternatesDirection = alternates; } - - bool isFinishedAt(double monotonicTime) const; - bool isFinished() const { return m_runState == Finished - || m_runState == Aborted - || m_runState == WaitingForDeletion; } - - CCAnimationCurve* curve() { return m_curve.get(); } - const CCAnimationCurve* curve() const { return m_curve.get(); } - - // If this is true, even if the animation is running, it will not be tickable until - // it is given a start time. This is true for animations running on the main thread. - bool needsSynchronizedStartTime() const { return m_needsSynchronizedStartTime; } - void setNeedsSynchronizedStartTime(bool needsSynchronizedStartTime) { m_needsSynchronizedStartTime = needsSynchronizedStartTime; } - - // Takes the given absolute time, and using the start time and the number - // of iterations, returns the relative time in the current iteration. - double trimTimeToCurrentIteration(double monotonicTime) const; - - enum InstanceType { - ControllingInstance = 0, - NonControllingInstance - }; - - scoped_ptr clone(InstanceType) const; - scoped_ptr cloneAndInitialize(InstanceType, RunState initialRunState, double startTime) const; - bool isControllingInstance() const { return m_isControllingInstance; } - - void pushPropertiesTo(CCActiveAnimation*) const; - -private: - CCActiveAnimation(scoped_ptr, int animationId, int groupId, TargetProperty); - - scoped_ptr m_curve; - - // IDs are not necessarily unique. - int m_id; - - // Animations that must be run together are called 'grouped' and have the same group id - // Grouped animations are guaranteed to start at the same time and no other animations - // may animate any of the group's target properties until all animations in the - // group have finished animating. Note: an active animation's group id and target - // property uniquely identify that animation. - int m_group; - - TargetProperty m_targetProperty; - RunState m_runState; - int m_iterations; - double m_startTime; - bool m_alternatesDirection; - - // The time offset effectively pushes the start of the animation back in time. This is - // used for resuming paused animations -- an animation is added with a non-zero time - // offset, causing the animation to skip ahead to the desired point in time. - double m_timeOffset; - - bool m_needsSynchronizedStartTime; - - // When an animation is suspended, it behaves as if it is paused and it also ignores - // all run state changes until it is resumed. This is used for testing purposes. - bool m_suspended; - - // These are used in trimTimeToCurrentIteration to account for time - // spent while paused. This is not included in AnimationState since it - // there is absolutely no need for clients of this controller to know - // about these values. - double m_pauseTime; - double m_totalPausedTime; - - // Animations lead dual lives. An active animation will be conceptually owned by - // two controllers, one on the impl thread and one on the main. In reality, there - // will be two separate CCActiveAnimation instances for the same animation. They - // will have the same group id and the same target property (these two values - // uniquely identify an animation). The instance on the impl thread is the instance - // that ultimately controls the values of the animating layer and so we will refer - // to it as the 'controlling instance'. - bool m_isControllingInstance; - - DISALLOW_COPY_AND_ASSIGN(CCActiveAnimation); -}; - -} // namespace cc - -#endif // CCActiveAnimation_h +// Temporary forwarding header +#include "cc/active_animation.h" diff --git a/cc/CCAnimationCurve.h b/cc/CCAnimationCurve.h index 7ed6e7a9e50a43..71cd0fae1dfcf4 100644 --- a/cc/CCAnimationCurve.h +++ b/cc/CCAnimationCurve.h @@ -2,55 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCAnimationCurve_h -#define CCAnimationCurve_h - -#include "base/memory/scoped_ptr.h" -#include - -namespace cc { - -class CCFloatAnimationCurve; -class CCTransformAnimationCurve; -class IntSize; -class TransformOperations; - -// An animation curve is a function that returns a value given a time. -// There are currently only two types of curve, float and transform. -class CCAnimationCurve { -public: - enum Type { Float, Transform }; - - virtual ~CCAnimationCurve() { } - - virtual double duration() const = 0; - virtual Type type() const = 0; - virtual scoped_ptr clone() const = 0; - - const CCFloatAnimationCurve* toFloatAnimationCurve() const; - const CCTransformAnimationCurve* toTransformAnimationCurve() const; -}; - -class CCFloatAnimationCurve : public CCAnimationCurve { -public: - virtual ~CCFloatAnimationCurve() { } - - virtual float getValue(double t) const = 0; - - // Partial CCAnimation implementation. - virtual Type type() const OVERRIDE; -}; - -class CCTransformAnimationCurve : public CCAnimationCurve { -public: - virtual ~CCTransformAnimationCurve() { } - - virtual WebKit::WebTransformationMatrix getValue(double t) const = 0; - - // Partial CCAnimation implementation. - virtual Type type() const OVERRIDE; -}; - -} // namespace cc - -#endif // CCAnimation_h +// Temporary forwarding header +#include "cc/animation_curve.h" diff --git a/cc/CCAnimationEvents.h b/cc/CCAnimationEvents.h index 5e86ef7381527b..988f56eee08ff7 100644 --- a/cc/CCAnimationEvents.h +++ b/cc/CCAnimationEvents.h @@ -2,36 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCAnimationEvents_h -#define CCAnimationEvents_h - -#include - -#include "CCActiveAnimation.h" - -namespace cc { - -struct CCAnimationEvent { - enum Type { Started, Finished }; - - CCAnimationEvent(Type type, int layerId, int groupId, CCActiveAnimation::TargetProperty targetProperty, double monotonicTime) - : type(type) - , layerId(layerId) - , groupId(groupId) - , targetProperty(targetProperty) - , monotonicTime(monotonicTime) - { - } - - Type type; - int layerId; - int groupId; - CCActiveAnimation::TargetProperty targetProperty; - double monotonicTime; -}; - -typedef std::vector CCAnimationEventsVector; - -} // namespace cc - -#endif // CCAnimationEvents_h +// Temporary forwarding header +#include "cc/animation_events.h" diff --git a/cc/CCAppendQuadsData.h b/cc/CCAppendQuadsData.h index b086de01a85269..7a11591c87e589 100644 --- a/cc/CCAppendQuadsData.h +++ b/cc/CCAppendQuadsData.h @@ -2,35 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCAppendQuadsData_h -#define CCAppendQuadsData_h - -#include "CCRenderPass.h" - -namespace cc { - -struct CCAppendQuadsData { - CCAppendQuadsData() - : hadOcclusionFromOutsideTargetSurface(false) - , hadMissingTiles(false) - , renderPassId(0, 0) - { - } - - explicit CCAppendQuadsData(CCRenderPass::Id renderPassId) - : hadOcclusionFromOutsideTargetSurface(false) - , hadMissingTiles(false) - , renderPassId(renderPassId) - { - } - - // Set by the QuadCuller. - bool hadOcclusionFromOutsideTargetSurface; - // Set by the layer appending quads. - bool hadMissingTiles; - // Given to the layer appending quads. - const CCRenderPass::Id renderPassId; -}; - -} -#endif // CCCCAppendQuadsData_h +// Temporary forwarding header +#include "cc/append_quads_data.h" diff --git a/cc/CCCheckerboardDrawQuad.h b/cc/CCCheckerboardDrawQuad.h index 1ef147f3b4fb17..ceb42db9e80f26 100644 --- a/cc/CCCheckerboardDrawQuad.h +++ b/cc/CCCheckerboardDrawQuad.h @@ -2,32 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCCheckerboardDrawQuad_h -#define CCCheckerboardDrawQuad_h - -#include "CCDrawQuad.h" -#include "base/memory/scoped_ptr.h" -#include "SkColor.h" - -namespace cc { - -#pragma pack(push, 4) - -class CCCheckerboardDrawQuad : public CCDrawQuad { -public: - static scoped_ptr create(const CCSharedQuadState*, const IntRect&, SkColor); - - SkColor color() const { return m_color; }; - - static const CCCheckerboardDrawQuad* materialCast(const CCDrawQuad*); -private: - CCCheckerboardDrawQuad(const CCSharedQuadState*, const IntRect&, SkColor); - - SkColor m_color; -}; - -#pragma pack(pop) - -} - -#endif +// Temporary forwarding header +#include "cc/checkerboard_draw_quad.h" diff --git a/cc/CCCompletionEvent.h b/cc/CCCompletionEvent.h index 462e4ba12f6885..f42207501beea3 100644 --- a/cc/CCCompletionEvent.h +++ b/cc/CCCompletionEvent.h @@ -1,62 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCCompletionEvent_h -#define CCCompletionEvent_h - -#include "base/synchronization/waitable_event.h" - -namespace cc { - -// Used for making blocking calls from one thread to another. Use only when -// absolutely certain that doing-so will not lead to a deadlock. -// -// It is safe to destroy this object as soon as wait() returns. -class CCCompletionEvent { -public: - CCCompletionEvent() - : m_event(false /* manual_reset */, false /* initially_signaled */) - { -#ifndef NDEBUG - m_waited = false; - m_signaled = false; -#endif - } - - ~CCCompletionEvent() - { - ASSERT(m_waited); - ASSERT(m_signaled); - } - - void wait() - { - ASSERT(!m_waited); -#ifndef NDEBUG - m_waited = true; -#endif - m_event.Wait(); - } - - void signal() - { - ASSERT(!m_signaled); -#ifndef NDEBUG - m_signaled = true; -#endif - m_event.Signal(); - } - -private: - base::WaitableEvent m_event; -#ifndef NDEBUG - // Used to assert that wait() and signal() are each called exactly once. - bool m_waited; - bool m_signaled; -#endif -}; - -} - -#endif +// Temporary forwarding header +#include "cc/completion_event.h" diff --git a/cc/CCDamageTracker.h b/cc/CCDamageTracker.h index c7550a26ba32b2..5e48bc6a5e8e6d 100644 --- a/cc/CCDamageTracker.h +++ b/cc/CCDamageTracker.h @@ -1,63 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCDamageTracker_h -#define CCDamageTracker_h - -#include "base/memory/scoped_ptr.h" -#include "FloatRect.h" -#include -#include -#include - -namespace WebKit { -class WebFilterOperations; -} - -namespace cc { - -class CCLayerImpl; -class CCRenderSurface; - -// Computes the region where pixels have actually changed on a RenderSurface. This region is used -// to scissor what is actually drawn to the screen to save GPU computation and bandwidth. -class CCDamageTracker { -public: - static scoped_ptr create(); - ~CCDamageTracker(); - - void didDrawDamagedArea() { m_currentDamageRect = FloatRect(); } - void forceFullDamageNextUpdate() { m_forceFullDamageNextUpdate = true; } - void updateDamageTrackingState(const std::vector& layerList, int targetSurfaceLayerID, bool targetSurfacePropertyChangedOnlyFromDescendant, const IntRect& targetSurfaceContentRect, CCLayerImpl* targetSurfaceMaskLayer, const WebKit::WebFilterOperations&); - - const FloatRect& currentDamageRect() { return m_currentDamageRect; } - -private: - CCDamageTracker(); - - FloatRect trackDamageFromActiveLayers(const std::vector& layerList, int targetSurfaceLayerID); - FloatRect trackDamageFromSurfaceMask(CCLayerImpl* targetSurfaceMaskLayer); - FloatRect trackDamageFromLeftoverRects(); - - FloatRect removeRectFromCurrentFrame(int layerID, bool& layerIsNew); - void saveRectForNextFrame(int layerID, const FloatRect& targetSpaceRect); - - // These helper functions are used only in trackDamageFromActiveLayers(). - void extendDamageForLayer(CCLayerImpl*, FloatRect& targetDamageRect); - void extendDamageForRenderSurface(CCLayerImpl*, FloatRect& targetDamageRect); - - // To correctly track exposed regions, two hashtables of rects are maintained. - // The "current" map is used to compute exposed regions of the current frame, while - // the "next" map is used to collect layer rects that are used in the next frame. - typedef HashMap RectMap; - scoped_ptr m_currentRectHistory; - scoped_ptr m_nextRectHistory; - - FloatRect m_currentDamageRect; - bool m_forceFullDamageNextUpdate; -}; - -} // namespace cc - -#endif // CCDamageTracker_h +// Temporary forwarding header +#include "cc/damage_tracker.h" diff --git a/cc/CCDebugBorderDrawQuad.h b/cc/CCDebugBorderDrawQuad.h index fbba1c6bebad18..3b275fa0b142f2 100644 --- a/cc/CCDebugBorderDrawQuad.h +++ b/cc/CCDebugBorderDrawQuad.h @@ -2,34 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCDebugBorderDrawQuad_h -#define CCDebugBorderDrawQuad_h - -#include "CCDrawQuad.h" -#include "SkColor.h" -#include "base/memory/scoped_ptr.h" - -namespace cc { - -#pragma pack(push, 4) - -class CCDebugBorderDrawQuad : public CCDrawQuad { -public: - static scoped_ptr create(const CCSharedQuadState*, const IntRect&, SkColor, int width); - - SkColor color() const { return m_color; }; - int width() const { return m_width; } - - static const CCDebugBorderDrawQuad* materialCast(const CCDrawQuad*); -private: - CCDebugBorderDrawQuad(const CCSharedQuadState*, const IntRect&, SkColor, int width); - - SkColor m_color; - int m_width; -}; - -#pragma pack(pop) - -} - -#endif +// Temporary forwarding header +#include "cc/debug_border_draw_quad.h" diff --git a/cc/CCDebugRectHistory.h b/cc/CCDebugRectHistory.h index 1b03f34aa79634..690febec4edec2 100644 --- a/cc/CCDebugRectHistory.h +++ b/cc/CCDebugRectHistory.h @@ -2,86 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCDebugRectHistory_h -#define CCDebugRectHistory_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "base/basictypes.h" -#include "FloatRect.h" -#include "IntRect.h" -#include -#include -#include - -namespace cc { - -class CCLayerImpl; -struct CCLayerTreeSettings; - -// There are currently six types of debug rects: -// -// - Paint rects (update rects): regions of a layer that needed to be re-uploaded to the -// texture resource; in most cases implying that they had to be repainted, too. -// -// - Property-changed rects: enclosing bounds of layers that cause changes to the screen -// even if the layer did not change internally. (For example, if the layer's opacity or -// position changes.) -// -// - Surface damage rects: the aggregate damage on a target surface that is caused by all -// layers and surfaces that contribute to it. This includes (1) paint rects, (2) property- -// changed rects, and (3) newly exposed areas. -// -// - Screen space rects: this is the region the contents occupy in screen space. -// -// - Replica screen space rects: this is the region the replica's contents occupy in screen space. -// -// - Occluding rects: these are the regions that contribute to the occluded region. -// -enum DebugRectType { PaintRectType, PropertyChangedRectType, SurfaceDamageRectType, ScreenSpaceRectType, ReplicaScreenSpaceRectType, OccludingRectType }; - -struct CCDebugRect { - CCDebugRect(DebugRectType newType, FloatRect newRect) - : type(newType) - , rect(newRect) { } - - DebugRectType type; - FloatRect rect; -}; - -// This class maintains a history of rects of various types that can be used -// for debugging purposes. The overhead of collecting rects is performed only if -// the appropriate CCLayerTreeSettings are enabled. -class CCDebugRectHistory { -public: - static PassOwnPtr create() - { - return adoptPtr(new CCDebugRectHistory()); - } - - ~CCDebugRectHistory(); - - // Note: Saving debug rects must happen before layers' change tracking is reset. - void saveDebugRectsForCurrentFrame(CCLayerImpl* rootLayer, const std::vector& renderSurfaceLayerList, const Vector& occludingScreenSpaceRects, const CCLayerTreeSettings&); - - const Vector& debugRects() { return m_debugRects; } - -private: - CCDebugRectHistory(); - - void savePaintRects(CCLayerImpl*); - void savePropertyChangedRects(const std::vector& renderSurfaceLayerList); - void saveSurfaceDamageRects(const std::vector& renderSurfaceLayerList); - void saveScreenSpaceRects(const std::vector& renderSurfaceLayerList); - void saveOccludingRects(const Vector& occludingScreenSpaceRects); - - Vector m_debugRects; - - DISALLOW_COPY_AND_ASSIGN(CCDebugRectHistory); -}; - -} // namespace cc - -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/debug_rect_history.h" diff --git a/cc/CCDelayBasedTimeSource.h b/cc/CCDelayBasedTimeSource.h index bf183f7aa7313e..249666c1b2d093 100644 --- a/cc/CCDelayBasedTimeSource.h +++ b/cc/CCDelayBasedTimeSource.h @@ -1,79 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCDelayBasedTimeSource_h -#define CCDelayBasedTimeSource_h - -#include "CCTimeSource.h" -#include "CCTimer.h" -#include - -namespace cc { - -class CCThread; - -// This timer implements a time source that achieves the specified interval -// in face of millisecond-precision delayed callbacks and random queueing delays. -class CCDelayBasedTimeSource : public CCTimeSource, CCTimerClient { -public: - static PassRefPtr create(base::TimeDelta interval, CCThread*); - - virtual ~CCDelayBasedTimeSource(); - - virtual void setClient(CCTimeSourceClient* client) OVERRIDE; - - // CCTimeSource implementation - virtual void setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval) OVERRIDE; - - virtual void setActive(bool) OVERRIDE; - virtual bool active() const OVERRIDE; - - // Get the last and next tick times. nextTimeTime() returns null when - // inactive. - virtual base::TimeTicks lastTickTime() OVERRIDE; - virtual base::TimeTicks nextTickTime() OVERRIDE; - - // CCTimerClient implementation. - virtual void onTimerFired() OVERRIDE; - - // Virtual for testing. - virtual base::TimeTicks now() const; - -protected: - CCDelayBasedTimeSource(base::TimeDelta interval, CCThread*); - base::TimeTicks nextTickTarget(base::TimeTicks now); - void postNextTickTask(base::TimeTicks now); - - enum State { - STATE_INACTIVE, - STATE_STARTING, - STATE_ACTIVE, - }; - - struct Parameters { - Parameters(base::TimeDelta interval, base::TimeTicks tickTarget) - : interval(interval), tickTarget(tickTarget) - { } - base::TimeDelta interval; - base::TimeTicks tickTarget; - }; - - CCTimeSourceClient* m_client; - bool m_hasTickTarget; - base::TimeTicks m_lastTickTime; - - // m_currentParameters should only be written by postNextTickTask. - // m_nextParameters will take effect on the next call to postNextTickTask. - // Maintaining a pending set of parameters allows nextTickTime() to always - // reflect the actual time we expect onTimerFired to be called. - Parameters m_currentParameters; - Parameters m_nextParameters; - - State m_state; - CCThread* m_thread; - CCTimer m_timer; -}; - -} -#endif // CCDelayBasedTimeSource_h +// Temporary forwarding header +#include "cc/delay_based_time_source.h" diff --git a/cc/CCDelegatedRendererLayerImpl.h b/cc/CCDelegatedRendererLayerImpl.h index 4ed842e560145d..08952e37223817 100644 --- a/cc/CCDelegatedRendererLayerImpl.h +++ b/cc/CCDelegatedRendererLayerImpl.h @@ -2,49 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCDelegatedRendererLayerImpl_h -#define CCDelegatedRendererLayerImpl_h - -#include "CCLayerImpl.h" -#include "cc/scoped_ptr_vector.h" - -namespace cc { - -class CCDelegatedRendererLayerImpl : public CCLayerImpl { -public: - static scoped_ptr create(int id) { return make_scoped_ptr(new CCDelegatedRendererLayerImpl(id)); } - virtual ~CCDelegatedRendererLayerImpl(); - - virtual bool descendantDrawsContent() OVERRIDE; - virtual bool hasContributingDelegatedRenderPasses() const OVERRIDE; - - // This gives ownership of the RenderPasses to the layer. - void setRenderPasses(ScopedPtrVector&); - void clearRenderPasses(); - - virtual void didLoseContext() OVERRIDE; - - virtual CCRenderPass::Id firstContributingRenderPassId() const OVERRIDE; - virtual CCRenderPass::Id nextContributingRenderPassId(CCRenderPass::Id) const OVERRIDE; - - void appendContributingRenderPasses(CCRenderPassSink&); - virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; - -private: - explicit CCDelegatedRendererLayerImpl(int); - - CCRenderPass::Id convertDelegatedRenderPassId(CCRenderPass::Id delegatedRenderPassId) const; - - void appendRenderPassQuads(CCQuadSink&, CCAppendQuadsData&, CCRenderPass* fromDelegatedRenderPass) const; - - PassOwnPtr createCopyOfQuad(const CCDrawQuad*); - - virtual const char* layerTypeAsString() const OVERRIDE; - - ScopedPtrVector m_renderPassesInDrawOrder; - base::hash_map m_renderPassesIndexById; -}; - -} - -#endif // CCDelegatedRendererLayerImpl_h +// Temporary forwarding header +#include "cc/delegated_renderer_layer_impl.h" diff --git a/cc/CCDirectRenderer.h b/cc/CCDirectRenderer.h index 73e6dc685377a5..3e61292ac6ba9d 100644 --- a/cc/CCDirectRenderer.h +++ b/cc/CCDirectRenderer.h @@ -2,104 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCDirectRenderer_h -#define CCDirectRenderer_h - -#include "base/basictypes.h" -#include "CCRenderer.h" -#include "CCResourceProvider.h" -#include "CCScopedTexture.h" - -namespace cc { - -class CCResourceProvider; - -// This is the base class for code shared between the GL and software -// renderer implementations. "Direct" refers to the fact that it does not -// delegate rendering to another compositor. -class CCDirectRenderer : public CCRenderer { -public: - virtual ~CCDirectRenderer(); - - CCResourceProvider* resourceProvider() const { return m_resourceProvider; } - - virtual void decideRenderPassAllocationsForFrame(const CCRenderPassList& renderPassesInDrawOrder) OVERRIDE; - virtual bool haveCachedResourcesForRenderPassId(CCRenderPass::Id) const OVERRIDE; - virtual void drawFrame(const CCRenderPassList& renderPassesInDrawOrder, const CCRenderPassIdHashMap& renderPassesById) OVERRIDE; - -protected: - CCDirectRenderer(CCRendererClient* client, CCResourceProvider* resourceProvider); - - struct DrawingFrame { - DrawingFrame(); - ~DrawingFrame(); - - const CCRenderPassIdHashMap* renderPassesById; - const CCRenderPass* rootRenderPass; - const CCRenderPass* currentRenderPass; - const CCScopedTexture* currentTexture; - - FloatRect rootDamageRect; - - WebKit::WebTransformationMatrix projectionMatrix; - WebKit::WebTransformationMatrix windowMatrix; - bool flippedY; - FloatRect scissorRectInRenderPassSpace; - }; - - class CachedTexture : public CCScopedTexture { - public: - static scoped_ptr create(CCResourceProvider* resourceProvider) { - return make_scoped_ptr(new CachedTexture(resourceProvider)); - } - virtual ~CachedTexture() {} - - bool isComplete() const { return m_isComplete; } - void setIsComplete(bool isComplete) { m_isComplete = isComplete; } - - protected: - explicit CachedTexture(CCResourceProvider* resourceProvider) - : CCScopedTexture(resourceProvider) - , m_isComplete(false) - { - } - - private: - bool m_isComplete; - - DISALLOW_COPY_AND_ASSIGN(CachedTexture); - }; - - static FloatRect quadVertexRect(); - static void quadRectTransform(WebKit::WebTransformationMatrix* quadRectTransform, const WebKit::WebTransformationMatrix& quadTransform, const FloatRect& quadRect); - static void initializeMatrices(DrawingFrame&, const IntRect& drawRect, bool flipY); - static IntRect moveScissorToWindowSpace(const DrawingFrame&, FloatRect scissorRect); - - bool haveCachedResources(CCRenderPass::Id) const; - static IntSize renderPassTextureSize(const CCRenderPass*); - static GC3Denum renderPassTextureFormat(const CCRenderPass*); - - void drawRenderPass(DrawingFrame&, const CCRenderPass*); - bool useRenderPass(DrawingFrame&, const CCRenderPass*); - - virtual void bindFramebufferToOutputSurface(DrawingFrame&) = 0; - virtual bool bindFramebufferToTexture(DrawingFrame&, const CCScopedTexture*, const IntRect& framebufferRect) = 0; - virtual void setDrawViewportSize(const IntSize&) = 0; - virtual void enableScissorTestRect(const IntRect& scissorRect) = 0; - virtual void disableScissorTest() = 0; - virtual void clearFramebuffer(DrawingFrame&) = 0; - virtual void drawQuad(DrawingFrame&, const CCDrawQuad*) = 0; - virtual void beginDrawingFrame(DrawingFrame&) = 0; - virtual void finishDrawingFrame(DrawingFrame&) = 0; - virtual bool flippedFramebuffer() const = 0; - - ScopedPtrHashMap m_renderPassTextures; - CCResourceProvider* m_resourceProvider; - -private: - DISALLOW_COPY_AND_ASSIGN(CCDirectRenderer); -}; - -} // namespace cc - -#endif // CCDirectRenderer_h +// Temporary forwarding header +#include "cc/direct_renderer.h" diff --git a/cc/CCDrawQuad.h b/cc/CCDrawQuad.h index 05a69065468192..ca1a0946236c32 100644 --- a/cc/CCDrawQuad.h +++ b/cc/CCDrawQuad.h @@ -2,95 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCDrawQuad_h -#define CCDrawQuad_h - -#include "CCSharedQuadState.h" - -namespace cc { - -// WARNING! All CCXYZDrawQuad classes must remain PODs (plain old data). -// They are intended to be "serializable" by copying their raw bytes, so they -// must not contain any non-bit-copyable member variables! -// -// Furthermore, the class members need to be packed so they are aligned -// properly and don't have paddings/gaps, otherwise memory check tools -// like Valgrind will complain about uninitialized memory usage when -// transferring these classes over the wire. -#pragma pack(push, 4) - -// CCDrawQuad is a bag of data used for drawing a quad. Because different -// materials need different bits of per-quad data to render, classes that derive -// from CCDrawQuad store additional data in their derived instance. The Material -// enum is used to "safely" downcast to the derived class. -class CCDrawQuad { -public: - enum Material { - Invalid, - Checkerboard, - DebugBorder, - IOSurfaceContent, - RenderPass, - TextureContent, - SolidColor, - TiledContent, - YUVVideoContent, - StreamVideoContent, - }; - - IntRect quadRect() const { return m_quadRect; } - const WebKit::WebTransformationMatrix& quadTransform() const { return m_sharedQuadState->quadTransform; } - IntRect visibleContentRect() const { return m_sharedQuadState->visibleContentRect; } - IntRect clippedRectInTarget() const { return m_sharedQuadState->clippedRectInTarget; } - float opacity() const { return m_sharedQuadState->opacity; } - // For the purposes of blending, what part of the contents of this quad are opaque? - IntRect opaqueRect() const; - bool needsBlending() const { return m_needsBlending || !opaqueRect().contains(m_quadVisibleRect); } - - // Allows changing the rect that gets drawn to make it smaller. Parameter passed - // in will be clipped to quadRect(). - void setQuadVisibleRect(const IntRect&); - IntRect quadVisibleRect() const { return m_quadVisibleRect; } - bool isDebugQuad() const { return m_material == DebugBorder; } - - Material material() const { return m_material; } - - // Returns transfer size of this object based on the derived class (by - // looking at the material type). - unsigned size() const; - - scoped_ptr copy(const CCSharedQuadState* copiedSharedQuadState) const; - - const CCSharedQuadState* sharedQuadState() const { return m_sharedQuadState; } - int sharedQuadStateId() const { return m_sharedQuadStateId; } - void setSharedQuadState(const CCSharedQuadState*); - -protected: - CCDrawQuad(const CCSharedQuadState*, Material, const IntRect&); - - // Stores state common to a large bundle of quads; kept separate for memory - // efficiency. There is special treatment to reconstruct these pointers - // during serialization. - const CCSharedQuadState* m_sharedQuadState; - int m_sharedQuadStateId; - - Material m_material; - IntRect m_quadRect; - IntRect m_quadVisibleRect; - - // By default, the shared quad state determines whether or not this quad is - // opaque or needs blending. Derived classes can override with these - // variables. - bool m_quadOpaque; - bool m_needsBlending; - - // Be default, this rect is empty. It is used when the shared quad state and above - // variables determine that the quad is not fully opaque but may be partially opaque. - IntRect m_opaqueRect; -}; - -#pragma pack(pop) - -} - -#endif +// Temporary forwarding header +#include "cc/draw_quad.h" diff --git a/cc/CCFontAtlas.h b/cc/CCFontAtlas.h index 2881ee9a55abc9..18463e47344a92 100644 --- a/cc/CCFontAtlas.h +++ b/cc/CCFontAtlas.h @@ -2,69 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCFontAtlas_h -#define CCFontAtlas_h - -#if USE(ACCELERATED_COMPOSITING) - -#include - -#include "base/basictypes.h" -#include "base/memory/scoped_ptr.h" -#include "IntRect.h" -#include "SkBitmap.h" - -class SkCanvas; - -namespace gfx { -class Point; -} - -namespace cc { - -class Color; -class FontDescription; -class GraphicsContext; -class IntSize; - -// This class provides basic ability to draw text onto the heads-up display. -class CCFontAtlas { -public: - static scoped_ptr create(SkBitmap bitmap, IntRect asciiToRectTable[128], int fontHeight) - { - return make_scoped_ptr(new CCFontAtlas(bitmap, asciiToRectTable, fontHeight)); - } - ~CCFontAtlas(); - - // Draws multiple lines of text where each line of text is separated by '\n'. - // - Correct glyphs will be drawn for ASCII codes in the range 32-127; any characters - // outside that range will be displayed as a default rectangle glyph. - // - IntSize clip is used to avoid wasting time drawing things that are outside the - // target canvas bounds. - // - Should only be called only on the impl thread. - void drawText(SkCanvas*, const SkPaint&, const std::string& text, const gfx::Point& destPosition, const IntSize& clip) const; - - // Draws the entire atlas at the specified position, just for debugging purposes. - void drawDebugAtlas(SkCanvas*, const gfx::Point& destPosition) const; - -private: - CCFontAtlas(SkBitmap, IntRect asciiToRectTable[128], int fontHeight); - - void drawOneLineOfTextInternal(SkCanvas*, const SkPaint&, const std::string&, const gfx::Point& destPosition) const; - - // The actual texture atlas containing all the pre-rendered glyphs. - SkBitmap m_atlas; - - // The look-up tables mapping ascii characters to their IntRect locations on the atlas. - IntRect m_asciiToRectTable[128]; - - int m_fontHeight; - - DISALLOW_COPY_AND_ASSIGN(CCFontAtlas); -}; - -} // namespace cc - -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/font_atlas.h" diff --git a/cc/CCFrameRateController.h b/cc/CCFrameRateController.h index 2aeeae156d6580..e8d28b53da44ad 100644 --- a/cc/CCFrameRateController.h +++ b/cc/CCFrameRateController.h @@ -1,82 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCFrameRateController_h -#define CCFrameRateController_h - -#include "base/memory/scoped_ptr.h" -#include "base/time.h" -#include "CCTimer.h" -#include -#include - -namespace cc { - -class CCThread; -class CCTimeSource; - -class CCFrameRateControllerClient { -public: - // Throttled is true when we have a maximum number of frames pending. - virtual void vsyncTick(bool throttled) = 0; - -protected: - virtual ~CCFrameRateControllerClient() {} -}; - -class CCFrameRateControllerTimeSourceAdapter; - -class CCFrameRateController : public CCTimerClient { -public: - explicit CCFrameRateController(PassRefPtr); - // Alternate form of CCFrameRateController with unthrottled frame-rate. - explicit CCFrameRateController(CCThread*); - virtual ~CCFrameRateController(); - - void setClient(CCFrameRateControllerClient* client) { m_client = client; } - - void setActive(bool); - - // Use the following methods to adjust target frame rate. - // - // Multiple frames can be in-progress, but for every didBeginFrame, a - // didFinishFrame should be posted. - // - // If the rendering pipeline crashes, call didAbortAllPendingFrames. - void didBeginFrame(); - void didFinishFrame(); - void didAbortAllPendingFrames(); - void setMaxFramesPending(int); // 0 for unlimited. - - // This returns null for unthrottled frame-rate. - base::TimeTicks nextTickTime(); - - void setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval); - void setSwapBuffersCompleteSupported(bool); - -protected: - friend class CCFrameRateControllerTimeSourceAdapter; - void onTimerTick(); - - void postManualTick(); - - // CCTimerClient implementation (used for unthrottled frame-rate). - virtual void onTimerFired() OVERRIDE; - - CCFrameRateControllerClient* m_client; - int m_numFramesPending; - int m_maxFramesPending; - RefPtr m_timeSource; - scoped_ptr m_timeSourceClientAdapter; - bool m_active; - bool m_swapBuffersCompleteSupported; - - // Members for unthrottled frame-rate. - bool m_isTimeSourceThrottling; - scoped_ptr m_manualTicker; -}; - -} // namespace cc - -#endif // CCFrameRateController_h +// Temporary forwarding header +#include "cc/frame_rate_controller.h" diff --git a/cc/CCFrameRateCounter.h b/cc/CCFrameRateCounter.h index 76b42242565b74..1a4708c7c42869 100644 --- a/cc/CCFrameRateCounter.h +++ b/cc/CCFrameRateCounter.h @@ -2,71 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCFrameRateCounter_h -#define CCFrameRateCounter_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "base/basictypes.h" -#include - -namespace cc { - -// This class maintains a history of timestamps, and provides functionality to -// intelligently compute average frames per second (and standard deviation). -class CCFrameRateCounter { -public: - static PassOwnPtr create() - { - return adoptPtr(new CCFrameRateCounter()); - } - - void markBeginningOfFrame(double timestamp); - void markEndOfFrame(); - int currentFrameNumber() const { return m_currentFrameNumber; } - void getAverageFPSAndStandardDeviation(double& averageFPS, double& standardDeviation) const; - int timeStampHistorySize() const { return kTimeStampHistorySize; } - - // n = 0 returns the oldest frame retained in the history, - // while n = timeStampHistorySize() - 1 returns the timestamp most recent frame. - double timeStampOfRecentFrame(int /* n */); - - // This is a heuristic that can be used to ignore frames in a reasonable way. Returns - // true if the given frame interval is too fast or too slow, based on constant thresholds. - bool isBadFrameInterval(double intervalBetweenConsecutiveFrames) const; - - int droppedFrameCount() const { return m_droppedFrameCount; } - -private: - CCFrameRateCounter(); - - double frameInterval(int frameNumber) const; - int frameIndex(int frameNumber) const; - bool isBadFrame(int frameNumber) const; - - // Two thresholds (measured in seconds) that describe what is considered to be a "no-op frame" that should not be counted. - // - if the frame is too fast, then given our compositor implementation, the frame probably was a no-op and did not draw. - // - if the frame is too slow, then there is probably not animating content, so we should not pollute the average. - static const double kFrameTooFast; - static const double kFrameTooSlow; - - // If a frame takes longer than this threshold (measured in seconds) then we - // (naively) assume that it missed a screen refresh; that is, we dropped a frame. - // FIXME: Determine this threshold based on monitor refresh rate, crbug.com/138642. - static const double kDroppedFrameTime; - - static const int kTimeStampHistorySize = 120; - - int m_currentFrameNumber; - double m_timeStampHistory[kTimeStampHistorySize]; - - int m_droppedFrameCount; - - DISALLOW_COPY_AND_ASSIGN(CCFrameRateCounter); -}; - -} // namespace cc - -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/frame_rate_counter.h" diff --git a/cc/CCGraphicsContext.h b/cc/CCGraphicsContext.h index 6eb5b3407cbd07..1193f1f82ceee8 100644 --- a/cc/CCGraphicsContext.h +++ b/cc/CCGraphicsContext.h @@ -2,17 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCGraphicsContext_h -#define CCGraphicsContext_h - -#include -#include - -namespace cc { - -// FIXME: rename fully to CCOutputSurface. -typedef WebKit::WebCompositorOutputSurface CCGraphicsContext; - -} // namespace cc - -#endif // CCGraphicsContext_h +// Temporary forwarding header +#include "cc/graphics_context.h" diff --git a/cc/CCHeadsUpDisplayLayerImpl.h b/cc/CCHeadsUpDisplayLayerImpl.h index 47e7cfe73e4252..ec7b16067990b1 100644 --- a/cc/CCHeadsUpDisplayLayerImpl.h +++ b/cc/CCHeadsUpDisplayLayerImpl.h @@ -2,56 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCHeadsUpDisplayLayerImpl_h -#define CCHeadsUpDisplayLayerImpl_h - -#include "base/memory/scoped_ptr.h" -#include "CCFontAtlas.h" -#include "CCLayerImpl.h" -#include "CCScopedTexture.h" - -class SkCanvas; - -namespace cc { - -class CCDebugRectHistory; -class CCFontAtlas; -class CCFrameRateCounter; - -class CCHeadsUpDisplayLayerImpl : public CCLayerImpl { -public: - static scoped_ptr create(int id) - { - return make_scoped_ptr(new CCHeadsUpDisplayLayerImpl(id)); - } - virtual ~CCHeadsUpDisplayLayerImpl(); - - void setFontAtlas(scoped_ptr); - - virtual void willDraw(CCResourceProvider*) OVERRIDE; - virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; - void updateHudTexture(CCResourceProvider*); - virtual void didDraw(CCResourceProvider*) OVERRIDE; - - virtual void didLoseContext() OVERRIDE; - - virtual bool layerIsAlwaysDamaged() const OVERRIDE; - -private: - explicit CCHeadsUpDisplayLayerImpl(int); - - virtual const char* layerTypeAsString() const OVERRIDE; - - void drawHudContents(SkCanvas*); - void drawFPSCounter(SkCanvas*, CCFrameRateCounter*, int top, int height); - void drawFPSCounterText(SkCanvas*, CCFrameRateCounter*, int top, int width, int height); - void drawDebugRects(SkCanvas*, CCDebugRectHistory*); - - scoped_ptr m_fontAtlas; - OwnPtr m_hudTexture; - OwnPtr m_hudCanvas; -}; - -} // namespace cc - -#endif // CCHeadsUpDisplayLayerImpl_h +// Temporary forwarding header +#include "cc/heads_up_display_layer_impl.h" diff --git a/cc/CCIOSurfaceDrawQuad.h b/cc/CCIOSurfaceDrawQuad.h index bb5b028291394a..e0faa3e20eeb09 100644 --- a/cc/CCIOSurfaceDrawQuad.h +++ b/cc/CCIOSurfaceDrawQuad.h @@ -2,41 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCIOSurfaceDrawQuad_h -#define CCIOSurfaceDrawQuad_h - -#include "CCDrawQuad.h" -#include "IntSize.h" -#include "base/memory/scoped_ptr.h" - -namespace cc { - -#pragma pack(push, 4) - -class CCIOSurfaceDrawQuad : public CCDrawQuad { -public: - enum Orientation { - Flipped, - Unflipped - }; - - static scoped_ptr create(const CCSharedQuadState*, const IntRect&, const IntSize& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation); - - IntSize ioSurfaceSize() const { return m_ioSurfaceSize; } - unsigned ioSurfaceTextureId() const { return m_ioSurfaceTextureId; } - Orientation orientation() const { return m_orientation; } - - static const CCIOSurfaceDrawQuad* materialCast(const CCDrawQuad*); -private: - CCIOSurfaceDrawQuad(const CCSharedQuadState*, const IntRect&, const IntSize& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation); - - IntSize m_ioSurfaceSize; - unsigned m_ioSurfaceTextureId; - Orientation m_orientation; -}; - -#pragma pack(pop) - -} - -#endif +// Temporary forwarding header +#include "cc/io_surface_draw_quad.h" diff --git a/cc/CCIOSurfaceLayerImpl.h b/cc/CCIOSurfaceLayerImpl.h index 238e27e4d28f3e..6cbf984aaa635e 100644 --- a/cc/CCIOSurfaceLayerImpl.h +++ b/cc/CCIOSurfaceLayerImpl.h @@ -2,42 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCIOSurfaceLayerImpl_h -#define CCIOSurfaceLayerImpl_h - -#include "CCLayerImpl.h" -#include "IntSize.h" - -namespace cc { - -class CCIOSurfaceLayerImpl : public CCLayerImpl { -public: - static scoped_ptr create(int id) - { - return make_scoped_ptr(new CCIOSurfaceLayerImpl(id)); - } - virtual ~CCIOSurfaceLayerImpl(); - - void setIOSurfaceProperties(unsigned ioSurfaceId, const IntSize&); - - virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; - - virtual void willDraw(CCResourceProvider*) OVERRIDE; - virtual void didLoseContext() OVERRIDE; - - virtual void dumpLayerProperties(std::string*, int indent) const OVERRIDE; - -private: - explicit CCIOSurfaceLayerImpl(int); - - virtual const char* layerTypeAsString() const OVERRIDE; - - unsigned m_ioSurfaceId; - IntSize m_ioSurfaceSize; - bool m_ioSurfaceChanged; - unsigned m_ioSurfaceTextureId; -}; - -} - -#endif // CCIOSurfaceLayerImpl_h +// Temporary forwarding header +#include "cc/io_surface_layer_impl.h" diff --git a/cc/CCInputHandler.h b/cc/CCInputHandler.h index 7188cabafae213..88f1b37bef3751 100644 --- a/cc/CCInputHandler.h +++ b/cc/CCInputHandler.h @@ -1,83 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCInputHandler_h -#define CCInputHandler_h - -#include "base/basictypes.h" -#include - -namespace cc { - -class IntPoint; -class IntSize; - -// The CCInputHandler is a way for the embedders to interact with -// the impl thread side of the compositor implementation. -// -// There is one CCInputHandler for every CCLayerTreeHost. It is -// created on the main thread and used only on the impl thread. -// -// The CCInputHandler is constructed with a CCInputHandlerClient, which is the -// interface by which the handler can manipulate the LayerTree. -class CCInputHandlerClient { -public: - enum ScrollStatus { ScrollOnMainThread, ScrollStarted, ScrollIgnored }; - enum ScrollInputType { Gesture, Wheel }; - - // Selects a layer to be scrolled at a given point in window coordinates. - // Returns ScrollStarted if the layer at the coordinates can be scrolled, - // ScrollOnMainThread if the scroll event should instead be delegated to the - // main thread, or ScrollIgnored if there is nothing to be scrolled at the - // given coordinates. - virtual ScrollStatus scrollBegin(const IntPoint&, ScrollInputType) = 0; - - // Scroll the selected layer starting at the given window coordinate. If - // there is no room to move the layer in the requested direction, its first - // ancestor layer that can be scrolled will be moved instead. Should only be - // called if scrollBegin() returned ScrollStarted. - virtual void scrollBy(const IntPoint&, const IntSize&) = 0; - - // Stop scrolling the selected layer. Should only be called if scrollBegin() - // returned ScrollStarted. - virtual void scrollEnd() = 0; - - virtual void pinchGestureBegin() = 0; - virtual void pinchGestureUpdate(float magnifyDelta, const IntPoint& anchor) = 0; - virtual void pinchGestureEnd() = 0; - - virtual void startPageScaleAnimation(const IntSize& targetPosition, - bool anchorPoint, - float pageScale, - double startTime, - double duration) = 0; - - // Request another callback to CCInputHandler::animate(). - virtual void scheduleAnimation() = 0; - -protected: - CCInputHandlerClient() { } - virtual ~CCInputHandlerClient() { } - -private: - DISALLOW_COPY_AND_ASSIGN(CCInputHandlerClient); -}; - -class CCInputHandler { -public: - virtual ~CCInputHandler() { } - - virtual void bindToClient(CCInputHandlerClient*) = 0; - virtual void animate(double monotonicTime) = 0; - -protected: - CCInputHandler() { } - -private: - DISALLOW_COPY_AND_ASSIGN(CCInputHandler); -}; - -} - -#endif +// Temporary forwarding header +#include "cc/input_handler.h" diff --git a/cc/CCKeyframedAnimationCurve.h b/cc/CCKeyframedAnimationCurve.h index 066e5c64da4352..3cd919d59b298f 100644 --- a/cc/CCKeyframedAnimationCurve.h +++ b/cc/CCKeyframedAnimationCurve.h @@ -2,108 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCKeyframedAnimationCurve_h -#define CCKeyframedAnimationCurve_h - -#include "CCAnimationCurve.h" -#include "CCTimingFunction.h" -#include "scoped_ptr_vector.h" -#include - -namespace cc { - -class CCKeyframe { -public: - double time() const; - const CCTimingFunction* timingFunction() const; - -protected: - CCKeyframe(double time, scoped_ptr); - virtual ~CCKeyframe(); - -private: - double m_time; - scoped_ptr m_timingFunction; -}; - -class CCFloatKeyframe : public CCKeyframe { -public: - static scoped_ptr create(double time, float value, scoped_ptr); - virtual ~CCFloatKeyframe(); - - float value() const; - - scoped_ptr clone() const; - -private: - CCFloatKeyframe(double time, float value, scoped_ptr); - - float m_value; -}; - -class CCTransformKeyframe : public CCKeyframe { -public: - static scoped_ptr create(double time, const WebKit::WebTransformOperations& value, scoped_ptr); - virtual ~CCTransformKeyframe(); - - const WebKit::WebTransformOperations& value() const; - - scoped_ptr clone() const; - -private: - CCTransformKeyframe(double time, const WebKit::WebTransformOperations& value, scoped_ptr); - - WebKit::WebTransformOperations m_value; -}; - -class CCKeyframedFloatAnimationCurve : public CCFloatAnimationCurve { -public: - // It is required that the keyframes be sorted by time. - static scoped_ptr create(); - - virtual ~CCKeyframedFloatAnimationCurve(); - - void addKeyframe(scoped_ptr); - - // CCAnimationCurve implementation - virtual double duration() const OVERRIDE; - virtual scoped_ptr clone() const OVERRIDE; - - // CCFloatAnimationCurve implementation - virtual float getValue(double t) const OVERRIDE; - -private: - CCKeyframedFloatAnimationCurve(); - - // Always sorted in order of increasing time. No two keyframes have the - // same time. - ScopedPtrVector m_keyframes; -}; - -class CCKeyframedTransformAnimationCurve : public CCTransformAnimationCurve { -public: - // It is required that the keyframes be sorted by time. - static scoped_ptr create(); - - virtual ~CCKeyframedTransformAnimationCurve(); - - void addKeyframe(scoped_ptr); - - // CCAnimationCurve implementation - virtual double duration() const OVERRIDE; - virtual scoped_ptr clone() const OVERRIDE; - - // CCTransformAnimationCurve implementation - virtual WebKit::WebTransformationMatrix getValue(double t) const OVERRIDE; - -private: - CCKeyframedTransformAnimationCurve(); - - // Always sorted in order of increasing time. No two keyframes have the - // same time. - ScopedPtrVector m_keyframes; -}; - -} // namespace cc - -#endif // CCKeyframedAnimationCurve_h +// Temporary forwarding header +#include "cc/keyframed_animation_curve.h" diff --git a/cc/CCLayerAnimationController.h b/cc/CCLayerAnimationController.h index 2fdb91c611aa3f..9f44af2023015b 100644 --- a/cc/CCLayerAnimationController.h +++ b/cc/CCLayerAnimationController.h @@ -2,111 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCLayerAnimationController_h -#define CCLayerAnimationController_h - -#include "CCAnimationEvents.h" - -#include "base/basictypes.h" -#include "base/hash_tables.h" -#include "base/memory/scoped_ptr.h" -#include "cc/scoped_ptr_vector.h" - -namespace WebKit { -class WebTransformationMatrix; -} - -namespace cc { - -class Animation; -class IntSize; -class KeyframeValueList; - -class CCLayerAnimationControllerClient { -public: - virtual ~CCLayerAnimationControllerClient() { } - - virtual int id() const = 0; - virtual void setOpacityFromAnimation(float) = 0; - virtual float opacity() const = 0; - virtual void setTransformFromAnimation(const WebKit::WebTransformationMatrix&) = 0; - virtual const WebKit::WebTransformationMatrix& transform() const = 0; -}; - -class CCLayerAnimationController { -public: - static scoped_ptr create(CCLayerAnimationControllerClient*); - - virtual ~CCLayerAnimationController(); - - // These methods are virtual for testing. - virtual void addAnimation(scoped_ptr); - virtual void pauseAnimation(int animationId, double timeOffset); - virtual void removeAnimation(int animationId); - virtual void removeAnimation(int animationId, CCActiveAnimation::TargetProperty); - virtual void suspendAnimations(double monotonicTime); - virtual void resumeAnimations(double monotonicTime); - - // Ensures that the list of active animations on the main thread and the impl thread - // are kept in sync. This function does not take ownership of the impl thread controller. - virtual void pushAnimationUpdatesTo(CCLayerAnimationController*); - - void animate(double monotonicTime, CCAnimationEventsVector*); - - // Returns the active animation in the given group, animating the given property, if such an - // animation exists. - CCActiveAnimation* getActiveAnimation(int groupId, CCActiveAnimation::TargetProperty) const; - - // Returns the active animation animating the given property that is either running, or is - // next to run, if such an animation exists. - CCActiveAnimation* getActiveAnimation(CCActiveAnimation::TargetProperty) const; - - // Returns true if there are any animations that have neither finished nor aborted. - bool hasActiveAnimation() const; - - // Returns true if there is an animation currently animating the given property, or - // if there is an animation scheduled to animate this property in the future. - bool isAnimatingProperty(CCActiveAnimation::TargetProperty) const; - - // This is called in response to an animation being started on the impl thread. This - // function updates the corresponding main thread animation's start time. - void notifyAnimationStarted(const CCAnimationEvent&); - - // If a sync is forced, then the next time animation updates are pushed to the impl - // thread, all animations will be transferred. - void setForceSync() { m_forceSync = true; } - - void setClient(CCLayerAnimationControllerClient*); - -protected: - explicit CCLayerAnimationController(CCLayerAnimationControllerClient*); - -private: - typedef base::hash_set TargetProperties; - - void pushNewAnimationsToImplThread(CCLayerAnimationController*) const; - void removeAnimationsCompletedOnMainThread(CCLayerAnimationController*) const; - void pushPropertiesToImplThread(CCLayerAnimationController*) const; - void replaceImplThreadAnimations(CCLayerAnimationController*) const; - - void startAnimationsWaitingForNextTick(double monotonicTime, CCAnimationEventsVector*); - void startAnimationsWaitingForStartTime(double monotonicTime, CCAnimationEventsVector*); - void startAnimationsWaitingForTargetAvailability(double monotonicTime, CCAnimationEventsVector*); - void resolveConflicts(double monotonicTime); - void markAnimationsForDeletion(double monotonicTime, CCAnimationEventsVector*); - void purgeAnimationsMarkedForDeletion(); - - void tickAnimations(double monotonicTime); - - // If this is true, we force a sync to the impl thread. - bool m_forceSync; - - CCLayerAnimationControllerClient* m_client; - ScopedPtrVector m_activeAnimations; - - DISALLOW_COPY_AND_ASSIGN(CCLayerAnimationController); -}; - -} // namespace cc - -#endif // CCLayerAnimationController_h +// Temporary forwarding header +#include "cc/layer_animation_controller.h" diff --git a/cc/CCLayerImpl.h b/cc/CCLayerImpl.h index e34ccc86a03735..2f36527df274fd 100644 --- a/cc/CCLayerImpl.h +++ b/cc/CCLayerImpl.h @@ -1,399 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCLayerImpl_h -#define CCLayerImpl_h - -#include "base/memory/scoped_ptr.h" -#include "cc/scoped_ptr_vector.h" -#include "CCInputHandler.h" -#include "CCLayerAnimationController.h" -#include "CCRenderPass.h" -#include "CCRenderSurface.h" -#include "CCResourceProvider.h" -#include "CCSharedQuadState.h" -#include "FloatRect.h" -#include "IntRect.h" -#include "Region.h" -#include "SkColor.h" -#include -#include -#include -#include - -namespace cc { - -class CCLayerSorter; -class CCLayerTreeHostImpl; -class CCQuadSink; -class CCRenderer; -class CCScrollbarAnimationController; -class CCScrollbarLayerImpl; -class LayerChromium; - -struct CCAppendQuadsData; - -class CCLayerImpl : public CCLayerAnimationControllerClient { -public: - static scoped_ptr create(int id) - { - return make_scoped_ptr(new CCLayerImpl(id)); - } - - virtual ~CCLayerImpl(); - - // CCLayerAnimationControllerClient implementation. - virtual int id() const OVERRIDE; - virtual void setOpacityFromAnimation(float) OVERRIDE; - virtual float opacity() const OVERRIDE; - virtual void setTransformFromAnimation(const WebKit::WebTransformationMatrix&) OVERRIDE; - virtual const WebKit::WebTransformationMatrix& transform() const OVERRIDE; - - // Tree structure. - CCLayerImpl* parent() const { return m_parent; } - const ScopedPtrVector& children() const { return m_children; } - void addChild(scoped_ptr); - void removeFromParent(); - void removeAllChildren(); - - void setMaskLayer(scoped_ptr); - CCLayerImpl* maskLayer() const { return m_maskLayer.get(); } - - void setReplicaLayer(scoped_ptr); - CCLayerImpl* replicaLayer() const { return m_replicaLayer.get(); } - - bool hasMask() const { return m_maskLayer; } - bool hasReplica() const { return m_replicaLayer; } - bool replicaHasMask() const { return m_replicaLayer && (m_maskLayer || m_replicaLayer->m_maskLayer); } - - CCLayerTreeHostImpl* layerTreeHostImpl() const { return m_layerTreeHostImpl; } - void setLayerTreeHostImpl(CCLayerTreeHostImpl* hostImpl) { m_layerTreeHostImpl = hostImpl; } - - scoped_ptr createSharedQuadState() const; - // willDraw must be called before appendQuads. If willDraw is called, - // didDraw is guaranteed to be called before another willDraw or before - // the layer is destroyed. To enforce this, any class that overrides - // willDraw/didDraw must call the base class version. - virtual void willDraw(CCResourceProvider*); - virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) { } - virtual void didDraw(CCResourceProvider*); - - virtual CCResourceProvider::ResourceId contentsResourceId() const; - - virtual bool hasContributingDelegatedRenderPasses() const; - virtual CCRenderPass::Id firstContributingRenderPassId() const; - virtual CCRenderPass::Id nextContributingRenderPassId(CCRenderPass::Id) const; - - // Returns true if this layer has content to draw. - void setDrawsContent(bool); - bool drawsContent() const { return m_drawsContent; } - - bool forceRenderSurface() const { return m_forceRenderSurface; } - void setForceRenderSurface(bool force) { m_forceRenderSurface = force; } - - // Returns true if any of the layer's descendants has content to draw. - virtual bool descendantDrawsContent(); - - void setAnchorPoint(const FloatPoint&); - const FloatPoint& anchorPoint() const { return m_anchorPoint; } - - void setAnchorPointZ(float); - float anchorPointZ() const { return m_anchorPointZ; } - - void setBackgroundColor(SkColor); - SkColor backgroundColor() const { return m_backgroundColor; } - - void setFilters(const WebKit::WebFilterOperations&); - const WebKit::WebFilterOperations& filters() const { return m_filters; } - - void setBackgroundFilters(const WebKit::WebFilterOperations&); - const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; } - - void setMasksToBounds(bool); - bool masksToBounds() const { return m_masksToBounds; } - - void setContentsOpaque(bool); - bool contentsOpaque() const { return m_contentsOpaque; } - - void setOpacity(float); - bool opacityIsAnimating() const; - - void setPosition(const FloatPoint&); - const FloatPoint& position() const { return m_position; } - - void setIsContainerForFixedPositionLayers(bool isContainerForFixedPositionLayers) { m_isContainerForFixedPositionLayers = isContainerForFixedPositionLayers; } - bool isContainerForFixedPositionLayers() const { return m_isContainerForFixedPositionLayers; } - - void setFixedToContainerLayer(bool fixedToContainerLayer = true) { m_fixedToContainerLayer = fixedToContainerLayer;} - bool fixedToContainerLayer() const { return m_fixedToContainerLayer; } - - void setPreserves3D(bool); - bool preserves3D() const { return m_preserves3D; } - - void setUseParentBackfaceVisibility(bool useParentBackfaceVisibility) { m_useParentBackfaceVisibility = useParentBackfaceVisibility; } - bool useParentBackfaceVisibility() const { return m_useParentBackfaceVisibility; } - - void setUseLCDText(bool useLCDText) { m_useLCDText = useLCDText; } - bool useLCDText() const { return m_useLCDText; } - - void setSublayerTransform(const WebKit::WebTransformationMatrix&); - const WebKit::WebTransformationMatrix& sublayerTransform() const { return m_sublayerTransform; } - - // Debug layer border - visual effect only, do not change geometry/clipping/etc. - void setDebugBorderColor(SkColor); - SkColor debugBorderColor() const { return m_debugBorderColor; } - void setDebugBorderWidth(float); - float debugBorderWidth() const { return m_debugBorderWidth; } - bool hasDebugBorders() const; - - // Debug layer name. - void setDebugName(const std::string& debugName) { m_debugName = debugName; } - std::string debugName() const { return m_debugName; } - - CCRenderSurface* renderSurface() const { return m_renderSurface.get(); } - void createRenderSurface(); - void clearRenderSurface() { m_renderSurface.clear(); } - - float drawOpacity() const { return m_drawOpacity; } - void setDrawOpacity(float opacity) { m_drawOpacity = opacity; } - - bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; } - void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; } - - CCLayerImpl* renderTarget() const { ASSERT(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; } - void setRenderTarget(CCLayerImpl* target) { m_renderTarget = target; } - - void setBounds(const IntSize&); - const IntSize& bounds() const { return m_bounds; } - - const IntSize& contentBounds() const { return m_contentBounds; } - void setContentBounds(const IntSize&); - - const IntPoint& scrollPosition() const { return m_scrollPosition; } - void setScrollPosition(const IntPoint&); - - const IntSize& maxScrollPosition() const {return m_maxScrollPosition; } - void setMaxScrollPosition(const IntSize&); - - const FloatSize& scrollDelta() const { return m_scrollDelta; } - void setScrollDelta(const FloatSize&); - - const WebKit::WebTransformationMatrix& implTransform() const { return m_implTransform; } - void setImplTransform(const WebKit::WebTransformationMatrix& transform); - - const IntSize& sentScrollDelta() const { return m_sentScrollDelta; } - void setSentScrollDelta(const IntSize& sentScrollDelta) { m_sentScrollDelta = sentScrollDelta; } - - // Returns the delta of the scroll that was outside of the bounds of the initial scroll - FloatSize scrollBy(const FloatSize& scroll); - - bool scrollable() const { return m_scrollable; } - void setScrollable(bool scrollable) { m_scrollable = scrollable; } - - bool shouldScrollOnMainThread() const { return m_shouldScrollOnMainThread; } - void setShouldScrollOnMainThread(bool shouldScrollOnMainThread) { m_shouldScrollOnMainThread = shouldScrollOnMainThread; } - - bool haveWheelEventHandlers() const { return m_haveWheelEventHandlers; } - void setHaveWheelEventHandlers(bool haveWheelEventHandlers) { m_haveWheelEventHandlers = haveWheelEventHandlers; } - - const Region& nonFastScrollableRegion() const { return m_nonFastScrollableRegion; } - void setNonFastScrollableRegion(const Region& region) { m_nonFastScrollableRegion = region; } - - void setDrawCheckerboardForMissingTiles(bool checkerboard) { m_drawCheckerboardForMissingTiles = checkerboard; } - bool drawCheckerboardForMissingTiles() const; - - CCInputHandlerClient::ScrollStatus tryScroll(const IntPoint& viewportPoint, CCInputHandlerClient::ScrollInputType) const; - - const IntRect& visibleContentRect() const { return m_visibleContentRect; } - void setVisibleContentRect(const IntRect& visibleContentRect) { m_visibleContentRect = visibleContentRect; } - - bool doubleSided() const { return m_doubleSided; } - void setDoubleSided(bool); - - void setTransform(const WebKit::WebTransformationMatrix&); - bool transformIsAnimating() const; - - const WebKit::WebTransformationMatrix& drawTransform() const { return m_drawTransform; } - void setDrawTransform(const WebKit::WebTransformationMatrix& matrix) { m_drawTransform = matrix; } - const WebKit::WebTransformationMatrix& screenSpaceTransform() const { return m_screenSpaceTransform; } - void setScreenSpaceTransform(const WebKit::WebTransformationMatrix& matrix) { m_screenSpaceTransform = matrix; } - - bool drawTransformIsAnimating() const { return m_drawTransformIsAnimating; } - void setDrawTransformIsAnimating(bool animating) { m_drawTransformIsAnimating = animating; } - bool screenSpaceTransformIsAnimating() const { return m_screenSpaceTransformIsAnimating; } - void setScreenSpaceTransformIsAnimating(bool animating) { m_screenSpaceTransformIsAnimating = animating; } - - const IntRect& drawableContentRect() const { return m_drawableContentRect; } - void setDrawableContentRect(const IntRect& rect) { m_drawableContentRect = rect; } - const FloatRect& updateRect() const { return m_updateRect; } - void setUpdateRect(const FloatRect& updateRect) { m_updateRect = updateRect; } - - std::string layerTreeAsText() const; - - void setStackingOrderChanged(bool); - - bool layerPropertyChanged() const { return m_layerPropertyChanged || layerIsAlwaysDamaged(); } - bool layerSurfacePropertyChanged() const; - - void resetAllChangeTrackingForSubtree(); - - virtual bool layerIsAlwaysDamaged() const; - - CCLayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); } - - virtual Region visibleContentOpaqueRegion() const; - - // Indicates that the context previously used to render this layer - // was lost and that a new one has been created. Won't be called - // until the new context has been created successfully. - virtual void didLoseContext(); - - CCScrollbarAnimationController* scrollbarAnimationController() const { return m_scrollbarAnimationController.get(); } - - CCScrollbarLayerImpl* horizontalScrollbarLayer() const; - void setHorizontalScrollbarLayer(CCScrollbarLayerImpl*); - - CCScrollbarLayerImpl* verticalScrollbarLayer() const; - void setVerticalScrollbarLayer(CCScrollbarLayerImpl*); - -protected: - explicit CCLayerImpl(int); - - void appendDebugBorderQuad(CCQuadSink&, const CCSharedQuadState*, CCAppendQuadsData&) const; - - IntRect layerRectToContentRect(const WebKit::WebRect& layerRect); - - virtual void dumpLayerProperties(std::string*, int indent) const; - static std::string indentString(int indent); - -private: - void setParent(CCLayerImpl* parent) { m_parent = parent; } - friend class TreeSynchronizer; - void clearChildList(); // Warning: This does not preserve tree structure invariants and so is only exposed to the tree synchronizer. - - void noteLayerPropertyChangedForSubtree(); - - // Note carefully this does not affect the current layer. - void noteLayerPropertyChangedForDescendants(); - - virtual const char* layerTypeAsString() const; - - void dumpLayer(std::string*, int indent) const; - - // Properties internal to CCLayerImpl - CCLayerImpl* m_parent; - ScopedPtrVector m_children; - // m_maskLayer can be temporarily stolen during tree sync, we need this ID to confirm newly assigned layer is still the previous one - int m_maskLayerId; - scoped_ptr m_maskLayer; - int m_replicaLayerId; // ditto - scoped_ptr m_replicaLayer; - int m_layerId; - CCLayerTreeHostImpl* m_layerTreeHostImpl; - - // Properties synchronized from the associated LayerChromium. - FloatPoint m_anchorPoint; - float m_anchorPointZ; - IntSize m_bounds; - IntSize m_contentBounds; - IntPoint m_scrollPosition; - bool m_scrollable; - bool m_shouldScrollOnMainThread; - bool m_haveWheelEventHandlers; - Region m_nonFastScrollableRegion; - SkColor m_backgroundColor; - - // Whether the "back" of this layer should draw. - bool m_doubleSided; - - // Tracks if drawing-related properties have changed since last redraw. - bool m_layerPropertyChanged; - - // Indicates that a property has changed on this layer that would not - // affect the pixels on its target surface, but would require redrawing - // but would require redrawing the targetSurface onto its ancestor targetSurface. - // For layers that do not own a surface this flag acts as m_layerPropertyChanged. - bool m_layerSurfacePropertyChanged; - - // Uses layer's content space. - IntRect m_visibleContentRect; - bool m_masksToBounds; - bool m_contentsOpaque; - float m_opacity; - FloatPoint m_position; - bool m_preserves3D; - bool m_useParentBackfaceVisibility; - bool m_drawCheckerboardForMissingTiles; - WebKit::WebTransformationMatrix m_sublayerTransform; - WebKit::WebTransformationMatrix m_transform; - bool m_useLCDText; - - bool m_drawsContent; - bool m_forceRenderSurface; - - // Set for the layer that other layers are fixed to. - bool m_isContainerForFixedPositionLayers; - // This is true if the layer should be fixed to the closest ancestor container. - bool m_fixedToContainerLayer; - - FloatSize m_scrollDelta; - IntSize m_sentScrollDelta; - IntSize m_maxScrollPosition; - WebKit::WebTransformationMatrix m_implTransform; - - // The layer whose coordinate space this layer draws into. This can be - // either the same layer (m_renderTarget == this) or an ancestor of this - // layer. - CCLayerImpl* m_renderTarget; - - // The global depth value of the center of the layer. This value is used - // to sort layers from back to front. - float m_drawDepth; - float m_drawOpacity; - bool m_drawOpacityIsAnimating; - - // Debug borders. - SkColor m_debugBorderColor; - float m_debugBorderWidth; - - // Debug layer name. - std::string m_debugName; - - WebKit::WebFilterOperations m_filters; - WebKit::WebFilterOperations m_backgroundFilters; - - WebKit::WebTransformationMatrix m_drawTransform; - WebKit::WebTransformationMatrix m_screenSpaceTransform; - bool m_drawTransformIsAnimating; - bool m_screenSpaceTransformIsAnimating; - -#ifndef NDEBUG - bool m_betweenWillDrawAndDidDraw; -#endif - - // Render surface associated with this layer. The layer and its descendants - // will render to this surface. - OwnPtr m_renderSurface; - - // Hierarchical bounding rect containing the layer and its descendants. - // Uses target surface's space. - IntRect m_drawableContentRect; - - // Rect indicating what was repainted/updated during update. - // Note that plugin layers bypass this and leave it empty. - // Uses layer's content space. - FloatRect m_updateRect; - - // Manages animations for this layer. - scoped_ptr m_layerAnimationController; - - // Manages scrollbars for this layer - OwnPtr m_scrollbarAnimationController; -}; - -void sortLayers(std::vector::iterator first, std::vector::iterator end, CCLayerSorter*); - -} - -#endif // CCLayerImpl_h +// Temporary forwarding header +#include "cc/layer_impl.h" diff --git a/cc/CCLayerIterator.h b/cc/CCLayerIterator.h index 4d36080d3060a3..1b0f9d4d5b1bbb 100644 --- a/cc/CCLayerIterator.h +++ b/cc/CCLayerIterator.h @@ -2,207 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCLayerIterator_h -#define CCLayerIterator_h - -#include "CCLayerTreeHostCommon.h" - -#include "base/memory/ref_counted.h" - -namespace cc { - -// These classes provide means to iterate over the RenderSurface-Layer tree. - -// Example code follows, for a tree of LayerChromium/RenderSurfaceChromium objects. See below for details. -// -// void doStuffOnLayers(const std::vector >& renderSurfaceLayerList) -// { -// typedef CCLayerIterator CCLayerIteratorType; -// -// CCLayerIteratorType end = CCLayerIteratorType::end(&renderSurfaceLayerList); -// for (CCLayerIteratorType it = CCLayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) { -// // Only one of these will be true -// if (it.representsTargetRenderSurface()) -// foo(*it); // *it is a layer representing a target RenderSurface -// if (it.representsContributingRenderSurface()) -// bar(*it); // *it is a layer representing a RenderSurface that contributes to the layer's target RenderSurface -// if (it.representsItself()) -// baz(*it); // *it is a layer representing itself, as it contributes to its own target RenderSurface -// } -// } - -// A RenderSurface R may be referred to in one of two different contexts. One RenderSurface is "current" at any time, for -// whatever operation is being performed. This current surface is referred to as a target surface. For example, when R is -// being painted it would be the target surface. Once R has been painted, its contents may be included into another -// surface S. While S is considered the target surface when it is being painted, R is called a contributing surface -// in this context as it contributes to the content of the target surface S. -// -// The iterator's current position in the tree always points to some layer. The state of the iterator indicates the role of the -// layer, and will be one of the following three states. A single layer L will appear in the iteration process in at least one, -// and possibly all, of these states. -// 1. Representing the target surface: The iterator in this state, pointing at layer L, indicates that the target RenderSurface -// is now the surface owned by L. This will occur exactly once for each RenderSurface in the tree. -// 2. Representing a contributing surface: The iterator in this state, pointing at layer L, refers to the RenderSurface owned -// by L as a contributing surface, without changing the current target RenderSurface. -// 3. Representing itself: The iterator in this state, pointing at layer L, refers to the layer itself, as a child of the -// current target RenderSurface. -// -// The BackToFront iterator will return a layer representing the target surface before returning layers representing themselves -// as children of the current target surface. Whereas the FrontToBack ordering will iterate over children layers of a surface -// before the layer representing the surface as a target surface. -// -// To use the iterators: -// -// Create a stepping iterator and end iterator by calling CCLayerIterator::begin() and CCLayerIterator::end() and passing in the -// list of layers owning target RenderSurfaces. Step through the tree by incrementing the stepping iterator while it is != to -// the end iterator. At each step the iterator knows what the layer is representing, and you can query the iterator to decide -// what actions to perform with the layer given what it represents. - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -// Non-templated constants -struct CCLayerIteratorValue { - static const int InvalidTargetRenderSurfaceLayerIndex = -1; - // This must be -1 since the iterator action code assumes that this value can be - // reached by subtracting one from the position of the first layer in the current - // target surface's child layer list, which is 0. - static const int LayerIndexRepresentingTargetRenderSurface = -1; -}; - -// The position of a layer iterator that is independent of its many template types. -template -struct CCLayerIteratorPosition { - bool representsTargetRenderSurface; - bool representsContributingRenderSurface; - bool representsItself; - LayerType* targetRenderSurfaceLayer; - LayerType* currentLayer; -}; - -// An iterator class for walking over layers in the RenderSurface-Layer tree. -template -class CCLayerIterator { - typedef CCLayerIterator CCLayerIteratorType; - -public: - CCLayerIterator() : m_renderSurfaceLayerList(0) { } - - static CCLayerIteratorType begin(const LayerList* renderSurfaceLayerList) { return CCLayerIteratorType(renderSurfaceLayerList, true); } - static CCLayerIteratorType end(const LayerList* renderSurfaceLayerList) { return CCLayerIteratorType(renderSurfaceLayerList, false); } - - CCLayerIteratorType& operator++() { m_actions.next(*this); return *this; } - bool operator==(const CCLayerIterator& other) const - { - return m_targetRenderSurfaceLayerIndex == other.m_targetRenderSurfaceLayerIndex - && m_currentLayerIndex == other.m_currentLayerIndex; - } - bool operator!=(const CCLayerIteratorType& other) const { return !(*this == other); } - - LayerType* operator->() const { return currentLayer(); } - LayerType* operator*() const { return currentLayer(); } - - bool representsTargetRenderSurface() const { return currentLayerRepresentsTargetRenderSurface(); } - bool representsContributingRenderSurface() const { return !representsTargetRenderSurface() && currentLayerRepresentsContributingRenderSurface(); } - bool representsItself() const { return !representsTargetRenderSurface() && !representsContributingRenderSurface(); } - - LayerType* targetRenderSurfaceLayer() const { return getRawPtr((*m_renderSurfaceLayerList)[m_targetRenderSurfaceLayerIndex]); } - - operator const CCLayerIteratorPosition() const - { - CCLayerIteratorPosition position; - position.representsTargetRenderSurface = representsTargetRenderSurface(); - position.representsContributingRenderSurface = representsContributingRenderSurface(); - position.representsItself = representsItself(); - position.targetRenderSurfaceLayer = targetRenderSurfaceLayer(); - position.currentLayer = currentLayer(); - return position; - } - -private: - CCLayerIterator(const LayerList* renderSurfaceLayerList, bool start) - : m_renderSurfaceLayerList(renderSurfaceLayerList) - , m_targetRenderSurfaceLayerIndex(0) - { - for (size_t i = 0; i < renderSurfaceLayerList->size(); ++i) { - if (!(*renderSurfaceLayerList)[i]->renderSurface()) { - ASSERT_NOT_REACHED(); - m_actions.end(*this); - return; - } - } - - if (start && !renderSurfaceLayerList->empty()) - m_actions.begin(*this); - else - m_actions.end(*this); - } - - inline static LayerChromium* getRawPtr(const scoped_refptr& ptr) { return ptr.get(); } - inline static CCLayerImpl* getRawPtr(CCLayerImpl* ptr) { return ptr; } - - inline LayerType* currentLayer() const { return currentLayerRepresentsTargetRenderSurface() ? targetRenderSurfaceLayer() : getRawPtr(targetRenderSurfaceChildren()[m_currentLayerIndex]); } - - inline bool currentLayerRepresentsContributingRenderSurface() const { return CCLayerTreeHostCommon::renderSurfaceContributesToTarget(currentLayer(), targetRenderSurfaceLayer()->id()); } - inline bool currentLayerRepresentsTargetRenderSurface() const { return m_currentLayerIndex == CCLayerIteratorValue::LayerIndexRepresentingTargetRenderSurface; } - - inline RenderSurfaceType* targetRenderSurface() const { return targetRenderSurfaceLayer()->renderSurface(); } - inline const LayerList& targetRenderSurfaceChildren() const { return targetRenderSurface()->layerList(); } - - IteratorActionType m_actions; - const LayerList* m_renderSurfaceLayerList; - - // The iterator's current position. - - // A position in the renderSurfaceLayerList. This points to a layer which owns the current target surface. - // This is a value from 0 to n-1 (n = size of renderSurfaceLayerList = number of surfaces). A value outside of - // this range (for example, CCLayerIteratorValue::InvalidTargetRenderSurfaceLayerIndex) is used to - // indicate a position outside the bounds of the tree. - int m_targetRenderSurfaceLayerIndex; - // A position in the list of layers that are children of the current target surface. When pointing to one of - // these layers, this is a value from 0 to n-1 (n = number of children). Since the iterator must also stop at - // the layers representing the target surface, this is done by setting the currentLayerIndex to a value of - // CCLayerIteratorValue::LayerRepresentingTargetRenderSurface. - int m_currentLayerIndex; - - friend struct CCLayerIteratorActions; -}; - -// Orderings for iterating over the RenderSurface-Layer tree. -struct CCLayerIteratorActions { - // Walks layers sorted by z-order from back to front. - class BackToFront { - public: - template - void begin(CCLayerIterator&); - - template - void end(CCLayerIterator&); - - template - void next(CCLayerIterator&); - - private: - int m_highestTargetRenderSurfaceLayer; - }; - - // Walks layers sorted by z-order from front to back - class FrontToBack { - public: - template - void begin(CCLayerIterator&); - - template - void end(CCLayerIterator&); - - template - void next(CCLayerIterator&); - - private: - template - void goToHighestInSubtree(CCLayerIterator&); - }; -}; - -} // namespace cc - -#endif +// Temporary forwarding header +#include "cc/layer_iterator.h" diff --git a/cc/CCLayerQuad.h b/cc/CCLayerQuad.h index 8be296fbf3c5a9..813ee03471c3cd 100644 --- a/cc/CCLayerQuad.h +++ b/cc/CCLayerQuad.h @@ -1,106 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef CCLayerQuad_h -#define CCLayerQuad_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "FloatPoint3D.h" -#include "FloatQuad.h" - -static const float kAntiAliasingInflateDistance = 0.5f; - -namespace cc { - -class CCLayerQuad { -public: - class Edge { - public: - Edge() - : m_x(0) - , m_y(0) - , m_z(0) - { - } - Edge(const FloatPoint&, const FloatPoint&); - - float x() const { return m_x; } - float y() const { return m_y; } - float z() const { return m_z; } - - void setX(float x) { m_x = x; } - void setY(float y) { m_y = y; } - void setZ(float z) { m_z = z; } - void set(float x, float y, float z) - { - m_x = x; - m_y = y; - m_z = z; - } - - void moveX(float dx) { m_x += dx; } - void moveY(float dy) { m_y += dy; } - void moveZ(float dz) { m_z += dz; } - void move(float dx, float dy, float dz) - { - m_x += dx; - m_y += dy; - m_z += dz; - } - - void scaleX(float sx) { m_x *= sx; } - void scaleY(float sy) { m_y *= sy; } - void scaleZ(float sz) { m_z *= sz; } - void scale(float sx, float sy, float sz) - { - m_x *= sx; - m_y *= sy; - m_z *= sz; - } - void scale(float s) { scale(s, s, s); } - - FloatPoint intersect(const Edge& e) const - { - return FloatPoint( - (y() * e.z() - e.y() * z()) / (x() * e.y() - e.x() * y()), - (x() * e.z() - e.x() * z()) / (e.x() * y() - x() * e.y())); - } - - private: - float m_x; - float m_y; - float m_z; - }; - - CCLayerQuad(const Edge& left, const Edge& top, const Edge& right, const Edge& bottom); - CCLayerQuad(const FloatQuad&); - - Edge left() const { return m_left; } - Edge top() const { return m_top; } - Edge right() const { return m_right; } - Edge bottom() const { return m_bottom; } - - void inflateX(float dx) { m_left.moveZ(dx); m_right.moveZ(dx); } - void inflateY(float dy) { m_top.moveZ(dy); m_bottom.moveZ(dy); } - void inflate(float d) { inflateX(d); inflateY(d); } - void inflateAntiAliasingDistance() { inflate(kAntiAliasingInflateDistance); } - - FloatQuad floatQuad() const; - - void toFloatArray(float[12]) const; - -private: - Edge m_left; - Edge m_top; - Edge m_right; - Edge m_bottom; -}; - -} - -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/layer_quad.h" diff --git a/cc/CCLayerSorter.h b/cc/CCLayerSorter.h index d4ca664abbbbf3..a2fd49c3999d91 100644 --- a/cc/CCLayerSorter.h +++ b/cc/CCLayerSorter.h @@ -1,92 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCLayerSorter_h -#define CCLayerSorter_h - -#include "base/basictypes.h" -#include "CCLayerImpl.h" -#include "FloatPoint3D.h" -#include "FloatQuad.h" -#include "FloatRect.h" -#include -#include -#include - -namespace WebKit { -class WebTransformationMatrix; -} - -namespace cc { - -class CCLayerSorter { -public: - CCLayerSorter(); - ~CCLayerSorter(); - - typedef std::vector LayerList; - - void sort(LayerList::iterator first, LayerList::iterator last); - - // Holds various useful properties derived from a layer's 3D outline. - struct LayerShape { - LayerShape(); - LayerShape(float width, float height, const WebKit::WebTransformationMatrix& drawTransform); - - float layerZFromProjectedPoint(const FloatPoint&) const; - - FloatPoint3D layerNormal; - FloatPoint3D transformOrigin; - FloatQuad projectedQuad; - FloatRect projectedBounds; - }; - - enum ABCompareResult { - ABeforeB, - BBeforeA, - None - }; - - static ABCompareResult checkOverlap(LayerShape*, LayerShape*, float zThreshold, float& weight); - -private: - struct GraphEdge; - - struct GraphNode { - explicit GraphNode(CCLayerImpl* cclayer); - ~GraphNode(); - - CCLayerImpl* layer; - LayerShape shape; - Vector incoming; - Vector outgoing; - float incomingEdgeWeight; - }; - - struct GraphEdge { - GraphEdge(GraphNode* fromNode, GraphNode* toNode, float weight) : from(fromNode), to(toNode), weight(weight) { }; - - GraphNode* from; - GraphNode* to; - float weight; - }; - - typedef Vector NodeList; - typedef Vector EdgeList; - NodeList m_nodes; - EdgeList m_edges; - float m_zRange; - - typedef HashMap EdgeMap; - EdgeMap m_activeEdges; - - void createGraphNodes(LayerList::iterator first, LayerList::iterator last); - void createGraphEdges(); - void removeEdgeFromList(GraphEdge*, Vector&); - - DISALLOW_COPY_AND_ASSIGN(CCLayerSorter); -}; - -} -#endif +// Temporary forwarding header +#include "cc/layer_sorter.h" diff --git a/cc/CCLayerTilingData.h b/cc/CCLayerTilingData.h index c73f0570c72f23..2883037fc25c8b 100644 --- a/cc/CCLayerTilingData.h +++ b/cc/CCLayerTilingData.h @@ -1,101 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef CCLayerTilingData_h -#define CCLayerTilingData_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "base/basictypes.h" -#include "IntRect.h" -#include "Region.h" -#include "TilingData.h" -#include -#include -#include - -namespace cc { - -class CCLayerTilingData { -public: - enum BorderTexelOption { HasBorderTexels, NoBorderTexels }; - - ~CCLayerTilingData(); - - static PassOwnPtr create(const IntSize& tileSize, BorderTexelOption); - - bool hasEmptyBounds() const { return m_tilingData.hasEmptyBounds(); } - int numTilesX() const { return m_tilingData.numTilesX(); } - int numTilesY() const { return m_tilingData.numTilesY(); } - IntRect tileBounds(int i, int j) const { return m_tilingData.tileBounds(i, j); } - IntPoint textureOffset(int xIndex, int yIndex) const { return m_tilingData.textureOffset(xIndex, yIndex); } - - // Change the tile size. This may invalidate all the existing tiles. - void setTileSize(const IntSize&); - IntSize tileSize() const; - // Change the border texel setting. This may invalidate all existing tiles. - void setBorderTexelOption(BorderTexelOption); - bool hasBorderTexels() const { return m_tilingData.borderTexels(); } - - bool isEmpty() const { return hasEmptyBounds() || !tiles().size(); } - - const CCLayerTilingData& operator=(const CCLayerTilingData&); - - class Tile { - public: - Tile() : m_i(-1), m_j(-1) { } - virtual ~Tile() { } - - int i() const { return m_i; } - int j() const { return m_j; } - void moveTo(int i, int j) { m_i = i; m_j = j; } - - const IntRect& opaqueRect() const { return m_opaqueRect; } - void setOpaqueRect(const IntRect& opaqueRect) { m_opaqueRect = opaqueRect; } - private: - int m_i; - int m_j; - IntRect m_opaqueRect; - DISALLOW_COPY_AND_ASSIGN(Tile); - }; - // Default hash key traits for integers disallow 0 and -1 as a key, so - // use a custom hash trait which disallows -1 and -2 instead. - typedef std::pair TileMapKey; - struct TileMapKeyTraits : HashTraits { - static const bool emptyValueIsZero = false; - static const bool needsDestruction = false; - static TileMapKey emptyValue() { return std::make_pair(-1, -1); } - static void constructDeletedValue(TileMapKey& slot) { slot = std::make_pair(-2, -2); } - static bool isDeletedValue(TileMapKey value) { return value.first == -2 && value.second == -2; } - }; - typedef HashMap, DefaultHash::Hash, TileMapKeyTraits> TileMap; - - void addTile(PassOwnPtr, int, int); - PassOwnPtr takeTile(int, int); - Tile* tileAt(int, int) const; - const TileMap& tiles() const { return m_tiles; } - - void setBounds(const IntSize&); - IntSize bounds() const; - - void contentRectToTileIndices(const IntRect&, int &left, int &top, int &right, int &bottom) const; - IntRect tileRect(const Tile*) const; - - Region opaqueRegionInContentRect(const IntRect&) const; - - void reset(); - -protected: - CCLayerTilingData(const IntSize& tileSize, BorderTexelOption); - - TileMap m_tiles; - TilingData m_tilingData; -}; - -} - -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/layer_tiling_data.h" diff --git a/cc/CCLayerTreeHost.h b/cc/CCLayerTreeHost.h index 277b1f06352ce6..e82fc46a0d470d 100644 --- a/cc/CCLayerTreeHost.h +++ b/cc/CCLayerTreeHost.h @@ -1,297 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCLayerTreeHost_h -#define CCLayerTreeHost_h - -#include "base/basictypes.h" -#include "base/hash_tables.h" -#include "base/memory/ref_counted.h" -#include "base/memory/scoped_ptr.h" -#include "CCAnimationEvents.h" -#include "CCGraphicsContext.h" -#include "CCLayerTreeHostClient.h" -#include "CCLayerTreeHostCommon.h" -#include "CCOcclusionTracker.h" -#include "CCPrioritizedTextureManager.h" -#include "CCProxy.h" -#include "CCRenderingStats.h" -#include "IntRect.h" -#include "RateLimiter.h" -#include "scoped_ptr_vector.h" -#include "SkColor.h" -#include - -#if defined(COMPILER_GCC) -namespace BASE_HASH_NAMESPACE { -template<> -struct hash { - size_t operator()(WebKit::WebGraphicsContext3D* ptr) const { - return hash()(reinterpret_cast(ptr)); - } -}; -} // namespace BASE_HASH_NAMESPACE -#endif // COMPILER - -namespace cc { - -class CCFontAtlas; -class CCLayerChromium; -class CCLayerTreeHostImpl; -class CCLayerTreeHostImplClient; -class CCPrioritizedTextureManager; -class CCTextureUpdateQueue; -class HeadsUpDisplayLayerChromium; -class Region; -struct CCScrollAndScaleSet; - -struct CCLayerTreeSettings { - CCLayerTreeSettings(); - ~CCLayerTreeSettings(); - - bool acceleratePainting; - bool showFPSCounter; - bool showPlatformLayerTree; - bool showPaintRects; - bool showPropertyChangedRects; - bool showSurfaceDamageRects; - bool showScreenSpaceRects; - bool showReplicaScreenSpaceRects; - bool showOccludingRects; - bool renderVSyncEnabled; - double refreshRate; - size_t maxPartialTextureUpdates; - IntSize defaultTileSize; - IntSize maxUntiledLayerSize; - IntSize minimumOcclusionTrackingSize; - - bool showDebugInfo() const { return showPlatformLayerTree || showFPSCounter || showDebugRects(); } - bool showDebugRects() const { return showPaintRects || showPropertyChangedRects || showSurfaceDamageRects || showScreenSpaceRects || showReplicaScreenSpaceRects || showOccludingRects; } -}; - -// Provides information on an Impl's rendering capabilities back to the CCLayerTreeHost -struct RendererCapabilities { - RendererCapabilities(); - ~RendererCapabilities(); - - GC3Denum bestTextureFormat; - bool contextHasCachedFrontBuffer; - bool usingPartialSwap; - bool usingAcceleratedPainting; - bool usingSetVisibility; - bool usingSwapCompleteCallback; - bool usingGpuMemoryManager; - bool usingDiscardFramebuffer; - bool usingEglImage; - int maxTextureSize; -}; - -class CCLayerTreeHost : public RateLimiterClient { -public: - static scoped_ptr create(CCLayerTreeHostClient*, const CCLayerTreeSettings&); - virtual ~CCLayerTreeHost(); - - void setSurfaceReady(); - - // Returns true if any CCLayerTreeHost is alive. - static bool anyLayerTreeHostInstanceExists(); - - static bool needsFilterContext() { return s_needsFilterContext; } - static void setNeedsFilterContext(bool needsFilterContext) { s_needsFilterContext = needsFilterContext; } - bool needsSharedContext() const { return needsFilterContext() || settings().acceleratePainting; } - - // CCLayerTreeHost interface to CCProxy. - void willBeginFrame() { m_client->willBeginFrame(); } - void didBeginFrame() { m_client->didBeginFrame(); } - void updateAnimations(double monotonicFrameBeginTime); - void layout(); - void beginCommitOnImplThread(CCLayerTreeHostImpl*); - void finishCommitOnImplThread(CCLayerTreeHostImpl*); - void willCommit(); - void commitComplete(); - scoped_ptr createContext(); - scoped_ptr createInputHandler(); - virtual scoped_ptr createLayerTreeHostImpl(CCLayerTreeHostImplClient*); - void didLoseContext(); - enum RecreateResult { - RecreateSucceeded, - RecreateFailedButTryAgain, - RecreateFailedAndGaveUp, - }; - RecreateResult recreateContext(); - void didCommitAndDrawFrame() { m_client->didCommitAndDrawFrame(); } - void didCompleteSwapBuffers() { m_client->didCompleteSwapBuffers(); } - void deleteContentsTexturesOnImplThread(CCResourceProvider*); - virtual void acquireLayerTextures(); - // Returns false if we should abort this frame due to initialization failure. - bool initializeRendererIfNeeded(); - void updateLayers(CCTextureUpdateQueue&, size_t contentsMemoryLimitBytes); - - CCLayerTreeHostClient* client() { return m_client; } - - // Only used when compositing on the main thread. - void composite(); - void scheduleComposite(); - - // Composites and attempts to read back the result into the provided - // buffer. If it wasn't possible, e.g. due to context lost, will return - // false. - bool compositeAndReadback(void *pixels, const IntRect&); - - void finishAllRendering(); - - int commitNumber() const { return m_commitNumber; } - - void renderingStats(CCRenderingStats*) const; - - const RendererCapabilities& rendererCapabilities() const; - - // Test only hook - void loseContext(int numTimes); - - void setNeedsAnimate(); - // virtual for testing - virtual void setNeedsCommit(); - void setNeedsRedraw(); - bool commitRequested() const; - - void setAnimationEvents(scoped_ptr, double wallClockTime); - virtual void didAddAnimation(); - - LayerChromium* rootLayer() { return m_rootLayer.get(); } - const LayerChromium* rootLayer() const { return m_rootLayer.get(); } - void setRootLayer(scoped_refptr); - - const CCLayerTreeSettings& settings() const { return m_settings; } - - void setViewportSize(const IntSize& layoutViewportSize, const IntSize& deviceViewportSize); - - const IntSize& layoutViewportSize() const { return m_layoutViewportSize; } - const IntSize& deviceViewportSize() const { return m_deviceViewportSize; } - - void setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor); - - void setBackgroundColor(SkColor color) { m_backgroundColor = color; } - - void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; } - - CCPrioritizedTextureManager* contentsTextureManager() const; - - // Delete contents textures' backing resources until they use only bytesLimit bytes. This may - // be called on the impl thread while the main thread is running. - void reduceContentsTexturesMemoryOnImplThread(size_t bytesLimit, CCResourceProvider*); - // Returns true if there any evicted backing textures that have not been deleted. - bool evictedContentsTexturesBackingsExist() const; - // Retrieve the list of all contents textures' backings that have been evicted, to pass to the - // main thread to unlink them from their owning textures. - void getEvictedContentTexturesBackings(CCPrioritizedTextureManager::BackingVector&); - // Unlink the list of contents textures' backings from their owning textures on the main thread - // before updating layers. - void unlinkEvictedContentTexturesBackings(const CCPrioritizedTextureManager::BackingVector&); - // Deletes all evicted backings, unlinking them from their owning textures if needed. - // Returns true if this function had to unlink any backings from their owning texture when - // destroying them. If this was the case, the impl layer tree may contain invalid resources. - bool deleteEvictedContentTexturesBackings(); - - bool visible() const { return m_visible; } - void setVisible(bool); - - void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double durationSec); - - void applyScrollAndScale(const CCScrollAndScaleSet&); - void setImplTransform(const WebKit::WebTransformationMatrix&); - - void startRateLimiter(WebKit::WebGraphicsContext3D*); - void stopRateLimiter(WebKit::WebGraphicsContext3D*); - - // RateLimitClient implementation - virtual void rateLimit() OVERRIDE; - - bool bufferedUpdates(); - bool requestPartialTextureUpdate(); - void deleteTextureAfterCommit(scoped_ptr); - - void setDeviceScaleFactor(float); - float deviceScaleFactor() const { return m_deviceScaleFactor; } - - void setFontAtlas(scoped_ptr); - - HeadsUpDisplayLayerChromium* hudLayer() const { return m_hudLayer.get(); } - -protected: - CCLayerTreeHost(CCLayerTreeHostClient*, const CCLayerTreeSettings&); - bool initialize(); - -private: - typedef std::vector > LayerList; - - void initializeRenderer(); - - void update(LayerChromium*, CCTextureUpdateQueue&, const CCOcclusionTracker*); - bool paintLayerContents(const LayerList&, CCTextureUpdateQueue&); - bool paintMasksForRenderSurface(LayerChromium*, CCTextureUpdateQueue&); - - void updateLayers(LayerChromium*, CCTextureUpdateQueue&); - - void prioritizeTextures(const LayerList&, CCOverdrawMetrics&); - void setPrioritiesForSurfaces(size_t surfaceMemoryBytes); - void setPrioritiesForLayers(const LayerList&); - size_t calculateMemoryForRenderSurfaces(const LayerList& updateList); - - void animateLayers(double monotonicTime); - bool animateLayersRecursive(LayerChromium* current, double monotonicTime); - void setAnimationEventsRecursive(const CCAnimationEventsVector&, LayerChromium*, double wallClockTime); - - bool m_animating; - bool m_needsAnimateLayers; - - CCLayerTreeHostClient* m_client; - - int m_commitNumber; - CCRenderingStats m_renderingStats; - - scoped_ptr m_proxy; - bool m_rendererInitialized; - bool m_contextLost; - int m_numTimesRecreateShouldFail; - int m_numFailedRecreateAttempts; - - scoped_refptr m_rootLayer; - scoped_refptr m_hudLayer; - scoped_ptr m_fontAtlas; - - scoped_ptr m_contentsTextureManager; - scoped_ptr m_surfaceMemoryPlaceholder; - - CCLayerTreeSettings m_settings; - - IntSize m_layoutViewportSize; - IntSize m_deviceViewportSize; - float m_deviceScaleFactor; - - bool m_visible; - - typedef base::hash_map > RateLimiterMap; - RateLimiterMap m_rateLimiters; - - float m_pageScaleFactor; - float m_minPageScaleFactor, m_maxPageScaleFactor; - WebKit::WebTransformationMatrix m_implTransform; - bool m_triggerIdleUpdates; - - SkColor m_backgroundColor; - bool m_hasTransparentBackground; - - typedef ScopedPtrVector TextureList; - TextureList m_deleteTextureAfterCommitList; - size_t m_partialTextureUpdateRequests; - - static bool s_needsFilterContext; - - DISALLOW_COPY_AND_ASSIGN(CCLayerTreeHost); -}; - -} // namespace cc - -#endif +// Temporary forwarding header +#include "cc/layer_tree_host.h" diff --git a/cc/CCLayerTreeHostClient.h b/cc/CCLayerTreeHostClient.h index 1c88a7542363c8..4a4f608cd976e5 100644 --- a/cc/CCLayerTreeHostClient.h +++ b/cc/CCLayerTreeHostClient.h @@ -2,42 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCLayerTreeHostClient_h -#define CCLayerTreeHostClient_h - -#include "base/memory/scoped_ptr.h" - -namespace WebKit { -class WebCompositorOutputSurface; -} - -namespace cc { -class CCInputHandler; -class IntSize; - -class CCLayerTreeHostClient { -public: - virtual void willBeginFrame() = 0; - // Marks finishing compositing-related tasks on the main thread. In threaded mode, this corresponds to didCommit(). - virtual void didBeginFrame() = 0; - virtual void animate(double frameBeginTime) = 0; - virtual void layout() = 0; - virtual void applyScrollAndScale(const IntSize& scrollDelta, float pageScale) = 0; - virtual scoped_ptr createOutputSurface() = 0; - virtual void didRecreateOutputSurface(bool success) = 0; - virtual scoped_ptr createInputHandler() = 0; - virtual void willCommit() = 0; - virtual void didCommit() = 0; - virtual void didCommitAndDrawFrame() = 0; - virtual void didCompleteSwapBuffers() = 0; - - // Used only in the single-threaded path. - virtual void scheduleComposite() = 0; - -protected: - virtual ~CCLayerTreeHostClient() { } -}; - -} - -#endif // CCLayerTreeHostClient_h +// Temporary forwarding header +#include "cc/layer_tree_host_client.h" diff --git a/cc/CCLayerTreeHostCommon.h b/cc/CCLayerTreeHostCommon.h index 01dc41e40dc332..4fcd6b0c7164a9 100644 --- a/cc/CCLayerTreeHostCommon.h +++ b/cc/CCLayerTreeHostCommon.h @@ -1,96 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCLayerTreeHostCommon_h -#define CCLayerTreeHostCommon_h - -#include "base/memory/ref_counted.h" -#include "cc/scoped_ptr_vector.h" -#include "IntRect.h" -#include "IntSize.h" -#include -#include - -namespace cc { - -class CCLayerImpl; -class CCLayerSorter; -class LayerChromium; - -class CCLayerTreeHostCommon { -public: - static IntRect calculateVisibleRect(const IntRect& targetSurfaceRect, const IntRect& layerBoundRect, const WebKit::WebTransformationMatrix&); - - static void calculateDrawTransforms(LayerChromium* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, int maxTextureSize, std::vector >& renderSurfaceLayerList); - static void calculateDrawTransforms(CCLayerImpl* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, CCLayerSorter*, int maxTextureSize, std::vector& renderSurfaceLayerList); - - // Performs hit testing for a given renderSurfaceLayerList. - static CCLayerImpl* findLayerThatIsHitByPoint(const IntPoint& viewportPoint, std::vector& renderSurfaceLayerList); - - template static bool renderSurfaceContributesToTarget(LayerType*, int targetSurfaceLayerID); - - // Returns a layer with the given id if one exists in the subtree starting - // from the given root layer (including mask and replica layers). - template static LayerType* findLayerInSubtree(LayerType* rootLayer, int layerId); - - static LayerChromium* getChildAsRawPtr(const std::vector >& children, size_t index) - { - return children[index].get(); - } - - static CCLayerImpl* getChildAsRawPtr(const ScopedPtrVector& children, size_t index) - { - return children[index]; - } - - struct ScrollUpdateInfo { - int layerId; - IntSize scrollDelta; - }; -}; - -struct CCScrollAndScaleSet { - CCScrollAndScaleSet(); - ~CCScrollAndScaleSet(); - - Vector scrolls; - float pageScaleDelta; -}; - -template -bool CCLayerTreeHostCommon::renderSurfaceContributesToTarget(LayerType* layer, int targetSurfaceLayerID) -{ - // A layer will either contribute its own content, or its render surface's content, to - // the target surface. The layer contributes its surface's content when both the - // following are true: - // (1) The layer actually has a renderSurface, and - // (2) The layer's renderSurface is not the same as the targetSurface. - // - // Otherwise, the layer just contributes itself to the target surface. - - return layer->renderSurface() && layer->id() != targetSurfaceLayerID; -} - -template -LayerType* CCLayerTreeHostCommon::findLayerInSubtree(LayerType* rootLayer, int layerId) -{ - if (rootLayer->id() == layerId) - return rootLayer; - - if (rootLayer->maskLayer() && rootLayer->maskLayer()->id() == layerId) - return rootLayer->maskLayer(); - - if (rootLayer->replicaLayer() && rootLayer->replicaLayer()->id() == layerId) - return rootLayer->replicaLayer(); - - for (size_t i = 0; i < rootLayer->children().size(); ++i) { - if (LayerType* found = findLayerInSubtree(getChildAsRawPtr(rootLayer->children(), i), layerId)) - return found; - } - return 0; -} - -} // namespace cc - -#endif +// Temporary forwarding header +#include "cc/layer_tree_host_common.h" diff --git a/cc/CCLayerTreeHostImpl.h b/cc/CCLayerTreeHostImpl.h index 297f619d00f992..714a528175f674 100644 --- a/cc/CCLayerTreeHostImpl.h +++ b/cc/CCLayerTreeHostImpl.h @@ -1,356 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCLayerTreeHostImpl_h -#define CCLayerTreeHostImpl_h - -#include "base/basictypes.h" -#include "base/time.h" -#include "CCAnimationEvents.h" -#include "CCInputHandler.h" -#include "CCLayerSorter.h" -#include "CCRenderPass.h" -#include "CCRenderPassSink.h" -#include "CCRenderer.h" -#include "SkColor.h" -#include -#include -#include - -namespace cc { - -class CCCompletionEvent; -class CCDebugRectHistory; -class CCFrameRateCounter; -class CCHeadsUpDisplayLayerImpl; -class CCLayerImpl; -class CCLayerTreeHostImplTimeSourceAdapter; -class CCPageScaleAnimation; -class CCRenderPassDrawQuad; -class CCResourceProvider; -struct RendererCapabilities; -struct CCRenderingStats; - -// CCLayerTreeHost->CCProxy callback interface. -class CCLayerTreeHostImplClient { -public: - virtual void didLoseContextOnImplThread() = 0; - virtual void onSwapBuffersCompleteOnImplThread() = 0; - virtual void onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds) = 0; - virtual void onCanDrawStateChanged(bool canDraw) = 0; - virtual void setNeedsRedrawOnImplThread() = 0; - virtual void setNeedsCommitOnImplThread() = 0; - virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr, double wallClockTime) = 0; - virtual void releaseContentsTexturesOnImplThread() = 0; -}; - -// CCPinchZoomViewport models the bounds and offset of the viewport that is used during a pinch-zoom operation. -// It tracks the layout-space dimensions of the viewport before any applied scale, and then tracks the layout-space -// coordinates of the viewport respecting the pinch settings. -class CCPinchZoomViewport { -public: - CCPinchZoomViewport(); - - float totalPageScaleFactor() const; - - void setPageScaleFactor(float factor) { m_pageScaleFactor = factor; } - float pageScaleFactor() const { return m_pageScaleFactor; } - - void setPageScaleDelta(float delta); - float pageScaleDelta() const { return m_pageScaleDelta; } - - float minPageScaleFactor() const { return m_minPageScaleFactor; } - float maxPageScaleFactor() const { return m_maxPageScaleFactor; } - - void setSentPageScaleDelta(float delta) { m_sentPageScaleDelta = delta; } - float sentPageScaleDelta() const { return m_sentPageScaleDelta; } - - // Returns true if the passed parameters were different from those previously - // cached. - bool setPageScaleFactorAndLimits(float pageScaleFactor, - float minPageScaleFactor, - float maxPageScaleFactor); - - // Returns the bounds and offset of the scaled and translated viewport to use for pinch-zoom. - FloatRect bounds() const; - const FloatPoint& scrollDelta() const { return m_pinchViewportScrollDelta; } - - void setLayoutViewportSize(const FloatSize& size) { m_layoutViewportSize = size; } - - // Apply the scroll offset in layout space to the offset of the pinch-zoom viewport. The viewport cannot be - // scrolled outside of the layout viewport bounds. Returns the component of the scroll that is un-applied due to - // this constraint. - FloatSize applyScroll(FloatSize&); - - WebKit::WebTransformationMatrix implTransform() const; - -private: - float m_pageScaleFactor; - float m_pageScaleDelta; - float m_sentPageScaleDelta; - float m_maxPageScaleFactor; - float m_minPageScaleFactor; - - FloatPoint m_pinchViewportScrollDelta; - FloatSize m_layoutViewportSize; -}; - -// CCLayerTreeHostImpl owns the CCLayerImpl tree as well as associated rendering state -class CCLayerTreeHostImpl : public CCInputHandlerClient, - public CCRendererClient, - public WebKit::WebCompositorOutputSurfaceClient { - typedef std::vector CCLayerList; - -public: - static scoped_ptr create(const CCLayerTreeSettings&, CCLayerTreeHostImplClient*); - virtual ~CCLayerTreeHostImpl(); - - // CCInputHandlerClient implementation - virtual CCInputHandlerClient::ScrollStatus scrollBegin(const IntPoint&, CCInputHandlerClient::ScrollInputType) OVERRIDE; - virtual void scrollBy(const IntPoint&, const IntSize&) OVERRIDE; - virtual void scrollEnd() OVERRIDE; - virtual void pinchGestureBegin() OVERRIDE; - virtual void pinchGestureUpdate(float, const IntPoint&) OVERRIDE; - virtual void pinchGestureEnd() OVERRIDE; - virtual void startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTime, double duration) OVERRIDE; - virtual void scheduleAnimation() OVERRIDE; - - struct FrameData : public CCRenderPassSink { - FrameData(); - ~FrameData(); - - Vector occludingScreenSpaceRects; - CCRenderPassList renderPasses; - CCRenderPassIdHashMap renderPassesById; - CCLayerList* renderSurfaceLayerList; - CCLayerList willDrawLayers; - - // CCRenderPassSink implementation. - virtual void appendRenderPass(scoped_ptr) OVERRIDE; - }; - - // Virtual for testing. - virtual void beginCommit(); - virtual void commitComplete(); - virtual void animate(double monotonicTime, double wallClockTime); - - // Returns false if problems occured preparing the frame, and we should try - // to avoid displaying the frame. If prepareToDraw is called, - // didDrawAllLayers must also be called, regardless of whether drawLayers is - // called between the two. - virtual bool prepareToDraw(FrameData&); - virtual void drawLayers(const FrameData&); - // Must be called if and only if prepareToDraw was called. - void didDrawAllLayers(const FrameData&); - - // CCRendererClient implementation - virtual const IntSize& deviceViewportSize() const OVERRIDE; - virtual const CCLayerTreeSettings& settings() const OVERRIDE; - virtual void didLoseContext() OVERRIDE; - virtual void onSwapBuffersComplete() OVERRIDE; - virtual void setFullRootLayerDamage() OVERRIDE; - virtual void releaseContentsTextures() OVERRIDE; - virtual void setMemoryAllocationLimitBytes(size_t) OVERRIDE; - - // WebCompositorOutputSurfaceClient implementation. - virtual void onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds) OVERRIDE; - - // Implementation - bool canDraw(); - CCGraphicsContext* context() const; - - std::string layerTreeAsText() const; - - void finishAllRendering(); - int sourceAnimationFrameNumber() const; - - bool initializeRenderer(scoped_ptr); - bool isContextLost(); - CCRenderer* renderer() { return m_renderer.get(); } - const RendererCapabilities& rendererCapabilities() const; - - bool swapBuffers(); - - void readback(void* pixels, const IntRect&); - - void setRootLayer(scoped_ptr); - CCLayerImpl* rootLayer() { return m_rootLayerImpl.get(); } - - void setHudLayer(CCHeadsUpDisplayLayerImpl* layerImpl) { m_hudLayerImpl = layerImpl; } - CCHeadsUpDisplayLayerImpl* hudLayer() { return m_hudLayerImpl; } - - // Release ownership of the current layer tree and replace it with an empty - // tree. Returns the root layer of the detached tree. - scoped_ptr detachLayerTree(); - - CCLayerImpl* rootScrollLayer() const { return m_rootScrollLayerImpl; } - - bool visible() const { return m_visible; } - void setVisible(bool); - - int sourceFrameNumber() const { return m_sourceFrameNumber; } - void setSourceFrameNumber(int frameNumber) { m_sourceFrameNumber = frameNumber; } - - bool contentsTexturesPurged() const { return m_contentsTexturesPurged; } - void setContentsTexturesPurged(); - void resetContentsTexturesPurged(); - size_t memoryAllocationLimitBytes() const { return m_memoryAllocationLimitBytes; } - - void setViewportSize(const IntSize& layoutViewportSize, const IntSize& deviceViewportSize); - const IntSize& layoutViewportSize() const { return m_layoutViewportSize; } - - float deviceScaleFactor() const { return m_deviceScaleFactor; } - void setDeviceScaleFactor(float); - - float pageScaleFactor() const; - void setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor); - - scoped_ptr processScrollDeltas(); - WebKit::WebTransformationMatrix implTransform() const; - - void startPageScaleAnimation(const IntSize& tragetPosition, bool useAnchor, float scale, double durationSec); - - SkColor backgroundColor() const { return m_backgroundColor; } - void setBackgroundColor(SkColor color) { m_backgroundColor = color; } - - bool hasTransparentBackground() const { return m_hasTransparentBackground; } - void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; } - - bool needsAnimateLayers() const { return m_needsAnimateLayers; } - void setNeedsAnimateLayers() { m_needsAnimateLayers = true; } - - void setNeedsRedraw(); - - void renderingStats(CCRenderingStats*) const; - - void updateRootScrollLayerImplTransform(); - - CCFrameRateCounter* fpsCounter() const { return m_fpsCounter.get(); } - CCDebugRectHistory* debugRectHistory() const { return m_debugRectHistory.get(); } - CCResourceProvider* resourceProvider() const { return m_resourceProvider.get(); } - - class CullRenderPassesWithCachedTextures { - public: - bool shouldRemoveRenderPass(const CCRenderPassDrawQuad&, const FrameData&) const; - - // Iterates from the root first, in order to remove the surfaces closest - // to the root with cached textures, and all surfaces that draw into - // them. - size_t renderPassListBegin(const CCRenderPassList& list) const { return list.size() - 1; } - size_t renderPassListEnd(const CCRenderPassList&) const { return 0 - 1; } - size_t renderPassListNext(size_t it) const { return it - 1; } - - CullRenderPassesWithCachedTextures(CCRenderer& renderer) : m_renderer(renderer) { } - private: - CCRenderer& m_renderer; - }; - - class CullRenderPassesWithNoQuads { - public: - bool shouldRemoveRenderPass(const CCRenderPassDrawQuad&, const FrameData&) const; - - // Iterates in draw order, so that when a surface is removed, and its - // target becomes empty, then its target can be removed also. - size_t renderPassListBegin(const CCRenderPassList&) const { return 0; } - size_t renderPassListEnd(const CCRenderPassList& list) const { return list.size(); } - size_t renderPassListNext(size_t it) const { return it + 1; } - }; - - template - static void removeRenderPasses(RenderPassCuller, FrameData&); - -protected: - CCLayerTreeHostImpl(const CCLayerTreeSettings&, CCLayerTreeHostImplClient*); - - void animatePageScale(double monotonicTime); - void animateScrollbars(double monotonicTime); - - // Exposed for testing. - void calculateRenderSurfaceLayerList(CCLayerList&); - - // Virtual for testing. - virtual void animateLayers(double monotonicTime, double wallClockTime); - - // Virtual for testing. - virtual base::TimeDelta lowFrequencyAnimationInterval() const; - - CCLayerTreeHostImplClient* m_client; - int m_sourceFrameNumber; - -private: - void computeDoubleTapZoomDeltas(CCScrollAndScaleSet* scrollInfo); - void computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo); - void makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale); - - void setPageScaleDelta(float); - void updateMaxScrollPosition(); - void trackDamageForAllSurfaces(CCLayerImpl* rootDrawLayer, const CCLayerList& renderSurfaceLayerList); - - // Returns false if the frame should not be displayed. This function should - // only be called from prepareToDraw, as didDrawAllLayers must be called - // if this helper function is called. - bool calculateRenderPasses(FrameData&); - void animateLayersRecursive(CCLayerImpl*, double monotonicTime, double wallClockTime, CCAnimationEventsVector*, bool& didAnimate, bool& needsAnimateLayers); - void setBackgroundTickingEnabled(bool); - IntSize contentSize() const; - - void sendDidLoseContextRecursive(CCLayerImpl*); - void clearRenderSurfaces(); - bool ensureRenderSurfaceLayerList(); - void clearCurrentlyScrollingLayer(); - - void animateScrollbarsRecursive(CCLayerImpl*, double monotonicTime); - - void dumpRenderSurfaces(std::string*, int indent, const CCLayerImpl*) const; - - scoped_ptr m_context; - OwnPtr m_resourceProvider; - OwnPtr m_renderer; - scoped_ptr m_rootLayerImpl; - CCLayerImpl* m_rootScrollLayerImpl; - CCLayerImpl* m_currentlyScrollingLayerImpl; - CCHeadsUpDisplayLayerImpl* m_hudLayerImpl; - int m_scrollingLayerIdFromPreviousTree; - bool m_scrollDeltaIsInScreenSpace; - CCLayerTreeSettings m_settings; - IntSize m_layoutViewportSize; - IntSize m_deviceViewportSize; - float m_deviceScaleFactor; - bool m_visible; - bool m_contentsTexturesPurged; - size_t m_memoryAllocationLimitBytes; - - SkColor m_backgroundColor; - bool m_hasTransparentBackground; - - // If this is true, it is necessary to traverse the layer tree ticking the animators. - bool m_needsAnimateLayers; - bool m_pinchGestureActive; - IntPoint m_previousPinchAnchor; - - OwnPtr m_pageScaleAnimation; - - // This is used for ticking animations slowly when hidden. - OwnPtr m_timeSourceClientAdapter; - - CCLayerSorter m_layerSorter; - - // List of visible layers for the most recently prepared frame. Used for - // rendering and input event hit testing. - CCLayerList m_renderSurfaceLayerList; - - CCPinchZoomViewport m_pinchZoomViewport; - - OwnPtr m_fpsCounter; - OwnPtr m_debugRectHistory; - - size_t m_numImplThreadScrolls; - size_t m_numMainThreadScrolls; - - DISALLOW_COPY_AND_ASSIGN(CCLayerTreeHostImpl); -}; - -}; - -#endif +// Temporary forwarding header +#include "cc/layer_tree_host_impl.h" diff --git a/cc/CCMathUtil.h b/cc/CCMathUtil.h index ed3848e6f4b7fb..945ffe8072bc5a 100644 --- a/cc/CCMathUtil.h +++ b/cc/CCMathUtil.h @@ -2,106 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCMathUtil_h -#define CCMathUtil_h - -#include "FloatPoint.h" -#include "FloatPoint3D.h" - -namespace WebKit { -class WebTransformationMatrix; -} - -namespace cc { - -class IntRect; -class FloatRect; -class FloatQuad; - -struct HomogeneousCoordinate { - HomogeneousCoordinate(double newX, double newY, double newZ, double newW) - : x(newX) - , y(newY) - , z(newZ) - , w(newW) - { - } - - bool shouldBeClipped() const - { - return w <= 0; - } - - FloatPoint cartesianPoint2d() const - { - if (w == 1) - return FloatPoint(x, y); - - // For now, because this code is used privately only by CCMathUtil, it should never be called when w == 0, and we do not yet need to handle that case. - ASSERT(w); - double invW = 1.0 / w; - return FloatPoint(x * invW, y * invW); - } - - FloatPoint3D cartesianPoint3d() const - { - if (w == 1) - return FloatPoint3D(x, y, z); - - // For now, because this code is used privately only by CCMathUtil, it should never be called when w == 0, and we do not yet need to handle that case. - ASSERT(w); - double invW = 1.0 / w; - return FloatPoint3D(x * invW, y * invW, z * invW); - } - - double x; - double y; - double z; - double w; -}; - -class CCMathUtil { -public: - - // Background: WebTransformationMatrix code in WebCore does not do the right thing in - // mapRect / mapQuad / projectQuad when there is a perspective projection that causes - // one of the transformed vertices to go to w < 0. In those cases, it is necessary to - // perform clipping in homogeneous coordinates, after applying the transform, before - // dividing-by-w to convert to cartesian coordinates. - // - // These functions return the axis-aligned rect that encloses the correctly clipped, - // transformed polygon. - static IntRect mapClippedRect(const WebKit::WebTransformationMatrix&, const IntRect&); - static FloatRect mapClippedRect(const WebKit::WebTransformationMatrix&, const FloatRect&); - static FloatRect projectClippedRect(const WebKit::WebTransformationMatrix&, const FloatRect&); - - // Returns an array of vertices that represent the clipped polygon. After returning, indexes from - // 0 to numVerticesInClippedQuad are valid in the clippedQuad array. Note that - // numVerticesInClippedQuad may be zero, which means the entire quad was clipped, and - // none of the vertices in the array are valid. - static void mapClippedQuad(const WebKit::WebTransformationMatrix&, const FloatQuad& srcQuad, FloatPoint clippedQuad[8], int& numVerticesInClippedQuad); - - static FloatRect computeEnclosingRectOfVertices(FloatPoint vertices[], int numVertices); - static FloatRect computeEnclosingClippedRect(const HomogeneousCoordinate& h1, const HomogeneousCoordinate& h2, const HomogeneousCoordinate& h3, const HomogeneousCoordinate& h4); - - // NOTE: These functions do not do correct clipping against w = 0 plane, but they - // correctly detect the clipped condition via the boolean clipped. - static FloatQuad mapQuad(const WebKit::WebTransformationMatrix&, const FloatQuad&, bool& clipped); - static FloatPoint mapPoint(const WebKit::WebTransformationMatrix&, const FloatPoint&, bool& clipped); - static FloatPoint3D mapPoint(const WebKit::WebTransformationMatrix&, const FloatPoint3D&, bool& clipped); - static FloatQuad projectQuad(const WebKit::WebTransformationMatrix&, const FloatQuad&, bool& clipped); - static FloatPoint projectPoint(const WebKit::WebTransformationMatrix&, const FloatPoint&, bool& clipped); - - static void flattenTransformTo2d(WebKit::WebTransformationMatrix&); - - // Returns the smallest angle between the given two vectors in degrees. Neither vector is - // assumed to be normalized. - static float smallestAngleBetweenVectors(const FloatSize&, const FloatSize&); - - // Projects the |source| vector onto |destination|. Neither vector is assumed to be normalized. - static FloatSize projectVector(const FloatSize& source, const FloatSize& destination); -}; - -} // namespace cc - -#endif // #define CCMathUtil_h +// Temporary forwarding header +#include "cc/math_util.h" diff --git a/cc/CCOcclusionTracker.h b/cc/CCOcclusionTracker.h index c2526cdc38eb04..b7c8ce0fa1655b 100644 --- a/cc/CCOcclusionTracker.h +++ b/cc/CCOcclusionTracker.h @@ -2,104 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCOcclusionTracker_h -#define CCOcclusionTracker_h - -#include "base/basictypes.h" -#include "CCLayerIterator.h" -#include "FloatQuad.h" -#include "Region.h" - -namespace cc { -class CCOverdrawMetrics; -class CCLayerImpl; -class CCRenderSurface; -class LayerChromium; -class RenderSurfaceChromium; - -// This class is used to track occlusion of layers while traversing them in a front-to-back order. As each layer is visited, one of the -// methods in this class is called to notify it about the current target surface. -// Then, occlusion in the content space of the current layer may be queried, via methods such as occluded() and unoccludedContentRect(). -// If the current layer owns a RenderSurface, then occlusion on that RenderSurface may also be queried via surfaceOccluded() and surfaceUnoccludedContentRect(). -// Finally, once finished with the layer, occlusion behind the layer should be marked by calling markOccludedBehindLayer(). -template -class CCOcclusionTrackerBase { -public: - CCOcclusionTrackerBase(IntRect rootTargetRect, bool recordMetricsForFrame); - - // Called at the beginning of each step in the CCLayerIterator's front-to-back traversal. - void enterLayer(const CCLayerIteratorPosition&); - // Called at the end of each step in the CCLayerIterator's front-to-back traversal. - void leaveLayer(const CCLayerIteratorPosition&); - - // Returns true if the given rect in content space for the layer is fully occluded in either screen space or the layer's target surface. - bool occluded(const LayerType*, const IntRect& contentRect, bool* hasOcclusionFromOutsideTargetSurface = 0) const; - // Gives an unoccluded sub-rect of |contentRect| in the content space of the layer. Used when considering occlusion for a layer that paints/draws something. - IntRect unoccludedContentRect(const LayerType*, const IntRect& contentRect, bool* hasOcclusionFromOutsideTargetSurface = 0) const; - - // Gives an unoccluded sub-rect of |contentRect| in the content space of the renderTarget owned by the layer. - // Used when considering occlusion for a contributing surface that is rendering into another target. - IntRect unoccludedContributingSurfaceContentRect(const LayerType*, bool forReplica, const IntRect& contentRect, bool* hasOcclusionFromOutsideTargetSurface = 0) const; - - // Report operations for recording overdraw metrics. - CCOverdrawMetrics& overdrawMetrics() const { return *m_overdrawMetrics.get(); } - - // Gives the region of the screen that is not occluded by something opaque. - Region computeVisibleRegionInScreen() const { return subtract(Region(m_rootTargetRect), m_stack.last().occlusionInScreen); } - - void setMinimumTrackingSize(const IntSize& size) { m_minimumTrackingSize = size; } - - // The following is used for visualization purposes. - void setOccludingScreenSpaceRectsContainer(Vector* rects) { m_occludingScreenSpaceRects = rects; } - -protected: - struct StackObject { - StackObject() : target(0) { } - StackObject(const LayerType* target) : target(target) { } - const LayerType* target; - Region occlusionInScreen; - Region occlusionInTarget; - }; - - // The stack holds occluded regions for subtrees in the RenderSurface-Layer tree, so that when we leave a subtree we may - // apply a mask to it, but not to the parts outside the subtree. - // - The first time we see a new subtree under a target, we add that target to the top of the stack. This can happen as a layer representing itself, or as a target surface. - // - When we visit a target surface, we apply its mask to its subtree, which is at the top of the stack. - // - When we visit a layer representing itself, we add its occlusion to the current subtree, which is at the top of the stack. - // - When we visit a layer representing a contributing surface, the current target will never be the top of the stack since we just came from the contributing surface. - // We merge the occlusion at the top of the stack with the new current subtree. This new target is pushed onto the stack if not already there. - Vector m_stack; - - // Allow tests to override this. - virtual IntRect layerClipRectInTarget(const LayerType*) const; - -private: - // Called when visiting a layer representing itself. If the target was not already current, then this indicates we have entered a new surface subtree. - void enterRenderTarget(const LayerType* newTarget); - - // Called when visiting a layer representing a target surface. This indicates we have visited all the layers within the surface, and we may - // perform any surface-wide operations. - void finishedRenderTarget(const LayerType* finishedTarget); - - // Called when visiting a layer representing a contributing surface. This indicates that we are leaving our current surface, and - // entering the new one. We then perform any operations required for merging results from the child subtree into its parent. - void leaveToRenderTarget(const LayerType* newTarget); - - // Add the layer's occlusion to the tracked state. - void markOccludedBehindLayer(const LayerType*); - - IntRect m_rootTargetRect; - OwnPtr m_overdrawMetrics; - IntSize m_minimumTrackingSize; - - // This is used for visualizing the occlusion tracking process. - Vector* m_occludingScreenSpaceRects; - - DISALLOW_COPY_AND_ASSIGN(CCOcclusionTrackerBase); -}; - -typedef CCOcclusionTrackerBase CCOcclusionTracker; -typedef CCOcclusionTrackerBase CCOcclusionTrackerImpl; - -} -#endif // CCOcclusionTracker_h +// Temporary forwarding header +#include "cc/occlusion_tracker.h" diff --git a/cc/CCOverdrawMetrics.h b/cc/CCOverdrawMetrics.h index b907a64b4c2cca..94a178810d11ef 100644 --- a/cc/CCOverdrawMetrics.h +++ b/cc/CCOverdrawMetrics.h @@ -2,96 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCOverdrawMetrics_h -#define CCOverdrawMetrics_h - -#include - -namespace WebKit { -class WebTransformationMatrix; -} - -namespace cc { -class IntRect; -class CCLayerTreeHost; -class CCLayerTreeHostImpl; - -// FIXME: compute overdraw metrics only occasionally, not every frame. -class CCOverdrawMetrics { -public: - static PassOwnPtr create(bool recordMetricsForFrame) { return adoptPtr(new CCOverdrawMetrics(recordMetricsForFrame)); } - - // These methods are used for saving metrics during update/commit. - - // Record pixels painted by WebKit into the texture updater, but does not mean the pixels were rasterized in main memory. - void didPaint(const IntRect& paintedRect); - // Records that an invalid tile was culled and did not need to be painted/uploaded, and did not contribute to other tiles needing to be painted. - void didCullTileForUpload(); - // Records pixels that were uploaded to texture memory. - void didUpload(const WebKit::WebTransformationMatrix& transformToTarget, const IntRect& uploadRect, const IntRect& opaqueRect); - // Record contents texture(s) behind present using the given number of bytes. - void didUseContentsTextureMemoryBytes(size_t contentsTextureUseBytes); - // Record RenderSurface texture(s) being present using the given number of bytes. - void didUseRenderSurfaceTextureMemoryBytes(size_t renderSurfaceUseBytes); - - // These methods are used for saving metrics during draw. - - // Record pixels that were not drawn to screen. - void didCullForDrawing(const WebKit::WebTransformationMatrix& transformToTarget, const IntRect& beforeCullRect, const IntRect& afterCullRect); - // Record pixels that were drawn to screen. - void didDraw(const WebKit::WebTransformationMatrix& transformToTarget, const IntRect& afterCullRect, const IntRect& opaqueRect); - - void recordMetrics(const CCLayerTreeHost*) const; - void recordMetrics(const CCLayerTreeHostImpl*) const; - - // Accessors for tests. - float pixelsDrawnOpaque() const { return m_pixelsDrawnOpaque; } - float pixelsDrawnTranslucent() const { return m_pixelsDrawnTranslucent; } - float pixelsCulledForDrawing() const { return m_pixelsCulledForDrawing; } - float pixelsPainted() const { return m_pixelsPainted; } - float pixelsUploadedOpaque() const { return m_pixelsUploadedOpaque; } - float pixelsUploadedTranslucent() const { return m_pixelsUploadedTranslucent; } - int tilesCulledForUpload() const { return m_tilesCulledForUpload; } - -private: - enum MetricsType { - UpdateAndCommit, - DrawingToScreen - }; - - explicit CCOverdrawMetrics(bool recordMetricsForFrame); - - template - void recordMetricsInternal(MetricsType, const LayerTreeHostType*) const; - - // When false this class is a giant no-op. - bool m_recordMetricsForFrame; - - // These values are used for saving metrics during update/commit. - - // Count of pixels that were painted due to invalidation. - float m_pixelsPainted; - // Count of pixels uploaded to textures and known to be opaque. - float m_pixelsUploadedOpaque; - // Count of pixels uploaded to textures and not known to be opaque. - float m_pixelsUploadedTranslucent; - // Count of tiles that were invalidated but not uploaded. - int m_tilesCulledForUpload; - // Count the number of bytes in contents textures. - unsigned long long m_contentsTextureUseBytes; - // Count the number of bytes in RenderSurface textures. - unsigned long long m_renderSurfaceTextureUseBytes; - - // These values are used for saving metrics during draw. - - // Count of pixels that are opaque (and thus occlude). Ideally this is no more than wiewport width x height. - float m_pixelsDrawnOpaque; - // Count of pixels that are possibly translucent, and cannot occlude. - float m_pixelsDrawnTranslucent; - // Count of pixels not drawn as they are occluded by somthing opaque. - float m_pixelsCulledForDrawing; -}; - -} // namespace cc - -#endif +// Temporary forwarding header +#include "cc/overdraw_metrics.h" diff --git a/cc/CCPageScaleAnimation.h b/cc/CCPageScaleAnimation.h index f597026f90e786..1c59d7d8901084 100644 --- a/cc/CCPageScaleAnimation.h +++ b/cc/CCPageScaleAnimation.h @@ -1,74 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCPageScaleAnimation_h -#define CCPageScaleAnimation_h - -#include "IntSize.h" -#include - -namespace cc { - -// A small helper class that does the math for zoom animations, primarily for -// double-tap zoom. Initialize it with starting and ending scroll/page scale -// positions and an animation length time, then call ...AtTime() at every frame -// to obtain the current interpolated position. -class CCPageScaleAnimation { -public: - // Construct with the starting page scale and scroll offset (which is in - // pageScaleStart space). The window size is the user-viewable area - // in pixels. - static PassOwnPtr create(const IntSize& scrollStart, float pageScaleStart, const IntSize& windowSize, const IntSize& contentSize, double startTime); - - // The following methods initialize the animation. Call one of them - // immediately after construction to set the final scroll and page scale. - - // Zoom while explicitly specifying the top-left scroll position. The - // scroll offset is in finalPageScale coordinates. - void zoomTo(const IntSize& finalScroll, float finalPageScale, double duration); - - // Zoom based on a specified onscreen anchor, which will remain at the same - // position on the screen throughout the animation. The anchor is in local - // space relative to scrollStart. - void zoomWithAnchor(const IntSize& anchor, float finalPageScale, double duration); - - // Call these functions while the animation is in progress to output the - // current state. - IntSize scrollOffsetAtTime(double time) const; - float pageScaleAtTime(double time) const; - bool isAnimationCompleteAtTime(double time) const; - - // The following methods return state which is invariant throughout the - // course of the animation. - double startTime() const { return m_startTime; } - double duration() const { return m_duration; } - double endTime() const { return m_startTime + m_duration; } - const IntSize& finalScrollOffset() const { return m_scrollEnd; } - float finalPageScale() const { return m_pageScaleEnd; } - -protected: - CCPageScaleAnimation(const IntSize& scrollStart, float pageScaleStart, const IntSize& windowSize, const IntSize& contentSize, double startTime); - -private: - float progressRatioForTime(double time) const; - IntSize scrollOffsetAtRatio(float ratio) const; - float pageScaleAtRatio(float ratio) const; - - IntSize m_scrollStart; - float m_pageScaleStart; - IntSize m_windowSize; - IntSize m_contentSize; - - bool m_anchorMode; - IntSize m_anchor; - IntSize m_scrollEnd; - float m_pageScaleEnd; - - double m_startTime; - double m_duration; -}; - -} // namespace cc - -#endif +// Temporary forwarding header +#include "cc/page_scale_animation.h" diff --git a/cc/CCPrioritizedTexture.h b/cc/CCPrioritizedTexture.h index 3196867064abce..19fdca209a3985 100644 --- a/cc/CCPrioritizedTexture.h +++ b/cc/CCPrioritizedTexture.h @@ -2,141 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCPrioritizedTexture_h -#define CCPrioritizedTexture_h - -#include "base/basictypes.h" -#include "base/memory/scoped_ptr.h" -#include "CCPriorityCalculator.h" -#include "CCResourceProvider.h" -#include "CCTexture.h" -#include "GraphicsContext3D.h" -#include "IntRect.h" -#include "IntSize.h" - -namespace cc { - -class CCPrioritizedTextureManager; - -class CCPrioritizedTexture { -public: - static scoped_ptr create(CCPrioritizedTextureManager* manager, IntSize size, GC3Denum format) - { - return make_scoped_ptr(new CCPrioritizedTexture(manager, size, format)); - } - static scoped_ptr create(CCPrioritizedTextureManager* manager) - { - return make_scoped_ptr(new CCPrioritizedTexture(manager, IntSize(), 0)); - } - ~CCPrioritizedTexture(); - - // Texture properties. Changing these causes the backing texture to be lost. - // Setting these to the same value is a no-op. - void setTextureManager(CCPrioritizedTextureManager*); - CCPrioritizedTextureManager* textureManager() { return m_manager; } - void setDimensions(IntSize, GC3Denum format); - GC3Denum format() const { return m_format; } - IntSize size() const { return m_size; } - size_t bytes() const { return m_bytes; } - - // Set priority for the requested texture. - void setRequestPriority(int priority) { m_priority = priority; } - int requestPriority() const { return m_priority; } - - // After CCPrioritizedTexture::prioritizeTextures() is called, this returns - // if the the request succeeded and this texture can be acquired for use. - bool canAcquireBackingTexture() const { return m_isAbovePriorityCutoff; } - - // This returns whether we still have a backing texture. This can continue - // to be true even after canAcquireBackingTexture() becomes false. In this - // case the texture can be used but shouldn't be updated since it will get - // taken away "soon". - bool haveBackingTexture() const { return !!backing(); } - - bool backingResourceWasEvicted() const; - - // If canAcquireBackingTexture() is true acquireBackingTexture() will acquire - // a backing texture for use. Call this whenever the texture is actually needed. - void acquireBackingTexture(CCResourceProvider*); - - // FIXME: Request late is really a hack for when we are totally out of memory - // (all textures are visible) but we can still squeeze into the limit - // by not painting occluded textures. In this case the manager - // refuses all visible textures and requestLate() will enable - // canAcquireBackingTexture() on a call-order basis. We might want to - // just remove this in the future (carefully) and just make sure we don't - // regress OOMs situations. - bool requestLate(); - - // Uploads pixels into the backing resource. This functions will aquire the backing if needed. - void upload(CCResourceProvider*, const uint8_t* image, const IntRect& imageRect, const IntRect& sourceRect, const IntSize& destOffset); - - CCResourceProvider::ResourceId resourceId() const; - - // Self-managed textures are accounted for when prioritizing other textures, - // but they are not allocated/recycled/deleted, so this needs to be done - // externally. canAcquireBackingTexture() indicates if the texture would have - // been allowed given its priority. - void setIsSelfManaged(bool isSelfManaged) { m_isSelfManaged = isSelfManaged; } - bool isSelfManaged() { return m_isSelfManaged; } - void setToSelfManagedMemoryPlaceholder(size_t bytes); - -private: - friend class CCPrioritizedTextureManager; - friend class CCPrioritizedTextureTest; - - class Backing : public CCTexture { - public: - Backing(unsigned id, CCResourceProvider*, IntSize, GC3Denum format); - ~Backing(); - void updatePriority(); - - CCPrioritizedTexture* owner() { return m_owner; } - bool hadOwnerAtLastPriorityUpdate() const { return m_ownerExistedAtLastPriorityUpdate; } - int requestPriorityAtLastPriorityUpdate() const { return m_priorityAtLastPriorityUpdate; } - bool wasAbovePriorityCutoffAtLastPriorityUpdate() const { return m_wasAbovePriorityCutoffAtLastPriorityUpdate; } - - void deleteResource(CCResourceProvider*); - bool resourceHasBeenDeleted() const; - - private: - friend class CCPrioritizedTexture; - CCPrioritizedTexture* m_owner; - int m_priorityAtLastPriorityUpdate; - bool m_ownerExistedAtLastPriorityUpdate; - bool m_wasAbovePriorityCutoffAtLastPriorityUpdate; - bool m_resourceHasBeenDeleted; -#ifndef NDEBUG - CCResourceProvider* m_resourceProvider; -#endif - - DISALLOW_COPY_AND_ASSIGN(Backing); - }; - - CCPrioritizedTexture(CCPrioritizedTextureManager*, IntSize, GC3Denum format); - - bool isAbovePriorityCutoff() { return m_isAbovePriorityCutoff; } - void setAbovePriorityCutoff(bool isAbovePriorityCutoff) { m_isAbovePriorityCutoff = isAbovePriorityCutoff; } - void setManagerInternal(CCPrioritizedTextureManager* manager) { m_manager = manager; } - - Backing* backing() const { return m_backing; } - void link(Backing*); - void unlink(); - - IntSize m_size; - GC3Denum m_format; - size_t m_bytes; - - int m_priority; - bool m_isAbovePriorityCutoff; - bool m_isSelfManaged; - - Backing* m_backing; - CCPrioritizedTextureManager* m_manager; - - DISALLOW_COPY_AND_ASSIGN(CCPrioritizedTexture); -}; - -} // namespace cc - -#endif +// Temporary forwarding header +#include "cc/prioritized_texture.h" diff --git a/cc/CCPrioritizedTextureManager.h b/cc/CCPrioritizedTextureManager.h index 1b3b1edbdfbf58..cfeb804c10561d 100644 --- a/cc/CCPrioritizedTextureManager.h +++ b/cc/CCPrioritizedTextureManager.h @@ -2,158 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCPrioritizedTextureManager_h -#define CCPrioritizedTextureManager_h - -#include "base/basictypes.h" -#include "base/hash_tables.h" -#include "base/memory/scoped_ptr.h" -#include "CCPrioritizedTexture.h" -#include "CCPriorityCalculator.h" -#include "CCTexture.h" -#include "GraphicsContext3D.h" -#include "IntRect.h" -#include "IntSize.h" -#include -#include - -#if defined(COMPILER_GCC) -namespace BASE_HASH_NAMESPACE { -template<> -struct hash { - size_t operator()(cc::CCPrioritizedTexture* ptr) const { - return hash()(reinterpret_cast(ptr)); - } -}; -} // namespace BASE_HASH_NAMESPACE -#endif // COMPILER - -namespace cc { - -class CCPriorityCalculator; - -class CCPrioritizedTextureManager { -public: - static scoped_ptr create(size_t maxMemoryLimitBytes, int maxTextureSize, int pool) - { - return make_scoped_ptr(new CCPrioritizedTextureManager(maxMemoryLimitBytes, maxTextureSize, pool)); - } - scoped_ptr createTexture(IntSize size, GC3Denum format) - { - return make_scoped_ptr(new CCPrioritizedTexture(this, size, format)); - } - ~CCPrioritizedTextureManager(); - - typedef Vector BackingVector; - - // FIXME (http://crbug.com/137094): This 64MB default is a straggler from the - // old texture manager and is just to give us a default memory allocation before - // we get a callback from the GPU memory manager. We should probaby either: - // - wait for the callback before rendering anything instead - // - push this into the GPU memory manager somehow. - static size_t defaultMemoryAllocationLimit() { return 64 * 1024 * 1024; } - - // memoryUseBytes() describes the number of bytes used by existing allocated textures. - // memoryAboveCutoffBytes() describes the number of bytes that would be used if all - // textures that are above the cutoff were allocated. - // memoryUseBytes() <= memoryAboveCutoffBytes() should always be true. - size_t memoryUseBytes() const { return m_memoryUseBytes; } - size_t memoryAboveCutoffBytes() const { return m_memoryAboveCutoffBytes; } - size_t memoryForSelfManagedTextures() const { return m_maxMemoryLimitBytes - m_memoryAvailableBytes; } - - void setMaxMemoryLimitBytes(size_t bytes) { m_maxMemoryLimitBytes = bytes; } - size_t maxMemoryLimitBytes() const { return m_maxMemoryLimitBytes; } - - void prioritizeTextures(); - void clearPriorities(); - - void reduceMemoryOnImplThread(size_t limitBytes, CCResourceProvider*); - bool evictedBackingsExist() const { return !m_evictedBackings.isEmpty(); } - void getEvictedBackings(BackingVector& evictedBackings); - void unlinkEvictedBackings(const BackingVector& evictedBackings); - // Deletes all evicted backings, unlinking them from their owning textures if needed. - // Returns true if this function unlinked any backings from their owning texture while - // destroying them. - bool deleteEvictedBackings(); - - bool requestLate(CCPrioritizedTexture*); - - void reduceMemory(CCResourceProvider*); - void clearAllMemory(CCResourceProvider*); - - void acquireBackingTextureIfNeeded(CCPrioritizedTexture*, CCResourceProvider*); - - void registerTexture(CCPrioritizedTexture*); - void unregisterTexture(CCPrioritizedTexture*); - void returnBackingTexture(CCPrioritizedTexture*); - -private: - friend class CCPrioritizedTextureTest; - - enum EvictionPriorityPolicy { - RespectManagerPriorityCutoff, - DoNotRespectManagerPriorityCutoff, - }; - - // Compare textures. Highest priority first. - static inline bool compareTextures(CCPrioritizedTexture* a, CCPrioritizedTexture* b) - { - if (a->requestPriority() == b->requestPriority()) - return a < b; - return CCPriorityCalculator::priorityIsHigher(a->requestPriority(), b->requestPriority()); - } - // Compare backings. Lowest priority first. - static inline bool compareBackings(CCPrioritizedTexture::Backing* a, CCPrioritizedTexture::Backing* b) - { - int priorityA = a->requestPriorityAtLastPriorityUpdate(); - int priorityB = b->requestPriorityAtLastPriorityUpdate(); - if (priorityA != priorityB) - return CCPriorityCalculator::priorityIsLower(priorityA, priorityB); - bool aboveCutoffA = a->wasAbovePriorityCutoffAtLastPriorityUpdate(); - bool aboveCutoffB = b->wasAbovePriorityCutoffAtLastPriorityUpdate(); - if (!aboveCutoffA && aboveCutoffB) - return true; - if (aboveCutoffA && !aboveCutoffB) - return false; - return a < b; - } - - CCPrioritizedTextureManager(size_t maxMemoryLimitBytes, int maxTextureSize, int pool); - - void updateBackingsPriorities(); - void evictBackingsToReduceMemory(size_t limitBytes, EvictionPriorityPolicy, CCResourceProvider*); - CCPrioritizedTexture::Backing* createBacking(IntSize, GC3Denum format, CCResourceProvider*); - void evictBackingResource(CCPrioritizedTexture::Backing*, CCResourceProvider*); - -#if !ASSERT_DISABLED - void assertInvariants(); -#endif - - size_t m_maxMemoryLimitBytes; - unsigned m_priorityCutoff; - size_t m_memoryUseBytes; - size_t m_memoryAboveCutoffBytes; - size_t m_memoryAvailableBytes; - int m_pool; - - typedef base::hash_set TextureSet; - typedef ListHashSet BackingSet; - typedef Vector TextureVector; - - TextureSet m_textures; - BackingSet m_backings; - BackingVector m_evictedBackings; - - TextureVector m_tempTextureVector; - BackingVector m_tempBackingVector; - - // Set by the main thread when it adjust priorities in such a way that - // the m_backings array's view of priorities is now out of date. - bool m_needsUpdateBackingsPrioritites; - - DISALLOW_COPY_AND_ASSIGN(CCPrioritizedTextureManager); -}; - -} // namespace cc - -#endif +// Temporary forwarding header +#include "cc/prioritized_texture_manager.h" diff --git a/cc/CCPriorityCalculator.h b/cc/CCPriorityCalculator.h index 45f2e64a649bd0..973da9fef930ae 100644 --- a/cc/CCPriorityCalculator.h +++ b/cc/CCPriorityCalculator.h @@ -1,32 +1,6 @@ -// Copyright 2010 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCPriorityCalculator_h -#define CCPriorityCalculator_h - -#include "GraphicsContext3D.h" -#include "IntRect.h" -#include "IntSize.h" - -namespace cc { - -class CCPriorityCalculator { -public: - static int uiPriority(bool drawsToRootSurface); - static int visiblePriority(bool drawsToRootSurface); - static int renderSurfacePriority(); - static int lingeringPriority(int previousPriority); - static int priorityFromDistance(const IntRect& visibleRect, const IntRect& textureRect, bool drawsToRootSurface); - static int smallAnimatedLayerMinPriority(); - - static inline int highestPriority() { return std::numeric_limits::min(); } - static inline int lowestPriority() { return std::numeric_limits::max(); } - static inline bool priorityIsLower(int a, int b) { return a > b; } - static inline bool priorityIsHigher(int a, int b) { return a < b; } - static inline bool maxPriority(int a, int b) { return priorityIsHigher(a, b) ? a : b; } -}; - -} - -#endif +// Temporary forwarding header +#include "cc/priority_calculator.h" diff --git a/cc/CCProxy.h b/cc/CCProxy.h index 30a62cc55cc9a4..012f06fd73fc14 100644 --- a/cc/CCProxy.h +++ b/cc/CCProxy.h @@ -1,129 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCProxy_h -#define CCProxy_h - -#include "base/basictypes.h" -#include -#include -#include - -namespace cc { - -class CCThread; -class IntRect; -class IntSize; -struct CCRenderingStats; -struct RendererCapabilities; - -// Abstract class responsible for proxying commands from the main-thread side of -// the compositor over to the compositor implementation. -class CCProxy { -public: - static void setMainThread(CCThread*); - static CCThread* mainThread(); - - static bool hasImplThread(); - static void setImplThread(CCThread*); - static CCThread* implThread(); - - // Returns 0 if the current thread is neither the main thread nor the impl thread. - static CCThread* currentThread(); - - virtual ~CCProxy(); - - virtual bool compositeAndReadback(void *pixels, const IntRect&) = 0; - - virtual void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double durationSec) = 0; - - virtual void finishAllRendering() = 0; - - virtual bool isStarted() const = 0; - - // Attempts to initialize a context to use for rendering. Returns false if the context could not be created. - // The context will not be used and no frames may be produced until initializeRenderer() is called. - virtual bool initializeContext() = 0; - - // Indicates that the compositing surface associated with our context is ready to use. - virtual void setSurfaceReady() = 0; - - virtual void setVisible(bool) = 0; - - // Attempts to initialize the layer renderer. Returns false if the context isn't usable for compositing. - virtual bool initializeRenderer() = 0; - - // Attempts to recreate the context and layer renderer after a context lost. Returns false if the renderer couldn't be - // reinitialized. - virtual bool recreateContext() = 0; - - virtual void renderingStats(CCRenderingStats*) = 0; - - virtual const RendererCapabilities& rendererCapabilities() const = 0; - - virtual void setNeedsAnimate() = 0; - virtual void setNeedsCommit() = 0; - virtual void setNeedsRedraw() = 0; - - virtual void didAddAnimation() = 0; - - virtual bool commitRequested() const = 0; - - virtual void start() = 0; // Must be called before using the proxy. - virtual void stop() = 0; // Must be called before deleting the proxy. - - // Forces 3D commands on all contexts to wait for all previous SwapBuffers to finish before executing in the GPU - // process. - virtual void forceSerializeOnSwapBuffers() = 0; - - // Maximum number of sub-region texture updates supported for each commit. - virtual size_t maxPartialTextureUpdates() const = 0; - - virtual void acquireLayerTextures() = 0; - - // Debug hooks -#ifndef NDEBUG - static bool isMainThread(); - static bool isImplThread(); - static bool isMainThreadBlocked(); - static void setMainThreadBlocked(bool); -#endif - - // Testing hooks - virtual void loseContext() = 0; - -#ifndef NDEBUG - static void setCurrentThreadIsImplThread(bool); -#endif - -protected: - CCProxy(); - friend class DebugScopedSetImplThread; - friend class DebugScopedSetMainThreadBlocked; - -private: - DISALLOW_COPY_AND_ASSIGN(CCProxy); -}; - -class DebugScopedSetMainThreadBlocked { -public: - DebugScopedSetMainThreadBlocked() - { -#if !ASSERT_DISABLED - ASSERT(!CCProxy::isMainThreadBlocked()); - CCProxy::setMainThreadBlocked(true); -#endif - } - ~DebugScopedSetMainThreadBlocked() - { -#if !ASSERT_DISABLED - ASSERT(CCProxy::isMainThreadBlocked()); - CCProxy::setMainThreadBlocked(false); -#endif - } -}; - -} - -#endif +// Temporary forwarding header +#include "cc/proxy.h" diff --git a/cc/CCQuadCuller.h b/cc/CCQuadCuller.h index b3927cc6466315..097fb782688510 100644 --- a/cc/CCQuadCuller.h +++ b/cc/CCQuadCuller.h @@ -2,36 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCQuadCuller_h -#define CCQuadCuller_h - -#include "CCQuadSink.h" -#include "CCRenderPass.h" - -namespace cc { -class CCLayerImpl; -class CCRenderSurface; -template -class CCOcclusionTrackerBase; - -class CCQuadCuller : public CCQuadSink { -public: - CCQuadCuller(CCQuadList&, CCSharedQuadStateList&, CCLayerImpl*, const CCOcclusionTrackerBase*, bool showCullingWithDebugBorderQuads, bool forSurface); - virtual ~CCQuadCuller() { } - - // CCQuadSink implementation. - virtual CCSharedQuadState* useSharedQuadState(scoped_ptr) OVERRIDE; - virtual bool append(scoped_ptr, CCAppendQuadsData&) OVERRIDE; - -private: - CCQuadList& m_quadList; - CCSharedQuadStateList& m_sharedQuadStateList; - CCSharedQuadState* m_currentSharedQuadState; - CCLayerImpl* m_layer; - const CCOcclusionTrackerBase* m_occlusionTracker; - bool m_showCullingWithDebugBorderQuads; - bool m_forSurface; -}; - -} -#endif // CCQuadCuller_h +// Temporary forwarding header +#include "cc/quad_culler.h" diff --git a/cc/CCQuadSink.h b/cc/CCQuadSink.h index 06d31b0473c460..a503c6c639d148 100644 --- a/cc/CCQuadSink.h +++ b/cc/CCQuadSink.h @@ -2,29 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCQuadSink_h -#define CCQuadSink_h - -#include "base/memory/scoped_ptr.h" - -namespace cc { - -class CCDrawQuad; - -struct CCAppendQuadsData; -struct CCSharedQuadState; - -class CCQuadSink { -public: - virtual ~CCQuadSink() { } - - // Call this to add a SharedQuadState before appending quads that refer to it. Returns a pointer - // to the given SharedQuadState for convenience, that can be set on the quads to append. - virtual CCSharedQuadState* useSharedQuadState(scoped_ptr) = 0; - - // Returns true if the quad is added to the list, and false if the quad is entirely culled. - virtual bool append(scoped_ptr passDrawQuad, CCAppendQuadsData&) = 0; -}; - -} -#endif // CCQuadCuller_h +// Temporary forwarding header +#include "cc/quad_sink.h" diff --git a/cc/CCRenderPass.h b/cc/CCRenderPass.h index cdfa958dd27ea0..ab2ae64d9033b5 100644 --- a/cc/CCRenderPass.h +++ b/cc/CCRenderPass.h @@ -1,140 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCRenderPass_h -#define CCRenderPass_h - -#include "base/basictypes.h" -#include "cc/hash_pair.h" -#include "cc/scoped_ptr_hash_map.h" -#include "cc/scoped_ptr_vector.h" -#include "CCDrawQuad.h" -#include "CCSharedQuadState.h" -#include "FloatRect.h" -#include "SkColor.h" -#include -#include -#include - -namespace cc { - -class CCLayerImpl; -template -class CCOcclusionTrackerBase; -class CCRenderSurface; - -struct CCAppendQuadsData; - -typedef CCOcclusionTrackerBase CCOcclusionTrackerImpl; - -// A list of CCDrawQuad objects, sorted internally in front-to-back order. -class CCQuadList : public ScopedPtrVector { -public: - typedef reverse_iterator backToFrontIterator; - typedef const_reverse_iterator constBackToFrontIterator; - - inline backToFrontIterator backToFrontBegin() { return rbegin(); } - inline backToFrontIterator backToFrontEnd() { return rend(); } - inline constBackToFrontIterator backToFrontBegin() const { return rbegin(); } - inline constBackToFrontIterator backToFrontEnd() const { return rend(); } -}; - -typedef ScopedPtrVector CCSharedQuadStateList; - -class CCRenderPass { -public: - ~CCRenderPass(); - - struct Id { - int layerId; - int index; - - Id(int layerId, int index) - : layerId(layerId) - , index(index) - { - } - - bool operator==(const Id& other) const { return layerId == other.layerId && index == other.index; } - bool operator!=(const Id& other) const { return !(*this == other); } - bool operator<(const Id& other) const { return layerId < other.layerId || (layerId == other.layerId && index < other.index); } - }; - - static scoped_ptr create(Id, IntRect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget); - - // A shallow copy of the render pass, which does not include its quads. - scoped_ptr copy(Id newId) const; - - void appendQuadsForLayer(CCLayerImpl*, CCOcclusionTrackerImpl*, CCAppendQuadsData&); - void appendQuadsForRenderSurfaceLayer(CCLayerImpl*, const CCRenderPass* contributingRenderPass, CCOcclusionTrackerImpl*, CCAppendQuadsData&); - void appendQuadsToFillScreen(CCLayerImpl* rootLayer, SkColor screenBackgroundColor, const CCOcclusionTrackerImpl&); - - const CCQuadList& quadList() const { return m_quadList; } - - Id id() const { return m_id; } - - // FIXME: Modify this transform when merging the RenderPass into a parent compositor. - // Transforms from quad's original content space to the root target's content space. - const WebKit::WebTransformationMatrix& transformToRootTarget() const { return m_transformToRootTarget; } - - // This denotes the bounds in physical pixels of the output generated by this RenderPass. - const IntRect& outputRect() const { return m_outputRect; } - - FloatRect damageRect() const { return m_damageRect; } - void setDamageRect(FloatRect rect) { m_damageRect = rect; } - - const WebKit::WebFilterOperations& filters() const { return m_filters; } - void setFilters(const WebKit::WebFilterOperations& filters) { m_filters = filters; } - - const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; } - void setBackgroundFilters(const WebKit::WebFilterOperations& filters) { m_backgroundFilters = filters; } - - bool hasTransparentBackground() const { return m_hasTransparentBackground; } - void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; } - - bool hasOcclusionFromOutsideTargetSurface() const { return m_hasOcclusionFromOutsideTargetSurface; } - void setHasOcclusionFromOutsideTargetSurface(bool hasOcclusionFromOutsideTargetSurface) { m_hasOcclusionFromOutsideTargetSurface = hasOcclusionFromOutsideTargetSurface; } -protected: - CCRenderPass(Id, IntRect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget); - - Id m_id; - CCQuadList m_quadList; - CCSharedQuadStateList m_sharedQuadStateList; - WebKit::WebTransformationMatrix m_transformToRootTarget; - IntRect m_outputRect; - FloatRect m_damageRect; - bool m_hasTransparentBackground; - bool m_hasOcclusionFromOutsideTargetSurface; - WebKit::WebFilterOperations m_filters; - WebKit::WebFilterOperations m_backgroundFilters; - - DISALLOW_COPY_AND_ASSIGN(CCRenderPass); -}; - -} // namespace cc - -namespace BASE_HASH_NAMESPACE { -#if defined(COMPILER_MSVC) -template<> -inline size_t hash_value(const cc::CCRenderPass::Id& key) { - return hash_value >(std::pair(key.layerId, key.index)); -} -#elif defined(COMPILER_GCC) -template<> -struct hash { - size_t operator()(cc::CCRenderPass::Id key) const { - return hash >()(std::pair(key.layerId, key.index)); - } -}; -#else -#error define a hash function for your compiler -#endif // COMPILER -} - -namespace cc { -typedef std::vector CCRenderPassList; -typedef ScopedPtrHashMap CCRenderPassIdHashMap; -} // namespace cc - -#endif +// Temporary forwarding header +#include "cc/render_pass.h" diff --git a/cc/CCRenderPassDrawQuad.h b/cc/CCRenderPassDrawQuad.h index 99222d9edb83c4..d665960fa36a36 100644 --- a/cc/CCRenderPassDrawQuad.h +++ b/cc/CCRenderPassDrawQuad.h @@ -1,51 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCRenderPassDrawQuad_h -#define CCRenderPassDrawQuad_h - -#include "base/basictypes.h" -#include "base/memory/scoped_ptr.h" -#include "CCDrawQuad.h" -#include "CCRenderPass.h" -#include "CCResourceProvider.h" -#include "IntRect.h" - -namespace cc { - -class CCRenderPassDrawQuad : public CCDrawQuad { -public: - static scoped_ptr create(const CCSharedQuadState*, const IntRect&, CCRenderPass::Id renderPassId, bool isReplica, CCResourceProvider::ResourceId maskResourceId, const IntRect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY); - - CCRenderPass::Id renderPassId() const { return m_renderPassId; } - bool isReplica() const { return m_isReplica; } - CCResourceProvider::ResourceId maskResourceId() const { return m_maskResourceId; } - const IntRect& contentsChangedSinceLastFrame() const { return m_contentsChangedSinceLastFrame; } - - static const CCRenderPassDrawQuad* materialCast(const CCDrawQuad*); - float maskTexCoordScaleX() const { return m_maskTexCoordScaleX; } - float maskTexCoordScaleY() const { return m_maskTexCoordScaleY; } - float maskTexCoordOffsetX() const { return m_maskTexCoordOffsetX; } - float maskTexCoordOffsetY() const { return m_maskTexCoordOffsetY; } - - scoped_ptr copy(const CCSharedQuadState* copiedSharedQuadState, CCRenderPass::Id copiedRenderPassId) const; - -private: - CCRenderPassDrawQuad(const CCSharedQuadState*, const IntRect&, CCRenderPass::Id renderPassId, bool isReplica, CCResourceProvider::ResourceId maskResourceId, const IntRect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY); - - CCRenderPass::Id m_renderPassId; - bool m_isReplica; - CCResourceProvider::ResourceId m_maskResourceId; - IntRect m_contentsChangedSinceLastFrame; - float m_maskTexCoordScaleX; - float m_maskTexCoordScaleY; - float m_maskTexCoordOffsetX; - float m_maskTexCoordOffsetY; - - DISALLOW_COPY_AND_ASSIGN(CCRenderPassDrawQuad); -}; - -} - -#endif +// Temporary forwarding header +#include "cc/render_pass_draw_quad.h" diff --git a/cc/CCRenderPassSink.h b/cc/CCRenderPassSink.h index f3bac1d01e85da..6f8bf642e340ad 100644 --- a/cc/CCRenderPassSink.h +++ b/cc/CCRenderPassSink.h @@ -2,19 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCRenderPassSink_h -#define CCRenderPassSink_h - -#include "base/memory/scoped_ptr.h" - -namespace cc { - -class CCRenderPass; - -class CCRenderPassSink { -public: - virtual void appendRenderPass(scoped_ptr) = 0; -}; - -} -#endif // CCRenderPassSink_h +// Temporary forwarding header +#include "cc/render_pass_sink.h" diff --git a/cc/CCRenderSurface.h b/cc/CCRenderSurface.h index afdf062de998b1..7747efd8137717 100644 --- a/cc/CCRenderSurface.h +++ b/cc/CCRenderSurface.h @@ -1,132 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCRenderSurface_h -#define CCRenderSurface_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "base/basictypes.h" -#include "base/memory/scoped_ptr.h" -#include "CCRenderPass.h" -#include "CCSharedQuadState.h" -#include "FloatRect.h" -#include "IntRect.h" -#include - -namespace cc { - -class CCDamageTracker; -class CCDelegatedRendererLayerImpl; -class CCQuadSink; -class CCRenderPassSink; -class CCLayerImpl; - -struct CCAppendQuadsData; - -class CCRenderSurface { -public: - explicit CCRenderSurface(CCLayerImpl*); - virtual ~CCRenderSurface(); - - std::string name() const; - void dumpSurface(std::string*, int indent) const; - - FloatPoint contentRectCenter() const { return FloatRect(m_contentRect).center(); } - - // Returns the rect that encloses the RenderSurface including any reflection. - FloatRect drawableContentRect() const; - - float drawOpacity() const { return m_drawOpacity; } - void setDrawOpacity(float opacity) { m_drawOpacity = opacity; } - - void setNearestAncestorThatMovesPixels(CCRenderSurface* surface) { m_nearestAncestorThatMovesPixels = surface; } - const CCRenderSurface* nearestAncestorThatMovesPixels() const { return m_nearestAncestorThatMovesPixels; } - - bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; } - void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; } - - void setDrawTransform(const WebKit::WebTransformationMatrix& drawTransform) { m_drawTransform = drawTransform; } - const WebKit::WebTransformationMatrix& drawTransform() const { return m_drawTransform; } - - void setScreenSpaceTransform(const WebKit::WebTransformationMatrix& screenSpaceTransform) { m_screenSpaceTransform = screenSpaceTransform; } - const WebKit::WebTransformationMatrix& screenSpaceTransform() const { return m_screenSpaceTransform; } - - void setReplicaDrawTransform(const WebKit::WebTransformationMatrix& replicaDrawTransform) { m_replicaDrawTransform = replicaDrawTransform; } - const WebKit::WebTransformationMatrix& replicaDrawTransform() const { return m_replicaDrawTransform; } - - void setReplicaScreenSpaceTransform(const WebKit::WebTransformationMatrix& replicaScreenSpaceTransform) { m_replicaScreenSpaceTransform = replicaScreenSpaceTransform; } - const WebKit::WebTransformationMatrix& replicaScreenSpaceTransform() const { return m_replicaScreenSpaceTransform; } - - bool targetSurfaceTransformsAreAnimating() const { return m_targetSurfaceTransformsAreAnimating; } - void setTargetSurfaceTransformsAreAnimating(bool animating) { m_targetSurfaceTransformsAreAnimating = animating; } - bool screenSpaceTransformsAreAnimating() const { return m_screenSpaceTransformsAreAnimating; } - void setScreenSpaceTransformsAreAnimating(bool animating) { m_screenSpaceTransformsAreAnimating = animating; } - - void setClipRect(const IntRect&); - const IntRect& clipRect() const { return m_clipRect; } - - bool contentsChanged() const; - - void setContentRect(const IntRect&); - const IntRect& contentRect() const { return m_contentRect; } - - std::vector& layerList() { return m_layerList; } - void addContributingDelegatedRenderPassLayer(CCLayerImpl*); - void clearLayerLists(); - - int owningLayerId() const; - - void resetPropertyChangedFlag() { m_surfacePropertyChanged = false; } - bool surfacePropertyChanged() const; - bool surfacePropertyChangedOnlyFromDescendant() const; - - CCDamageTracker* damageTracker() const { return m_damageTracker.get(); } - - CCRenderPass::Id renderPassId(); - - void appendRenderPasses(CCRenderPassSink&); - void appendQuads(CCQuadSink&, CCAppendQuadsData&, bool forReplica, CCRenderPass::Id renderPassId); - -private: - CCLayerImpl* m_owningLayer; - - // Uses this surface's space. - IntRect m_contentRect; - bool m_surfacePropertyChanged; - - float m_drawOpacity; - bool m_drawOpacityIsAnimating; - WebKit::WebTransformationMatrix m_drawTransform; - WebKit::WebTransformationMatrix m_screenSpaceTransform; - WebKit::WebTransformationMatrix m_replicaDrawTransform; - WebKit::WebTransformationMatrix m_replicaScreenSpaceTransform; - bool m_targetSurfaceTransformsAreAnimating; - bool m_screenSpaceTransformsAreAnimating; - - // Uses the space of the surface's target surface. - IntRect m_clipRect; - - std::vector m_layerList; - std::vector m_contributingDelegatedRenderPassLayerList; - - // The nearest ancestor target surface that will contain the contents of this surface, and that is going - // to move pixels within the surface (such as with a blur). This can point to itself. - CCRenderSurface* m_nearestAncestorThatMovesPixels; - - scoped_ptr m_damageTracker; - - // For CCLayerIteratorActions - int m_targetRenderSurfaceLayerIndexHistory; - int m_currentLayerIndexHistory; - - friend struct CCLayerIteratorActions; - - DISALLOW_COPY_AND_ASSIGN(CCRenderSurface); -}; - -} -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/render_surface_impl.h" diff --git a/cc/CCRenderSurfaceFilters.h b/cc/CCRenderSurfaceFilters.h index cd199b5679a69d..f102a22583265d 100644 --- a/cc/CCRenderSurfaceFilters.h +++ b/cc/CCRenderSurfaceFilters.h @@ -2,33 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef CCRenderSurfaceFilters_h -#define CCRenderSurfaceFilters_h - -#if USE(ACCELERATED_COMPOSITING) - -class GrContext; -class SkBitmap; - -namespace WebKit { -class WebFilterOperations; -class WebGraphicsContext3D; -} - -namespace cc { -class FloatSize; - -class CCRenderSurfaceFilters { -public: - static SkBitmap apply(const WebKit::WebFilterOperations& filters, unsigned textureId, const FloatSize&, WebKit::WebGraphicsContext3D*, GrContext*); - static WebKit::WebFilterOperations optimize(const WebKit::WebFilterOperations& filters); - -private: - CCRenderSurfaceFilters(); -}; - -} -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/render_surface_filters.h" diff --git a/cc/CCRenderer.h b/cc/CCRenderer.h index 740ba0b293e758..3e37b7f8ac36b7 100644 --- a/cc/CCRenderer.h +++ b/cc/CCRenderer.h @@ -2,83 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCRenderer_h -#define CCRenderer_h - -#include "base/basictypes.h" -#include "CCLayerTreeHost.h" -#include "CCRenderPass.h" -#include "FloatQuad.h" -#include "IntRect.h" -#include - -namespace cc { - -class CCScopedTexture; - -class CCRendererClient { -public: - virtual const IntSize& deviceViewportSize() const = 0; - virtual const CCLayerTreeSettings& settings() const = 0; - virtual void didLoseContext() = 0; - virtual void onSwapBuffersComplete() = 0; - virtual void releaseContentsTextures() = 0; - virtual void setFullRootLayerDamage() = 0; - virtual void setMemoryAllocationLimitBytes(size_t) = 0; -protected: - virtual ~CCRendererClient() { } -}; - -class CCRenderer { -public: - // This enum defines the various resource pools for the CCResourceProvider - // where textures get allocated. - enum ResourcePool { - ImplPool = 1, // This pool is for textures that get allocated on the impl thread (e.g. RenderSurfaces). - ContentPool // This pool is for textures that get allocated on the main thread (e.g. tiles). - }; - - virtual ~CCRenderer() { } - - virtual const RendererCapabilities& capabilities() const = 0; - - const CCLayerTreeSettings& settings() const { return m_client->settings(); } - - const IntSize& viewportSize() { return m_client->deviceViewportSize(); } - int viewportWidth() { return viewportSize().width(); } - int viewportHeight() { return viewportSize().height(); } - - virtual void viewportChanged() { } - - virtual void decideRenderPassAllocationsForFrame(const CCRenderPassList&) { } - virtual bool haveCachedResourcesForRenderPassId(CCRenderPass::Id) const; - - virtual void drawFrame(const CCRenderPassList&, const CCRenderPassIdHashMap&) = 0; - - // waits for rendering to finish - virtual void finish() = 0; - - virtual void doNoOp() { } - // puts backbuffer onscreen - virtual bool swapBuffers() = 0; - - virtual void getFramebufferPixels(void *pixels, const IntRect&) = 0; - - virtual bool isContextLost(); - - virtual void setVisible(bool) = 0; - -protected: - explicit CCRenderer(CCRendererClient* client) - : m_client(client) - { - } - - CCRendererClient* m_client; - - DISALLOW_COPY_AND_ASSIGN(CCRenderer); -}; - -} - -#endif // CCRenderer_h +// Temporary forwarding header +#include "cc/renderer.h" diff --git a/cc/CCRendererGL.h b/cc/CCRendererGL.h index a5f2c4f056da0f..a4458d6c793f58 100644 --- a/cc/CCRendererGL.h +++ b/cc/CCRendererGL.h @@ -1,240 +1,6 @@ -// Copyright 2010 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef CCRendererGL_h -#define CCRendererGL_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "base/basictypes.h" -#include "CCCheckerboardDrawQuad.h" -#include "CCDebugBorderDrawQuad.h" -#include "CCDirectRenderer.h" -#include "CCIOSurfaceDrawQuad.h" -#include "CCRenderPassDrawQuad.h" -#include "CCRenderer.h" -#include "CCSolidColorDrawQuad.h" -#include "CCStreamVideoDrawQuad.h" -#include "CCTextureDrawQuad.h" -#include "CCTileDrawQuad.h" -#include "CCYUVVideoDrawQuad.h" -#include "Extensions3DChromium.h" -#include - -namespace WebKit { -class WebGraphicsContext3D; -} - -namespace cc { - -class CCScopedTexture; -class GeometryBinding; -class ScopedEnsureFramebufferAllocation; - -// Class that handles drawing of composited render layers using GL. -class CCRendererGL : public CCDirectRenderer, - public WebKit::WebGraphicsContext3D::WebGraphicsSwapBuffersCompleteCallbackCHROMIUM, - public WebKit::WebGraphicsContext3D::WebGraphicsMemoryAllocationChangedCallbackCHROMIUM , - public WebKit::WebGraphicsContext3D::WebGraphicsContextLostCallback { -public: - static PassOwnPtr create(CCRendererClient*, CCResourceProvider*); - - virtual ~CCRendererGL(); - - virtual const RendererCapabilities& capabilities() const OVERRIDE; - - WebKit::WebGraphicsContext3D* context(); - - virtual void viewportChanged() OVERRIDE; - - const FloatQuad& sharedGeometryQuad() const { return m_sharedGeometryQuad; } - - // waits for rendering to finish - virtual void finish() OVERRIDE; - - virtual void doNoOp() OVERRIDE; - // puts backbuffer onscreen - virtual bool swapBuffers() OVERRIDE; - - static void debugGLCall(WebKit::WebGraphicsContext3D*, const char* command, const char* file, int line); - - const GeometryBinding* sharedGeometry() const { return m_sharedGeometry.get(); } - - virtual void getFramebufferPixels(void *pixels, const IntRect&) OVERRIDE; - bool getFramebufferTexture(CCScopedTexture*, const IntRect& deviceRect); - - virtual bool isContextLost() OVERRIDE; - - virtual void setVisible(bool) OVERRIDE; - -protected: - CCRendererGL(CCRendererClient*, CCResourceProvider*); - - bool isFramebufferDiscarded() const { return m_isFramebufferDiscarded; } - bool initialize(); - - void releaseRenderPassTextures(); - - virtual void bindFramebufferToOutputSurface(DrawingFrame&) OVERRIDE; - virtual bool bindFramebufferToTexture(DrawingFrame&, const CCScopedTexture*, const IntRect& framebufferRect) OVERRIDE; - virtual void setDrawViewportSize(const IntSize&) OVERRIDE; - virtual void enableScissorTestRect(const IntRect& scissorRect) OVERRIDE; - virtual void disableScissorTest() OVERRIDE; - virtual void clearFramebuffer(DrawingFrame&) OVERRIDE; - virtual void drawQuad(DrawingFrame&, const CCDrawQuad*) OVERRIDE; - virtual void beginDrawingFrame(DrawingFrame&) OVERRIDE; - virtual void finishDrawingFrame(DrawingFrame&) OVERRIDE; - virtual bool flippedFramebuffer() const OVERRIDE; - -private: - static void toGLMatrix(float*, const WebKit::WebTransformationMatrix&); - - void drawCheckerboardQuad(const DrawingFrame&, const CCCheckerboardDrawQuad*); - void drawDebugBorderQuad(const DrawingFrame&, const CCDebugBorderDrawQuad*); - PassOwnPtr drawBackgroundFilters(DrawingFrame&, const CCRenderPassDrawQuad*, const WebKit::WebFilterOperations&, const WebKit::WebTransformationMatrix& deviceTransform); - void drawRenderPassQuad(DrawingFrame&, const CCRenderPassDrawQuad*); - void drawSolidColorQuad(const DrawingFrame&, const CCSolidColorDrawQuad*); - void drawStreamVideoQuad(const DrawingFrame&, const CCStreamVideoDrawQuad*); - void drawTextureQuad(const DrawingFrame&, const CCTextureDrawQuad*); - void drawIOSurfaceQuad(const DrawingFrame&, const CCIOSurfaceDrawQuad*); - void drawTileQuad(const DrawingFrame&, const CCTileDrawQuad*); - void drawYUVVideoQuad(const DrawingFrame&, const CCYUVVideoDrawQuad*); - - void setShaderOpacity(float opacity, int alphaLocation); - void setShaderFloatQuad(const FloatQuad&, int quadLocation); - void drawQuadGeometry(const DrawingFrame&, const WebKit::WebTransformationMatrix& drawTransform, const FloatRect& quadRect, int matrixLocation); - - void copyTextureToFramebuffer(const DrawingFrame&, int textureId, const IntRect&, const WebKit::WebTransformationMatrix& drawMatrix); - - bool useScopedTexture(DrawingFrame&, const CCScopedTexture*, const IntRect& viewportRect); - - bool makeContextCurrent(); - - bool initializeSharedObjects(); - void cleanupSharedObjects(); - - // WebKit::WebGraphicsContext3D::WebGraphicsSwapBuffersCompleteCallbackCHROMIUM implementation. - virtual void onSwapBuffersComplete() OVERRIDE; - - // WebKit::WebGraphicsContext3D::WebGraphicsMemoryAllocationChangedCallbackCHROMIUM implementation. - virtual void onMemoryAllocationChanged(WebKit::WebGraphicsMemoryAllocation) OVERRIDE; - void onMemoryAllocationChangedOnImplThread(WebKit::WebGraphicsMemoryAllocation); - void discardFramebuffer(); - void ensureFramebuffer(); - - // WebGraphicsContext3D::WebGraphicsContextLostCallback implementation. - virtual void onContextLost() OVERRIDE; - - RendererCapabilities m_capabilities; - - unsigned m_offscreenFramebufferId; - - OwnPtr m_sharedGeometry; - FloatQuad m_sharedGeometryQuad; - - // This block of bindings defines all of the programs used by the compositor itself. - - // Tiled layer shaders. - typedef ProgramBinding TileProgram; - typedef ProgramBinding TileProgramAA; - typedef ProgramBinding TileProgramSwizzleAA; - typedef ProgramBinding TileProgramOpaque; - typedef ProgramBinding TileProgramSwizzle; - typedef ProgramBinding TileProgramSwizzleOpaque; - typedef ProgramBinding TileCheckerboardProgram; - - // Render surface shaders. - typedef ProgramBinding RenderPassProgram; - typedef ProgramBinding RenderPassMaskProgram; - typedef ProgramBinding RenderPassProgramAA; - typedef ProgramBinding RenderPassMaskProgramAA; - - // Texture shaders. - typedef ProgramBinding TextureProgram; - typedef ProgramBinding TextureProgramFlip; - typedef ProgramBinding TextureIOSurfaceProgram; - - // Video shaders. - typedef ProgramBinding VideoStreamTextureProgram; - typedef ProgramBinding VideoYUVProgram; - - // Special purpose / effects shaders. - typedef ProgramBinding SolidColorProgram; - - const TileProgram* tileProgram(); - const TileProgramOpaque* tileProgramOpaque(); - const TileProgramAA* tileProgramAA(); - const TileProgramSwizzle* tileProgramSwizzle(); - const TileProgramSwizzleOpaque* tileProgramSwizzleOpaque(); - const TileProgramSwizzleAA* tileProgramSwizzleAA(); - const TileCheckerboardProgram* tileCheckerboardProgram(); - - const RenderPassProgram* renderPassProgram(); - const RenderPassProgramAA* renderPassProgramAA(); - const RenderPassMaskProgram* renderPassMaskProgram(); - const RenderPassMaskProgramAA* renderPassMaskProgramAA(); - - const TextureProgram* textureProgram(); - const TextureProgramFlip* textureProgramFlip(); - const TextureIOSurfaceProgram* textureIOSurfaceProgram(); - - const VideoYUVProgram* videoYUVProgram(); - const VideoStreamTextureProgram* videoStreamTextureProgram(); - - const SolidColorProgram* solidColorProgram(); - - OwnPtr m_tileProgram; - OwnPtr m_tileProgramOpaque; - OwnPtr m_tileProgramAA; - OwnPtr m_tileProgramSwizzle; - OwnPtr m_tileProgramSwizzleOpaque; - OwnPtr m_tileProgramSwizzleAA; - OwnPtr m_tileCheckerboardProgram; - - OwnPtr m_renderPassProgram; - OwnPtr m_renderPassProgramAA; - OwnPtr m_renderPassMaskProgram; - OwnPtr m_renderPassMaskProgramAA; - - OwnPtr m_textureProgram; - OwnPtr m_textureProgramFlip; - OwnPtr m_textureIOSurfaceProgram; - - OwnPtr m_videoYUVProgram; - OwnPtr m_videoStreamTextureProgram; - - OwnPtr m_solidColorProgram; - - WebKit::WebGraphicsContext3D* m_context; - - IntRect m_swapBufferRect; - bool m_isViewportChanged; - bool m_isFramebufferDiscarded; - bool m_isUsingBindUniform; - bool m_visible; - - OwnPtr m_currentFramebufferLock; - - DISALLOW_COPY_AND_ASSIGN(CCRendererGL); -}; - - -// Setting DEBUG_GL_CALLS to 1 will call glGetError() after almost every GL -// call made by the compositor. Useful for debugging rendering issues but -// will significantly degrade performance. -#define DEBUG_GL_CALLS 0 - -#if DEBUG_GL_CALLS && !defined ( NDEBUG ) -#define GLC(context, x) (x, CCRendererGL::debugGLCall(&*context, #x, __FILE__, __LINE__)) -#else -#define GLC(context, x) (x) -#endif - - -} - -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/gl_renderer.h" diff --git a/cc/CCRendererSoftware.h b/cc/CCRendererSoftware.h index 2ad688fc0a1f6a..827aa21d595775 100644 --- a/cc/CCRendererSoftware.h +++ b/cc/CCRendererSoftware.h @@ -2,75 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCRendererSoftware_h -#define CCRendererSoftware_h - -#include "base/basictypes.h" -#include "CCDirectRenderer.h" -#include "CCLayerTreeHost.h" -#include - -namespace cc { - -class CCDebugBorderDrawQuad; -class CCRendererClient; -class CCResourceProvider; -class CCSolidColorDrawQuad; -class CCTextureDrawQuad; -class CCTileDrawQuad; - -class CCRendererSoftware : public CCDirectRenderer { -public: - static PassOwnPtr create(CCRendererClient*, CCResourceProvider*, WebKit::WebCompositorSoftwareOutputDevice*); - virtual ~CCRendererSoftware(); - - virtual const RendererCapabilities& capabilities() const OVERRIDE; - - virtual void viewportChanged() OVERRIDE; - - virtual void finish() OVERRIDE; - - virtual bool swapBuffers() OVERRIDE; - - virtual void getFramebufferPixels(void *pixels, const IntRect&) OVERRIDE; - - virtual void setVisible(bool) OVERRIDE; - -protected: - virtual void bindFramebufferToOutputSurface(DrawingFrame&) OVERRIDE; - virtual bool bindFramebufferToTexture(DrawingFrame&, const CCScopedTexture*, const IntRect& framebufferRect) OVERRIDE; - virtual void setDrawViewportSize(const IntSize&) OVERRIDE; - virtual void enableScissorTestRect(const IntRect& scissorRect) OVERRIDE; - virtual void disableScissorTest() OVERRIDE; - virtual void clearFramebuffer(DrawingFrame&) OVERRIDE; - virtual void drawQuad(DrawingFrame&, const CCDrawQuad*) OVERRIDE; - virtual void beginDrawingFrame(DrawingFrame&) OVERRIDE; - virtual void finishDrawingFrame(DrawingFrame&) OVERRIDE; - virtual bool flippedFramebuffer() const OVERRIDE; - -private: - CCRendererSoftware(CCRendererClient*, CCResourceProvider*, WebKit::WebCompositorSoftwareOutputDevice*); - - bool isSoftwareResource(CCResourceProvider::ResourceId) const; - - void drawDebugBorderQuad(const DrawingFrame&, const CCDebugBorderDrawQuad*); - void drawSolidColorQuad(const DrawingFrame&, const CCSolidColorDrawQuad*); - void drawTextureQuad(const DrawingFrame&, const CCTextureDrawQuad*); - void drawTileQuad(const DrawingFrame&, const CCTileDrawQuad*); - void drawUnsupportedQuad(const DrawingFrame&, const CCDrawQuad*); - - RendererCapabilities m_capabilities; - bool m_visible; - - WebKit::WebCompositorSoftwareOutputDevice* m_outputDevice; - OwnPtr m_skRootCanvas; - SkCanvas* m_skCurrentCanvas; - SkPaint m_skCurrentPaint; - OwnPtr m_currentFramebufferLock; - - DISALLOW_COPY_AND_ASSIGN(CCRendererSoftware); -}; - -} - -#endif +// Temporary forwarding header +#include "cc/software_renderer.h" diff --git a/cc/CCRenderingStats.h b/cc/CCRenderingStats.h index fb178a89722fe3..d95e987152ca4a 100644 --- a/cc/CCRenderingStats.h +++ b/cc/CCRenderingStats.h @@ -2,37 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCRenderingStats_h -#define CCRenderingStats_h - -namespace cc { - -struct CCRenderingStats { - // FIXME: Rename these to animationFrameCount and screenFrameCount, crbug.com/138641. - int numAnimationFrames; - int numFramesSentToScreen; - int droppedFrameCount; - double totalPaintTimeInSeconds; - double totalRasterizeTimeInSeconds; - double totalCommitTimeInSeconds; - size_t totalCommitCount; - size_t numImplThreadScrolls; - size_t numMainThreadScrolls; - - CCRenderingStats() - : numAnimationFrames(0) - , numFramesSentToScreen(0) - , droppedFrameCount(0) - , totalPaintTimeInSeconds(0) - , totalRasterizeTimeInSeconds(0) - , totalCommitTimeInSeconds(0) - , totalCommitCount(0) - , numImplThreadScrolls(0) - , numMainThreadScrolls(0) - { - } -}; - -} - -#endif +// Temporary forwarding header +#include "cc/rendering_stats.h" diff --git a/cc/CCResourceProvider.h b/cc/CCResourceProvider.h index f515c112daf733..be760bbdec242c 100644 --- a/cc/CCResourceProvider.h +++ b/cc/CCResourceProvider.h @@ -2,274 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCResourceProvider_h -#define CCResourceProvider_h - -#include "base/basictypes.h" -#include "CCGraphicsContext.h" -#include "GraphicsContext3D.h" -#include "IntSize.h" -#include "SkBitmap.h" -#include "SkCanvas.h" -#include "TextureCopier.h" -#include -#include -#include -#include -#include -#include -#include - -namespace WebKit { -class WebGraphicsContext3D; -} - -namespace cc { - -class IntRect; -class LayerTextureSubImage; -class TextureCopier; -class TextureUploader; - -// Thread-safety notes: this class is not thread-safe and can only be called -// from the thread it was created on (in practice, the compositor thread). -class CCResourceProvider { -public: - typedef unsigned ResourceId; - typedef Vector ResourceIdArray; - typedef HashMap ResourceIdMap; - enum TextureUsageHint { TextureUsageAny, TextureUsageFramebuffer }; - enum ResourceType { - GLTexture = 1, - Bitmap, - }; - struct Mailbox { - GC3Dbyte name[64]; - }; - struct TransferableResource { - unsigned id; - GC3Denum format; - IntSize size; - Mailbox mailbox; - }; - typedef Vector TransferableResourceArray; - struct TransferableResourceList { - TransferableResourceList(); - ~TransferableResourceList(); - - TransferableResourceArray resources; - unsigned syncPoint; - }; - - static PassOwnPtr create(CCGraphicsContext*); - - virtual ~CCResourceProvider(); - - WebKit::WebGraphicsContext3D* graphicsContext3D(); - TextureUploader* textureUploader() const { return m_textureUploader.get(); } - TextureCopier* textureCopier() const { return m_textureCopier.get(); } - int maxTextureSize() const { return m_maxTextureSize; } - unsigned numResources() const { return m_resources.size(); } - - // Checks whether a resource is in use by a consumer. - bool inUseByConsumer(ResourceId); - - - // Producer interface. - - void setDefaultResourceType(ResourceType type) { m_defaultResourceType = type; } - ResourceType defaultResourceType() const { return m_defaultResourceType; } - ResourceType resourceType(ResourceId); - - // Creates a resource of the default resource type. - ResourceId createResource(int pool, const IntSize&, GC3Denum format, TextureUsageHint); - - // You can also explicitly create a specific resource type. - ResourceId createGLTexture(int pool, const IntSize&, GC3Denum format, TextureUsageHint); - ResourceId createBitmap(int pool, const IntSize&); - // Wraps an external texture into a GL resource. - ResourceId createResourceFromExternalTexture(unsigned textureId); - - void deleteResource(ResourceId); - - // Deletes all resources owned by a given pool. - void deleteOwnedResources(int pool); - - // Upload data from image, copying sourceRect (in image) into destRect (in the resource). - void upload(ResourceId, const uint8_t* image, const IntRect& imageRect, const IntRect& sourceRect, const IntSize& destOffset); - - // Flush all context operations, kicking uploads and ensuring ordering with - // respect to other contexts. - void flush(); - - // Only flush the command buffer if supported. - // Returns true if the shallow flush occurred, false otherwise. - bool shallowFlushIfSupported(); - - // Creates accounting for a child, and associate it with a pool. Resources - // transfered from that child will go to that pool. Returns a child ID. - int createChild(int pool); - - // Destroys accounting for the child, deleting all resources from that pool. - void destroyChild(int child); - - // Gets the child->parent resource ID map. - const ResourceIdMap& getChildToParentMap(int child) const; - - // Prepares resources to be transfered to the parent, moving them to - // mailboxes and serializing meta-data into TransferableResources. - // Resources are not removed from the CCResourceProvider, but are markes as - // "in use". - TransferableResourceList prepareSendToParent(const ResourceIdArray&); - - // Prepares resources to be transfered back to the child, moving them to - // mailboxes and serializing meta-data into TransferableResources. - // Resources are removed from the CCResourceProvider. Note: the resource IDs - // passed are in the parent namespace and will be translated to the child - // namespace when returned. - TransferableResourceList prepareSendToChild(int child, const ResourceIdArray&); - - // Receives resources from a child, moving them from mailboxes. Resource IDs - // passed are in the child namespace, and will be translated to the parent - // namespace, added to the child->parent map. - // NOTE: if the syncPoint filed in TransferableResourceList is set, this - // will wait on it. - void receiveFromChild(int child, const TransferableResourceList&); - - // Receives resources from the parent, moving them from mailboxes. Resource IDs - // passed are in the child namespace. - // NOTE: if the syncPoint filed in TransferableResourceList is set, this - // will wait on it. - void receiveFromParent(const TransferableResourceList&); - - // Only for testing - size_t mailboxCount() const { return m_mailboxes.size(); } - - // The following lock classes are part of the CCResourceProvider API and are - // needed to read and write the resource contents. The user must ensure - // that they only use GL locks on GL resources, etc, and this is enforced - // by assertions. - class ScopedReadLockGL { - public: - ScopedReadLockGL(CCResourceProvider*, CCResourceProvider::ResourceId); - ~ScopedReadLockGL(); - - unsigned textureId() const { return m_textureId; } - - private: - CCResourceProvider* m_resourceProvider; - CCResourceProvider::ResourceId m_resourceId; - unsigned m_textureId; - - DISALLOW_COPY_AND_ASSIGN(ScopedReadLockGL); - }; - - class ScopedWriteLockGL { - public: - ScopedWriteLockGL(CCResourceProvider*, CCResourceProvider::ResourceId); - ~ScopedWriteLockGL(); - - unsigned textureId() const { return m_textureId; } - - private: - CCResourceProvider* m_resourceProvider; - CCResourceProvider::ResourceId m_resourceId; - unsigned m_textureId; - - DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGL); - }; - - class ScopedReadLockSoftware { - public: - ScopedReadLockSoftware(CCResourceProvider*, CCResourceProvider::ResourceId); - ~ScopedReadLockSoftware(); - - const SkBitmap* skBitmap() const { return &m_skBitmap; } - - private: - CCResourceProvider* m_resourceProvider; - CCResourceProvider::ResourceId m_resourceId; - SkBitmap m_skBitmap; - - DISALLOW_COPY_AND_ASSIGN(ScopedReadLockSoftware); - }; - - class ScopedWriteLockSoftware { - public: - ScopedWriteLockSoftware(CCResourceProvider*, CCResourceProvider::ResourceId); - ~ScopedWriteLockSoftware(); - - SkCanvas* skCanvas() { return m_skCanvas.get(); } - - private: - CCResourceProvider* m_resourceProvider; - CCResourceProvider::ResourceId m_resourceId; - SkBitmap m_skBitmap; - OwnPtr m_skCanvas; - - DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockSoftware); - }; - -private: - struct Resource { - Resource(); - Resource(unsigned textureId, int pool, const IntSize& size, GC3Denum format); - Resource(uint8_t* pixels, int pool, const IntSize& size, GC3Denum format); - - unsigned glId; - uint8_t* pixels; - int pool; - int lockForReadCount; - bool lockedForWrite; - bool external; - bool exported; - IntSize size; - GC3Denum format; - ResourceType type; - }; - typedef HashMap ResourceMap; - struct Child { - Child(); - ~Child(); - - int pool; - ResourceIdMap childToParentMap; - ResourceIdMap parentToChildMap; - }; - typedef HashMap ChildMap; - - explicit CCResourceProvider(CCGraphicsContext*); - bool initialize(); - - const Resource* lockForRead(ResourceId); - void unlockForRead(ResourceId); - const Resource* lockForWrite(ResourceId); - void unlockForWrite(ResourceId); - static void populateSkBitmapWithResource(SkBitmap*, const Resource*); - - bool transferResource(WebKit::WebGraphicsContext3D*, ResourceId, TransferableResource*); - void trimMailboxDeque(); - - CCGraphicsContext* m_context; - ResourceId m_nextId; - ResourceMap m_resources; - int m_nextChild; - ChildMap m_children; - - Deque m_mailboxes; - - ResourceType m_defaultResourceType; - bool m_useTextureStorageExt; - bool m_useTextureUsageHint; - bool m_useShallowFlush; - OwnPtr m_texSubImage; - OwnPtr m_textureUploader; - OwnPtr m_textureCopier; - int m_maxTextureSize; - - DISALLOW_COPY_AND_ASSIGN(CCResourceProvider); -}; - -} - -#endif +// Temporary forwarding header +#include "cc/resource_provider.h" diff --git a/cc/CCScheduler.h b/cc/CCScheduler.h index 1b483074b7cbd2..70327796619704 100644 --- a/cc/CCScheduler.h +++ b/cc/CCScheduler.h @@ -1,109 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCScheduler_h -#define CCScheduler_h - -#include "base/basictypes.h" -#include "base/memory/scoped_ptr.h" -#include "base/time.h" -#include "CCFrameRateController.h" -#include "CCSchedulerStateMachine.h" -#include - -namespace cc { - -class CCThread; - -struct CCScheduledActionDrawAndSwapResult { - CCScheduledActionDrawAndSwapResult() - : didDraw(false) - , didSwap(false) - { - } - CCScheduledActionDrawAndSwapResult(bool didDraw, bool didSwap) - : didDraw(didDraw) - , didSwap(didSwap) - { - } - bool didDraw; - bool didSwap; -}; - -class CCSchedulerClient { -public: - virtual void scheduledActionBeginFrame() = 0; - virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible() = 0; - virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced() = 0; - virtual void scheduledActionCommit() = 0; - virtual void scheduledActionBeginContextRecreation() = 0; - virtual void scheduledActionAcquireLayerTexturesForMainThread() = 0; - virtual void didAnticipatedDrawTimeChange(base::TimeTicks) = 0; - -protected: - virtual ~CCSchedulerClient() { } -}; - -class CCScheduler : CCFrameRateControllerClient { -public: - static PassOwnPtr create(CCSchedulerClient* client, scoped_ptr frameRateController) - { - return adoptPtr(new CCScheduler(client, frameRateController.Pass())); - } - - virtual ~CCScheduler(); - - void setCanBeginFrame(bool); - - void setVisible(bool); - void setCanDraw(bool); - - void setNeedsCommit(); - - // Like setNeedsCommit(), but ensures a commit will definitely happen even if we are not visible. - void setNeedsForcedCommit(); - - void setNeedsRedraw(); - - void setMainThreadNeedsLayerTextures(); - - // Like setNeedsRedraw(), but ensures the draw will definitely happen even if we are not visible. - void setNeedsForcedRedraw(); - - void beginFrameComplete(); - void beginFrameAborted(); - - void setMaxFramesPending(int); - void setSwapBuffersCompleteSupported(bool); - void didSwapBuffersComplete(); - - void didLoseContext(); - void didRecreateContext(); - - bool commitPending() const { return m_stateMachine.commitPending(); } - bool redrawPending() const { return m_stateMachine.redrawPending(); } - - void setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval); - - base::TimeTicks anticipatedDrawTime(); - - // CCFrameRateControllerClient implementation - virtual void vsyncTick(bool throttled) OVERRIDE; - -private: - CCScheduler(CCSchedulerClient*, scoped_ptr); - - void processScheduledActions(); - - CCSchedulerClient* m_client; - scoped_ptr m_frameRateController; - CCSchedulerStateMachine m_stateMachine; - bool m_insideProcessScheduledActions; - - DISALLOW_COPY_AND_ASSIGN(CCScheduler); -}; - -} // namespace cc - -#endif // CCScheduler_h +// Temporary forwarding header +#include "cc/scheduler.h" diff --git a/cc/CCSchedulerStateMachine.h b/cc/CCSchedulerStateMachine.h index 092231f59c345d..a5852843db9261 100644 --- a/cc/CCSchedulerStateMachine.h +++ b/cc/CCSchedulerStateMachine.h @@ -1,161 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCSchedulerStateMachine_h -#define CCSchedulerStateMachine_h - -#include - -#include "base/basictypes.h" - -namespace cc { - -// The CCSchedulerStateMachine decides how to coordinate main thread activites -// like painting/running javascript with rendering and input activities on the -// impl thread. -// -// The state machine tracks internal state but is also influenced by external state. -// Internal state includes things like whether a frame has been requested, while -// external state includes things like the current time being near to the vblank time. -// -// The scheduler seperates "what to do next" from the updating of its internal state to -// make testing cleaner. -class CCSchedulerStateMachine { -public: - CCSchedulerStateMachine(); - - enum CommitState { - COMMIT_STATE_IDLE, - COMMIT_STATE_FRAME_IN_PROGRESS, - COMMIT_STATE_READY_TO_COMMIT, - COMMIT_STATE_WAITING_FOR_FIRST_DRAW, - }; - - enum TextureState { - LAYER_TEXTURE_STATE_UNLOCKED, - LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD, - LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD, - }; - - enum ContextState { - CONTEXT_ACTIVE, - CONTEXT_LOST, - CONTEXT_RECREATING, - }; - - bool commitPending() const - { - return m_commitState != COMMIT_STATE_IDLE; - } - - bool redrawPending() const { return m_needsRedraw; } - - enum Action { - ACTION_NONE, - ACTION_BEGIN_FRAME, - ACTION_COMMIT, - ACTION_DRAW_IF_POSSIBLE, - ACTION_DRAW_FORCED, - ACTION_BEGIN_CONTEXT_RECREATION, - ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD, - }; - Action nextAction() const; - void updateState(Action); - - // Indicates whether the scheduler needs a vsync callback in order to make - // progress. - bool vsyncCallbackNeeded() const; - - // Indicates that the system has entered and left a vsync callback. - // The scheduler will not draw more than once in a given vsync callback. - void didEnterVSync(); - void didLeaveVSync(); - - // Indicates whether the LayerTreeHostImpl is visible. - void setVisible(bool); - - // Indicates that a redraw is required, either due to the impl tree changing - // or the screen being damaged and simply needing redisplay. - void setNeedsRedraw(); - - // As setNeedsRedraw(), but ensures the draw will definitely happen even if - // we are not visible. - void setNeedsForcedRedraw(); - - // Indicates whether ACTION_DRAW_IF_POSSIBLE drew to the screen or not. - void didDrawIfPossibleCompleted(bool success); - - // Indicates that a new commit flow needs to be performed, either to pull - // updates from the main thread to the impl, or to push deltas from the impl - // thread to main. - void setNeedsCommit(); - - // As setNeedsCommit(), but ensures the beginFrame will definitely happen even if - // we are not visible. - void setNeedsForcedCommit(); - - // Call this only in response to receiving an ACTION_BEGIN_FRAME - // from nextState. Indicates that all painting is complete. - void beginFrameComplete(); - - // Call this only in response to receiving an ACTION_BEGIN_FRAME - // from nextState if the client rejects the beginFrame message. - void beginFrameAborted(); - - // Request exclusive access to the textures that back single buffered - // layers on behalf of the main thread. Upon acqusition, - // ACTION_DRAW_IF_POSSIBLE will not draw until the main thread releases the - // textures to the impl thread by committing the layers. - void setMainThreadNeedsLayerTextures(); - - // Indicates whether we can successfully begin a frame at this time. - void setCanBeginFrame(bool can) { m_canBeginFrame = can; } - - // Indicates whether drawing would, at this time, make sense. - // canDraw can be used to supress flashes or checkerboarding - // when such behavior would be undesirable. - void setCanDraw(bool can) { m_canDraw = can; } - - void didLoseContext(); - void didRecreateContext(); - - // Exposed for testing purposes. - void setMaximumNumberOfFailedDrawsBeforeDrawIsForced(int); - - std::string toString(); - -protected: - bool shouldDrawForced() const; - bool drawSuspendedUntilCommit() const; - bool scheduledToDraw() const; - bool shouldDraw() const; - bool shouldAcquireLayerTexturesForMainThread() const; - bool hasDrawnThisFrame() const; - - CommitState m_commitState; - - int m_currentFrameNumber; - int m_lastFrameNumberWhereDrawWasCalled; - int m_consecutiveFailedDraws; - int m_maximumNumberOfFailedDrawsBeforeDrawIsForced; - bool m_needsRedraw; - bool m_needsForcedRedraw; - bool m_needsForcedRedrawAfterNextCommit; - bool m_needsCommit; - bool m_needsForcedCommit; - bool m_mainThreadNeedsLayerTextures; - bool m_insideVSync; - bool m_visible; - bool m_canBeginFrame; - bool m_canDraw; - bool m_drawIfPossibleFailed; - TextureState m_textureState; - ContextState m_contextState; - - DISALLOW_COPY_AND_ASSIGN(CCSchedulerStateMachine); -}; - -} - -#endif // CCSchedulerStateMachine_h +// Temporary forwarding header +#include "cc/scheduler_state_machine.h" diff --git a/cc/CCScopedTexture.h b/cc/CCScopedTexture.h index a5b615c6e7c08a..faa11f5e9dcd02 100644 --- a/cc/CCScopedTexture.h +++ b/cc/CCScopedTexture.h @@ -2,45 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCScopedTexture_h -#define CCScopedTexture_h - -#include "base/basictypes.h" -#include "CCTexture.h" - -#if !ASSERT_DISABLED -#include "base/threading/platform_thread.h" -#endif - -namespace cc { - -class CCScopedTexture : protected CCTexture { -public: - static PassOwnPtr create(CCResourceProvider* resourceProvider) { return adoptPtr(new CCScopedTexture(resourceProvider)); } - virtual ~CCScopedTexture(); - - using CCTexture::id; - using CCTexture::size; - using CCTexture::format; - using CCTexture::bytes; - - bool allocate(int pool, const IntSize&, GC3Denum format, CCResourceProvider::TextureUsageHint); - void free(); - void leak(); - -protected: - explicit CCScopedTexture(CCResourceProvider*); - -private: - CCResourceProvider* m_resourceProvider; - -#if !ASSERT_DISABLED - base::PlatformThreadId m_allocateThreadIdentifier; -#endif - - DISALLOW_COPY_AND_ASSIGN(CCScopedTexture); -}; - -} - -#endif +// Temporary forwarding header +#include "cc/scoped_texture.h" diff --git a/cc/CCScopedThreadProxy.h b/cc/CCScopedThreadProxy.h index 802046dcfa858a..20a6b07dc9f1e5 100644 --- a/cc/CCScopedThreadProxy.h +++ b/cc/CCScopedThreadProxy.h @@ -1,74 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCScopedThreadProxy_h -#define CCScopedThreadProxy_h - -#include "CCThreadTask.h" -#include "base/threading/platform_thread.h" -#include -#include -#include - -namespace cc { - -// This class is a proxy used to post tasks to an target thread from any other thread. The proxy may be shut down at -// any point from the target thread after which no more tasks posted to the proxy will run. In other words, all -// tasks posted via a proxy are scoped to the lifecycle of the proxy. Use this when posting tasks to an object that -// might die with tasks in flight. -// -// The proxy must be created and shut down from the target thread, tasks may be posted from any thread. -// -// Implementation note: Unlike ScopedRunnableMethodFactory in Chromium, pending tasks are not cancelled by actually -// destroying the proxy. Instead each pending task holds a reference to the proxy to avoid maintaining an explicit -// list of outstanding tasks. -class CCScopedThreadProxy : public ThreadSafeRefCounted { -public: - static PassRefPtr create(CCThread* targetThread) - { - ASSERT(base::PlatformThread::CurrentId() == targetThread->threadID()); - return adoptRef(new CCScopedThreadProxy(targetThread)); - } - - ~CCScopedThreadProxy(); - - // Can be called from any thread. Posts a task to the target thread that runs unless - // shutdown() is called before it runs. - void postTask(PassOwnPtr task) - { - ref(); - m_targetThread->postTask(createCCThreadTask(this, &CCScopedThreadProxy::runTaskIfNotShutdown, task)); - } - - void shutdown() - { - ASSERT(base::PlatformThread::CurrentId() == m_targetThread->threadID()); - ASSERT(!m_shutdown); - m_shutdown = true; - } - -private: - explicit CCScopedThreadProxy(CCThread* targetThread); - - void runTaskIfNotShutdown(PassOwnPtr popTask) - { - OwnPtr task = popTask; - // If our shutdown flag is set, it's possible that m_targetThread has already been destroyed so don't - // touch it. - if (m_shutdown) { - deref(); - return; - } - ASSERT(base::PlatformThread::CurrentId() == m_targetThread->threadID()); - task->performTask(); - deref(); - } - - CCThread* m_targetThread; - bool m_shutdown; // Only accessed on the target thread -}; - -} - -#endif +// Temporary forwarding header +#include "cc/scoped_thread_proxy.h" diff --git a/cc/CCScrollbarAnimationController.h b/cc/CCScrollbarAnimationController.h index bb387d7bf1c767..584c8dcf17007f 100644 --- a/cc/CCScrollbarAnimationController.h +++ b/cc/CCScrollbarAnimationController.h @@ -2,63 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCScrollbarAnimationController_h -#define CCScrollbarAnimationController_h - -#include "FloatPoint.h" -#include "IntSize.h" -#include - -namespace cc { - -class CCLayerImpl; -class CCScrollbarLayerImpl; - -// This abstract class represents the compositor-side analogy of ScrollbarAnimator. -// Individual platforms should subclass it to provide specialized implementation. -class CCScrollbarAnimationController { -public: - // Implemented by subclass. - static PassOwnPtr create(CCLayerImpl* scrollLayer); - - virtual ~CCScrollbarAnimationController(); - - virtual bool animate(double monotonicTime); - void didPinchGestureBegin(); - void didPinchGestureUpdate(); - void didPinchGestureEnd(); - void updateScrollOffset(CCLayerImpl* scrollLayer); - - void setHorizontalScrollbarLayer(CCScrollbarLayerImpl* layer) { m_horizontalScrollbarLayer = layer; } - CCScrollbarLayerImpl* horizontalScrollbarLayer() const { return m_horizontalScrollbarLayer; } - - void setVerticalScrollbarLayer(CCScrollbarLayerImpl* layer) { m_verticalScrollbarLayer = layer; } - CCScrollbarLayerImpl* verticalScrollbarLayer() const { return m_verticalScrollbarLayer; } - - FloatPoint currentPos() const { return m_currentPos; } - IntSize totalSize() const { return m_totalSize; } - IntSize maximum() const { return m_maximum; } - - virtual void didPinchGestureBeginAtTime(double monotonicTime) { } - virtual void didPinchGestureUpdateAtTime(double monotonicTime) { } - virtual void didPinchGestureEndAtTime(double monotonicTime) { } - virtual void updateScrollOffsetAtTime(CCLayerImpl* scrollLayer, double monotonicTime); - -protected: - explicit CCScrollbarAnimationController(CCLayerImpl* scrollLayer); - -private: - static IntSize getScrollLayerBounds(const CCLayerImpl*); - - // Beware of dangling pointer. Always update these during tree synchronization. - CCScrollbarLayerImpl* m_horizontalScrollbarLayer; - CCScrollbarLayerImpl* m_verticalScrollbarLayer; - - FloatPoint m_currentPos; - IntSize m_totalSize; - IntSize m_maximum; -}; - -} // namespace cc - -#endif // CCScrollbarAnimationController_h +// Temporary forwarding header +#include "cc/scrollbar_animation_controller.h" diff --git a/cc/CCScrollbarAnimationControllerLinearFade.h b/cc/CCScrollbarAnimationControllerLinearFade.h index 749dca5e3f3493..7ce0e02adaf2e1 100644 --- a/cc/CCScrollbarAnimationControllerLinearFade.h +++ b/cc/CCScrollbarAnimationControllerLinearFade.h @@ -2,38 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCScrollbarAnimationControllerLinearFade_h -#define CCScrollbarAnimationControllerLinearFade_h - -#include "CCScrollbarAnimationController.h" - -namespace cc { - -class CCScrollbarAnimationControllerLinearFade : public CCScrollbarAnimationController { -public: - static PassOwnPtr create(CCLayerImpl* scrollLayer, double fadeoutDelay, double fadeoutLength); - - virtual ~CCScrollbarAnimationControllerLinearFade(); - - virtual bool animate(double monotonicTime) OVERRIDE; - - virtual void didPinchGestureUpdateAtTime(double monotonicTime) OVERRIDE; - virtual void didPinchGestureEndAtTime(double monotonicTime) OVERRIDE; - virtual void updateScrollOffsetAtTime(CCLayerImpl* scrollLayer, double monotonicTime) OVERRIDE; - -protected: - CCScrollbarAnimationControllerLinearFade(CCLayerImpl* scrollLayer, double fadeoutDelay, double fadeoutLength); - -private: - float opacityAtTime(double monotonicTime); - - double m_lastAwakenTime; - bool m_pinchGestureInEffect; - - double m_fadeoutDelay; - double m_fadeoutLength; -}; - -} // namespace cc - -#endif // CCScrollbarAnimationControllerLinearFade_h +// Temporary forwarding header +#include "cc/scrollbar_animation_controller_linear_fade.h" diff --git a/cc/CCScrollbarGeometryFixedThumb.h b/cc/CCScrollbarGeometryFixedThumb.h index fe0db12f263604..e19a6794dbf820 100644 --- a/cc/CCScrollbarGeometryFixedThumb.h +++ b/cc/CCScrollbarGeometryFixedThumb.h @@ -2,38 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCScrollbarGeometryFixedThumb_h -#define CCScrollbarGeometryFixedThumb_h - -#include "CCScrollbarGeometryStub.h" -#include "IntSize.h" - -namespace cc { - -// This scrollbar geometry class behaves exactly like a normal geometry except -// it always returns a fixed thumb length. This allows a page to zoom (changing -// the total size of the scrollable area, changing the thumb length) while not -// requiring the thumb resource to be repainted. -class CCScrollbarGeometryFixedThumb : public CCScrollbarGeometryStub { -public: - static PassOwnPtr create(PassOwnPtr); - virtual ~CCScrollbarGeometryFixedThumb(); - - // Update thumb length from scrollbar - void update(WebKit::WebScrollbar*); - - // WebScrollbarThemeGeometry interface - virtual WebKit::WebScrollbarThemeGeometry* clone() const OVERRIDE; - virtual int thumbLength(WebKit::WebScrollbar*) OVERRIDE; - virtual int thumbPosition(WebKit::WebScrollbar*) OVERRIDE; - virtual void splitTrack(WebKit::WebScrollbar*, const WebKit::WebRect& track, WebKit::WebRect& startTrack, WebKit::WebRect& thumb, WebKit::WebRect& endTrack) OVERRIDE; - -private: - explicit CCScrollbarGeometryFixedThumb(PassOwnPtr); - - IntSize m_thumbSize; -}; - -} - -#endif +// Temporary forwarding header +#include "cc/scrollbar_geometry_fixed_thumb.h" diff --git a/cc/CCScrollbarGeometryStub.h b/cc/CCScrollbarGeometryStub.h index 0d23a4e78bd8d5..3d0d81a5664c01 100644 --- a/cc/CCScrollbarGeometryStub.h +++ b/cc/CCScrollbarGeometryStub.h @@ -2,51 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCScrollbarGeometryStub_h -#define CCScrollbarGeometryStub_h - -#include -#include -#include - -namespace cc { - -// This subclass wraps an existing scrollbar geometry class so that -// another class can derive from it and override specific functions, while -// passing through the remaining ones. -class CCScrollbarGeometryStub : public WebKit::WebScrollbarThemeGeometry { -public: - virtual ~CCScrollbarGeometryStub(); - - // Allow derived classes to update themselves from a scrollbar. - void update(WebKit::WebScrollbar*) { } - - // WebScrollbarThemeGeometry interface - virtual WebKit::WebScrollbarThemeGeometry* clone() const OVERRIDE; - virtual int thumbPosition(WebKit::WebScrollbar*) OVERRIDE; - virtual int thumbLength(WebKit::WebScrollbar*) OVERRIDE; - virtual int trackPosition(WebKit::WebScrollbar*) OVERRIDE; - virtual int trackLength(WebKit::WebScrollbar*) OVERRIDE; - virtual bool hasButtons(WebKit::WebScrollbar*) OVERRIDE; - virtual bool hasThumb(WebKit::WebScrollbar*) OVERRIDE; - virtual WebKit::WebRect trackRect(WebKit::WebScrollbar*) OVERRIDE; - virtual WebKit::WebRect thumbRect(WebKit::WebScrollbar*) OVERRIDE; - virtual int minimumThumbLength(WebKit::WebScrollbar*) OVERRIDE; - virtual int scrollbarThickness(WebKit::WebScrollbar*) OVERRIDE; - virtual WebKit::WebRect backButtonStartRect(WebKit::WebScrollbar*) OVERRIDE; - virtual WebKit::WebRect backButtonEndRect(WebKit::WebScrollbar*) OVERRIDE; - virtual WebKit::WebRect forwardButtonStartRect(WebKit::WebScrollbar*) OVERRIDE; - virtual WebKit::WebRect forwardButtonEndRect(WebKit::WebScrollbar*) OVERRIDE; - virtual WebKit::WebRect constrainTrackRectToTrackPieces(WebKit::WebScrollbar*, const WebKit::WebRect&) OVERRIDE; - virtual void splitTrack(WebKit::WebScrollbar*, const WebKit::WebRect& track, WebKit::WebRect& startTrack, WebKit::WebRect& thumb, WebKit::WebRect& endTrack) OVERRIDE; - -protected: - explicit CCScrollbarGeometryStub(PassOwnPtr); - -private: - OwnPtr m_geometry; -}; - -} - -#endif +// Temporary forwarding header +#include "cc/scrollbar_geometry_stub.h" diff --git a/cc/CCScrollbarLayerImpl.h b/cc/CCScrollbarLayerImpl.h index e7cf58417a7ba1..69fd3c484586a0 100644 --- a/cc/CCScrollbarLayerImpl.h +++ b/cc/CCScrollbarLayerImpl.h @@ -2,111 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCScrollbarLayerImpl_h -#define CCScrollbarLayerImpl_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "CCLayerImpl.h" -#include "CCScrollbarGeometryFixedThumb.h" -#include -#include -#include - -namespace cc { - -class ScrollView; - -class CCScrollbarLayerImpl : public CCLayerImpl { -public: - static scoped_ptr create(int id); - virtual ~CCScrollbarLayerImpl(); - - CCScrollbarGeometryFixedThumb* scrollbarGeometry() const { return m_geometry.get(); } - void setScrollbarGeometry(PassOwnPtr); - void setScrollbarData(WebKit::WebScrollbar*); - - void setBackTrackResourceId(CCResourceProvider::ResourceId id) { m_backTrackResourceId = id; } - void setForeTrackResourceId(CCResourceProvider::ResourceId id) { m_foreTrackResourceId = id; } - void setThumbResourceId(CCResourceProvider::ResourceId id) { m_thumbResourceId = id; } - - float currentPos() const { return m_currentPos; } - void setCurrentPos(float currentPos) { m_currentPos = currentPos; } - - int totalSize() const { return m_totalSize; } - void setTotalSize(int totalSize) { m_totalSize = totalSize; } - - int maximum() const { return m_maximum; } - void setMaximum(int maximum) { m_maximum = maximum; } - - WebKit::WebScrollbar::Orientation orientation() const { return m_orientation; } - - virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; - - virtual void didLoseContext() OVERRIDE; - -protected: - explicit CCScrollbarLayerImpl(int id); - -private: - // nested class only to avoid namespace problem - class CCScrollbar : public WebKit::WebScrollbar { - public: - explicit CCScrollbar(CCScrollbarLayerImpl* owner) : m_owner(owner) { } - - // WebScrollbar implementation - virtual bool isOverlay() const; - virtual int value() const; - virtual WebKit::WebPoint location() const; - virtual WebKit::WebSize size() const; - virtual bool enabled() const; - virtual int maximum() const; - virtual int totalSize() const; - virtual bool isScrollViewScrollbar() const; - virtual bool isScrollableAreaActive() const; - virtual void getTickmarks(WebKit::WebVector& tickmarks) const; - virtual WebScrollbar::ScrollbarControlSize controlSize() const; - virtual WebScrollbar::ScrollbarPart pressedPart() const; - virtual WebScrollbar::ScrollbarPart hoveredPart() const; - virtual WebScrollbar::ScrollbarOverlayStyle scrollbarOverlayStyle() const; - virtual WebScrollbar::Orientation orientation() const; - virtual bool isCustomScrollbar() const; - - private: - CCScrollbarLayerImpl* m_owner; - - }; - - virtual const char* layerTypeAsString() const OVERRIDE; - - CCScrollbar m_scrollbar; - - CCResourceProvider::ResourceId m_backTrackResourceId; - CCResourceProvider::ResourceId m_foreTrackResourceId; - CCResourceProvider::ResourceId m_thumbResourceId; - - OwnPtr m_geometry; - - // Data to implement CCScrollbar - WebKit::WebScrollbar::ScrollbarOverlayStyle m_scrollbarOverlayStyle; - WebKit::WebVector m_tickmarks; - WebKit::WebScrollbar::Orientation m_orientation; - WebKit::WebScrollbar::ScrollbarControlSize m_controlSize; - WebKit::WebScrollbar::ScrollbarPart m_pressedPart; - WebKit::WebScrollbar::ScrollbarPart m_hoveredPart; - - float m_currentPos; - int m_totalSize; - int m_maximum; - - bool m_isScrollableAreaActive; - bool m_isScrollViewScrollbar; - bool m_enabled; - bool m_isCustomScrollbar; - bool m_isOverlayScrollbar; -}; - -} -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/scrollbar_layer_impl.h" diff --git a/cc/CCSettings.h b/cc/CCSettings.h index cde48caa2a453c..af2de4073f3b1c 100644 --- a/cc/CCSettings.h +++ b/cc/CCSettings.h @@ -2,39 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCSettings_h -#define CCSettings_h - -#include "IntSize.h" - -namespace cc { - -// This file is for settings that apply to all compositors. Add settings to -// CCLayerTreeSettings if a ui and renderer compositor might not want the same -// setting. - -class CCSettings { -public: - static bool perTilePaintingEnabled(); - static bool partialSwapEnabled(); - static bool acceleratedAnimationEnabled(); - static bool pageScalePinchZoomEnabled(); - - static bool jankInsteadOfCheckerboard(); - static bool backgroundColorInsteadOfCheckerboard(); - - // These setters should only be used on the main thread before the layer - // renderer is initialized. - static void setPerTilePaintingEnabled(bool); - static void setPartialSwapEnabled(bool); - static void setAcceleratedAnimationEnabled(bool); - static void setPageScalePinchZoomEnabled(bool); - - // These settings are meant to be set only once, and only read thereafter. - // This function is only for resetting settings in tests. - static void reset(); -}; - -} // namespace cc - -#endif // CCSettings_h +// Temporary forwarding header +#include "cc/settings.h" diff --git a/cc/CCSharedQuadState.h b/cc/CCSharedQuadState.h index 0f5e386410d599..c5d50d8b69b0c8 100644 --- a/cc/CCSharedQuadState.h +++ b/cc/CCSharedQuadState.h @@ -2,32 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCSharedQuadState_h -#define CCSharedQuadState_h - -#include "IntRect.h" -#include "base/memory/scoped_ptr.h" -#include - -namespace cc { - -struct CCSharedQuadState { - int id; - - // Transforms from quad's original content space to its target content space. - WebKit::WebTransformationMatrix quadTransform; - // This rect lives in the content space for the quad's originating layer. - IntRect visibleContentRect; - IntRect clippedRectInTarget; - float opacity; - bool opaque; - - static scoped_ptr create(const WebKit::WebTransformationMatrix& quadTransform, const IntRect& visibleContentRect, const IntRect& clippedRectInTarget, float opacity, bool opaque); - CCSharedQuadState(const WebKit::WebTransformationMatrix& quadTransform, const IntRect& visibleContentRect, const IntRect& clippedRectInTarget, float opacity, bool opaque); - - scoped_ptr copy() const; -}; - -} - -#endif +// Temporary forwarding header +#include "cc/shared_quad_state.h" diff --git a/cc/CCSingleThreadProxy.h b/cc/CCSingleThreadProxy.h index 979dbb3907f529..4a6f21e5df59cc 100644 --- a/cc/CCSingleThreadProxy.h +++ b/cc/CCSingleThreadProxy.h @@ -1,134 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCSingleThreadProxy_h -#define CCSingleThreadProxy_h - -#include "CCAnimationEvents.h" -#include "CCLayerTreeHostImpl.h" -#include "CCProxy.h" -#include -#include - -namespace cc { - -class CCLayerTreeHost; - -class CCSingleThreadProxy : public CCProxy, CCLayerTreeHostImplClient { -public: - static scoped_ptr create(CCLayerTreeHost*); - virtual ~CCSingleThreadProxy(); - - // CCProxy implementation - virtual bool compositeAndReadback(void *pixels, const IntRect&) OVERRIDE; - virtual void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double duration) OVERRIDE; - virtual void finishAllRendering() OVERRIDE; - virtual bool isStarted() const OVERRIDE; - virtual bool initializeContext() OVERRIDE; - virtual void setSurfaceReady() OVERRIDE; - virtual void setVisible(bool) OVERRIDE; - virtual bool initializeRenderer() OVERRIDE; - virtual bool recreateContext() OVERRIDE; - virtual void renderingStats(CCRenderingStats*) OVERRIDE; - virtual const RendererCapabilities& rendererCapabilities() const OVERRIDE; - virtual void loseContext() OVERRIDE; - virtual void setNeedsAnimate() OVERRIDE; - virtual void setNeedsCommit() OVERRIDE; - virtual void setNeedsRedraw() OVERRIDE; - virtual bool commitRequested() const OVERRIDE; - virtual void didAddAnimation() OVERRIDE; - virtual void start() OVERRIDE; - virtual void stop() OVERRIDE; - virtual size_t maxPartialTextureUpdates() const OVERRIDE; - virtual void acquireLayerTextures() OVERRIDE { } - virtual void forceSerializeOnSwapBuffers() OVERRIDE; - - // CCLayerTreeHostImplClient implementation - virtual void didLoseContextOnImplThread() OVERRIDE { } - virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE; - virtual void onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds) OVERRIDE { } - virtual void onCanDrawStateChanged(bool canDraw) OVERRIDE { } - virtual void setNeedsRedrawOnImplThread() OVERRIDE; - virtual void setNeedsCommitOnImplThread() OVERRIDE; - virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr, double wallClockTime) OVERRIDE; - virtual void releaseContentsTexturesOnImplThread() OVERRIDE; - - // Called by the legacy path where RenderWidget does the scheduling. - void compositeImmediately(); - -private: - explicit CCSingleThreadProxy(CCLayerTreeHost*); - - bool commitAndComposite(); - void doCommit(PassOwnPtr); - bool doComposite(); - void didSwapFrame(); - - // Accessed on main thread only. - CCLayerTreeHost* m_layerTreeHost; - bool m_contextLost; - - // Holds on to the context between initializeContext() and initializeRenderer() calls. Shouldn't - // be used for anything else. - scoped_ptr m_contextBeforeInitialization; - - // Used on the CCThread, but checked on main thread during initialization/shutdown. - scoped_ptr m_layerTreeHostImpl; - bool m_rendererInitialized; - RendererCapabilities m_RendererCapabilitiesForMainThread; - - bool m_nextFrameIsNewlyCommittedFrame; - - base::TimeDelta m_totalCommitTime; - size_t m_totalCommitCount; -}; - -// For use in the single-threaded case. In debug builds, it pretends that the -// code is running on the impl thread to satisfy assertion checks. -class DebugScopedSetImplThread { -public: - DebugScopedSetImplThread() - { -#if !ASSERT_DISABLED - CCProxy::setCurrentThreadIsImplThread(true); -#endif - } - ~DebugScopedSetImplThread() - { -#if !ASSERT_DISABLED - CCProxy::setCurrentThreadIsImplThread(false); -#endif - } -}; - -// For use in the single-threaded case. In debug builds, it pretends that the -// code is running on the main thread to satisfy assertion checks. -class DebugScopedSetMainThread { -public: - DebugScopedSetMainThread() - { -#if !ASSERT_DISABLED - CCProxy::setCurrentThreadIsImplThread(false); -#endif - } - ~DebugScopedSetMainThread() - { -#if !ASSERT_DISABLED - CCProxy::setCurrentThreadIsImplThread(true); -#endif - } -}; - -// For use in the single-threaded case. In debug builds, it pretends that the -// code is running on the impl thread and that the main thread is blocked to -// satisfy assertion checks -class DebugScopedSetImplThreadAndMainThreadBlocked { -private: - DebugScopedSetImplThread m_implThread; - DebugScopedSetMainThreadBlocked m_mainThreadBlocked; -}; - -} // namespace cc - -#endif +// Temporary forwarding header +#include "cc/single_thread_proxy.h" diff --git a/cc/CCSolidColorDrawQuad.h b/cc/CCSolidColorDrawQuad.h index 6825612e491472..ca00bc944bc0e3 100644 --- a/cc/CCSolidColorDrawQuad.h +++ b/cc/CCSolidColorDrawQuad.h @@ -2,32 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCSolidColorDrawQuad_h -#define CCSolidColorDrawQuad_h - -#include "CCDrawQuad.h" -#include "SkColor.h" -#include "base/memory/scoped_ptr.h" - -namespace cc { - -#pragma pack(push, 4) - -class CCSolidColorDrawQuad : public CCDrawQuad { -public: - static scoped_ptr create(const CCSharedQuadState*, const IntRect&, SkColor); - - SkColor color() const { return m_color; }; - - static const CCSolidColorDrawQuad* materialCast(const CCDrawQuad*); -private: - CCSolidColorDrawQuad(const CCSharedQuadState*, const IntRect&, SkColor); - - SkColor m_color; -}; - -#pragma pack(pop) - -} - -#endif +// Temporary forwarding header +#include "cc/solid_color_draw_quad.h" diff --git a/cc/CCSolidColorLayerImpl.h b/cc/CCSolidColorLayerImpl.h index 72beb25505a6fd..b763bf702cd0a2 100644 --- a/cc/CCSolidColorLayerImpl.h +++ b/cc/CCSolidColorLayerImpl.h @@ -2,33 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCSolidColorLayerImpl_h -#define CCSolidColorLayerImpl_h - -#include "CCLayerImpl.h" -#include - -namespace cc { - -class CCSolidColorLayerImpl : public CCLayerImpl { -public: - static scoped_ptr create(int id) - { - return make_scoped_ptr(new CCSolidColorLayerImpl(id)); - } - virtual ~CCSolidColorLayerImpl(); - - virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; - -protected: - explicit CCSolidColorLayerImpl(int id); - -private: - virtual const char* layerTypeAsString() const OVERRIDE; - - const int m_tileSize; -}; - -} - -#endif // CCSolidColorLayerImpl_h +// Temporary forwarding header +#include "cc/solid_color_layer_impl.h" diff --git a/cc/CCStreamVideoDrawQuad.h b/cc/CCStreamVideoDrawQuad.h index 6a1b6c407dcec8..fb996bfa33f58d 100644 --- a/cc/CCStreamVideoDrawQuad.h +++ b/cc/CCStreamVideoDrawQuad.h @@ -2,34 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCStreamVideoDrawQuad_h -#define CCStreamVideoDrawQuad_h - -#include "CCDrawQuad.h" -#include "base/memory/scoped_ptr.h" -#include - -namespace cc { - -#pragma pack(push, 4) - -class CCStreamVideoDrawQuad : public CCDrawQuad { -public: - static scoped_ptr create(const CCSharedQuadState*, const IntRect&, unsigned textureId, const WebKit::WebTransformationMatrix&); - - unsigned textureId() const { return m_textureId; } - const WebKit::WebTransformationMatrix& matrix() const { return m_matrix; } - - static const CCStreamVideoDrawQuad* materialCast(const CCDrawQuad*); -private: - CCStreamVideoDrawQuad(const CCSharedQuadState*, const IntRect&, unsigned textureId, const WebKit::WebTransformationMatrix&); - - unsigned m_textureId; - WebKit::WebTransformationMatrix m_matrix; -}; - -#pragma pack(pop) - -} - -#endif +// Temporary forwarding header +#include "cc/stream_video_draw_quad.h" diff --git a/cc/CCTexture.h b/cc/CCTexture.h index 8d0def354495aa..4f798d0a1d4098 100644 --- a/cc/CCTexture.h +++ b/cc/CCTexture.h @@ -2,41 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCTexture_h -#define CCTexture_h - -#include "CCResourceProvider.h" -#include "CCTexture.h" -#include "GraphicsContext3D.h" -#include "IntSize.h" - -namespace cc { - -class CCTexture { -public: - CCTexture() : m_id(0) { } - CCTexture(unsigned id, IntSize size, GC3Denum format) - : m_id(id) - , m_size(size) - , m_format(format) { } - - CCResourceProvider::ResourceId id() const { return m_id; } - const IntSize& size() const { return m_size; } - GC3Denum format() const { return m_format; } - - void setId(CCResourceProvider::ResourceId id) { m_id = id; } - void setDimensions(const IntSize&, GC3Denum format); - - size_t bytes() const; - - static size_t memorySizeBytes(const IntSize&, GC3Denum format); - -private: - CCResourceProvider::ResourceId m_id; - IntSize m_size; - GC3Denum m_format; -}; - -} - -#endif +// Temporary forwarding header +#include "cc/texture.h" diff --git a/cc/CCTextureDrawQuad.h b/cc/CCTextureDrawQuad.h index daa600f717f6d4..2ad6600fdf482a 100644 --- a/cc/CCTextureDrawQuad.h +++ b/cc/CCTextureDrawQuad.h @@ -2,40 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCTextureDrawQuad_h -#define CCTextureDrawQuad_h - -#include "CCDrawQuad.h" -#include "FloatRect.h" -#include "base/memory/scoped_ptr.h" - -namespace cc { - -#pragma pack(push, 4) - -class CCTextureDrawQuad : public CCDrawQuad { -public: - static scoped_ptr create(const CCSharedQuadState*, const IntRect&, unsigned resourceId, bool premultipliedAlpha, const FloatRect& uvRect, bool flipped); - FloatRect uvRect() const { return m_uvRect; } - - unsigned resourceId() const { return m_resourceId; } - bool premultipliedAlpha() const { return m_premultipliedAlpha; } - bool flipped() const { return m_flipped; } - - void setNeedsBlending(); - - static const CCTextureDrawQuad* materialCast(const CCDrawQuad*); -private: - CCTextureDrawQuad(const CCSharedQuadState*, const IntRect&, unsigned resourceId, bool premultipliedAlpha, const FloatRect& uvRect, bool flipped); - - unsigned m_resourceId; - bool m_premultipliedAlpha; - FloatRect m_uvRect; - bool m_flipped; -}; - -#pragma pack(pop) - -} - -#endif +// Temporary forwarding header +#include "cc/texture_draw_quad.h" diff --git a/cc/CCTextureLayerImpl.h b/cc/CCTextureLayerImpl.h index ff88ff36db2b8a..8b05959f3a80d7 100644 --- a/cc/CCTextureLayerImpl.h +++ b/cc/CCTextureLayerImpl.h @@ -2,47 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCTextureLayerImpl_h -#define CCTextureLayerImpl_h - -#include "CCLayerImpl.h" - -namespace cc { - -class CCTextureLayerImpl : public CCLayerImpl { -public: - static scoped_ptr create(int id) - { - return make_scoped_ptr(new CCTextureLayerImpl(id)); - } - virtual ~CCTextureLayerImpl(); - - virtual void willDraw(CCResourceProvider*) OVERRIDE; - virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; - virtual void didDraw(CCResourceProvider*) OVERRIDE; - - virtual void didLoseContext() OVERRIDE; - - virtual void dumpLayerProperties(std::string*, int indent) const OVERRIDE; - - unsigned textureId() const { return m_textureId; } - void setTextureId(unsigned id) { m_textureId = id; } - void setPremultipliedAlpha(bool premultipliedAlpha) { m_premultipliedAlpha = premultipliedAlpha; } - void setFlipped(bool flipped) { m_flipped = flipped; } - void setUVRect(const FloatRect& rect) { m_uvRect = rect; } - -private: - explicit CCTextureLayerImpl(int); - - virtual const char* layerTypeAsString() const OVERRIDE; - - unsigned m_textureId; - CCResourceProvider::ResourceId m_externalTextureResource; - bool m_premultipliedAlpha; - bool m_flipped; - FloatRect m_uvRect; -}; - -} - -#endif // CCTextureLayerImpl_h +// Temporary forwarding header +#include "cc/texture_layer_impl.h" diff --git a/cc/CCTextureUpdateController.h b/cc/CCTextureUpdateController.h index 74bb8ca957403e..9c00820357086d 100644 --- a/cc/CCTextureUpdateController.h +++ b/cc/CCTextureUpdateController.h @@ -2,76 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCTextureUpdateController_h -#define CCTextureUpdateController_h - -#include "base/basictypes.h" -#include "base/time.h" -#include "CCTextureUpdateQueue.h" -#include "CCTimer.h" -#include - -namespace cc { - -class TextureUploader; - -class CCTextureUpdateControllerClient { -public: - virtual void readyToFinalizeTextureUpdates() = 0; - -protected: - virtual ~CCTextureUpdateControllerClient() { } -}; - -class CCTextureUpdateController : public CCTimerClient { -public: - static PassOwnPtr create(CCTextureUpdateControllerClient* client, CCThread* thread, PassOwnPtr queue, CCResourceProvider* resourceProvider, TextureUploader* uploader) - { - return adoptPtr(new CCTextureUpdateController(client, thread, queue, resourceProvider, uploader)); - } - static size_t maxPartialTextureUpdates(); - - virtual ~CCTextureUpdateController(); - - // Discard uploads to textures that were evicted on the impl thread. - void discardUploadsToEvictedResources(); - - void performMoreUpdates(base::TimeTicks timeLimit); - void finalize(); - - // CCTimerClient implementation. - virtual void onTimerFired() OVERRIDE; - - // Virtual for testing. - virtual base::TimeTicks now() const; - virtual base::TimeDelta updateMoreTexturesTime() const; - virtual size_t updateMoreTexturesSize() const; - -protected: - CCTextureUpdateController(CCTextureUpdateControllerClient*, CCThread*, PassOwnPtr, CCResourceProvider*, TextureUploader*); - - static size_t maxFullUpdatesPerTick(TextureUploader*); - - size_t maxBlockingUpdates() const; - - // This returns true when there were textures left to update. - bool updateMoreTexturesIfEnoughTimeRemaining(); - void updateMoreTexturesNow(); - - CCTextureUpdateControllerClient* m_client; - OwnPtr m_timer; - OwnPtr m_queue; - bool m_contentsTexturesPurged; - CCResourceProvider* m_resourceProvider; - TextureUploader* m_uploader; - base::TimeTicks m_timeLimit; - size_t m_textureUpdatesPerTick; - bool m_firstUpdateAttempt; - -private: - DISALLOW_COPY_AND_ASSIGN(CCTextureUpdateController); -}; - -} - -#endif // CCTextureUpdateController_h +// Temporary forwarding header +#include "cc/texture_update_controller.h" diff --git a/cc/CCTextureUpdateQueue.h b/cc/CCTextureUpdateQueue.h index 4cf29338bb038a..b3ead959f10a42 100644 --- a/cc/CCTextureUpdateQueue.h +++ b/cc/CCTextureUpdateQueue.h @@ -2,46 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCTextureUpdateQueue_h -#define CCTextureUpdateQueue_h - -#include "base/basictypes.h" -#include "TextureCopier.h" -#include "TextureUploader.h" -#include - -namespace cc { - -class CCTextureUpdateQueue { -public: - CCTextureUpdateQueue(); - virtual ~CCTextureUpdateQueue(); - - void appendFullUpload(TextureUploader::Parameters); - void appendPartialUpload(TextureUploader::Parameters); - void appendCopy(TextureCopier::Parameters); - - void clearUploadsToEvictedResources(); - - TextureUploader::Parameters takeFirstFullUpload(); - TextureUploader::Parameters takeFirstPartialUpload(); - TextureCopier::Parameters takeFirstCopy(); - - size_t fullUploadSize() const { return m_fullEntries.size(); } - size_t partialUploadSize() const { return m_partialEntries.size(); } - size_t copySize() const { return m_copyEntries.size(); } - - bool hasMoreUpdates() const; - -private: - void clearUploadsToEvictedResources(Deque& entryQueue); - Deque m_fullEntries; - Deque m_partialEntries; - Deque m_copyEntries; - - DISALLOW_COPY_AND_ASSIGN(CCTextureUpdateQueue); -}; - -} - -#endif // CCTextureUpdateQueue_h +// Temporary forwarding header +#include "cc/texture_update_queue.h" diff --git a/cc/CCThread.h b/cc/CCThread.h index 1ac494663199a1..aaa3579e596fe5 100644 --- a/cc/CCThread.h +++ b/cc/CCThread.h @@ -1,43 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCThread_h -#define CCThread_h - -#include "base/basictypes.h" -#include "base/threading/platform_thread.h" -#include - -namespace cc { - -// CCThread provides basic infrastructure for messaging with the compositor in a -// platform-neutral way. -class CCThread { -public: - virtual ~CCThread() { } - - class Task { - public: - virtual ~Task() { } - virtual void performTask() = 0; - void* instance() const { return m_instance; } - protected: - Task(void* instance) : m_instance(instance) { } - void* m_instance; - private: - DISALLOW_COPY_AND_ASSIGN(Task); - }; - - // Executes the task on context's thread asynchronously. - virtual void postTask(PassOwnPtr) = 0; - - // Executes the task after the specified delay. - virtual void postDelayedTask(PassOwnPtr, long long delayMs) = 0; - - virtual base::PlatformThreadId threadID() const = 0; -}; - -} - -#endif +// Temporary forwarding header +#include "cc/thread.h" diff --git a/cc/CCThreadProxy.h b/cc/CCThreadProxy.h index a6ea6acbbc22c4..04899c098a6332 100644 --- a/cc/CCThreadProxy.h +++ b/cc/CCThreadProxy.h @@ -1,185 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCThreadProxy_h -#define CCThreadProxy_h - -#include "CCAnimationEvents.h" -#include "CCCompletionEvent.h" -#include "CCLayerTreeHostImpl.h" -#include "CCProxy.h" -#include "CCScheduler.h" -#include "CCTextureUpdateController.h" -#include -#include - -namespace cc { - -class CCInputHandler; -class CCLayerTreeHost; -class CCScheduler; -class CCScopedThreadProxy; -class CCTextureUpdateQueue; -class CCThread; -class CCThreadProxyContextRecreationTimer; - -class CCThreadProxy : public CCProxy, CCLayerTreeHostImplClient, CCSchedulerClient, CCTextureUpdateControllerClient { -public: - static scoped_ptr create(CCLayerTreeHost*); - - virtual ~CCThreadProxy(); - - // CCProxy implementation - virtual bool compositeAndReadback(void *pixels, const IntRect&) OVERRIDE; - virtual void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double duration) OVERRIDE; - virtual void finishAllRendering() OVERRIDE; - virtual bool isStarted() const OVERRIDE; - virtual bool initializeContext() OVERRIDE; - virtual void setSurfaceReady() OVERRIDE; - virtual void setVisible(bool) OVERRIDE; - virtual bool initializeRenderer() OVERRIDE; - virtual bool recreateContext() OVERRIDE; - virtual void renderingStats(CCRenderingStats*) OVERRIDE; - virtual const RendererCapabilities& rendererCapabilities() const OVERRIDE; - virtual void loseContext() OVERRIDE; - virtual void setNeedsAnimate() OVERRIDE; - virtual void setNeedsCommit() OVERRIDE; - virtual void setNeedsRedraw() OVERRIDE; - virtual bool commitRequested() const OVERRIDE; - virtual void didAddAnimation() OVERRIDE { } - virtual void start() OVERRIDE; - virtual void stop() OVERRIDE; - virtual size_t maxPartialTextureUpdates() const OVERRIDE; - virtual void acquireLayerTextures() OVERRIDE; - virtual void forceSerializeOnSwapBuffers() OVERRIDE; - - // CCLayerTreeHostImplClient implementation - virtual void didLoseContextOnImplThread() OVERRIDE; - virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE; - virtual void onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds) OVERRIDE; - virtual void onCanDrawStateChanged(bool canDraw) OVERRIDE; - virtual void setNeedsRedrawOnImplThread() OVERRIDE; - virtual void setNeedsCommitOnImplThread() OVERRIDE; - virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr, double wallClockTime) OVERRIDE; - virtual void releaseContentsTexturesOnImplThread() OVERRIDE; - - // CCSchedulerClient implementation - virtual void scheduledActionBeginFrame() OVERRIDE; - virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible() OVERRIDE; - virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced() OVERRIDE; - virtual void scheduledActionCommit() OVERRIDE; - virtual void scheduledActionBeginContextRecreation() OVERRIDE; - virtual void scheduledActionAcquireLayerTexturesForMainThread() OVERRIDE; - virtual void didAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE; - - // CCTextureUpdateControllerClient implementation - virtual void readyToFinalizeTextureUpdates() OVERRIDE; - -private: - explicit CCThreadProxy(CCLayerTreeHost*); - friend class CCThreadProxyContextRecreationTimer; - - // Set on impl thread, read on main thread. - struct BeginFrameAndCommitState { - BeginFrameAndCommitState(); - ~BeginFrameAndCommitState(); - - double monotonicFrameBeginTime; - scoped_ptr scrollInfo; - WebKit::WebTransformationMatrix implTransform; - CCPrioritizedTextureManager::BackingVector evictedContentsTexturesBackings; - size_t memoryAllocationLimitBytes; - }; - OwnPtr m_pendingBeginFrameRequest; - - // Called on main thread - void beginFrame(); - void didCommitAndDrawFrame(); - void didCompleteSwapBuffers(); - void setAnimationEvents(CCAnimationEventsVector*, double wallClockTime); - void beginContextRecreation(); - void tryToRecreateContext(); - - // Called on impl thread - struct ReadbackRequest { - CCCompletionEvent completion; - bool success; - void* pixels; - IntRect rect; - }; - void forceBeginFrameOnImplThread(CCCompletionEvent*); - void beginFrameCompleteOnImplThread(CCCompletionEvent*, PassOwnPtr); - void beginFrameAbortedOnImplThread(); - void requestReadbackOnImplThread(ReadbackRequest*); - void requestStartPageScaleAnimationOnImplThread(IntSize targetPosition, bool useAnchor, float scale, double durationSec); - void finishAllRenderingOnImplThread(CCCompletionEvent*); - void initializeImplOnImplThread(CCCompletionEvent*, CCInputHandler*); - void setSurfaceReadyOnImplThread(); - void setVisibleOnImplThread(CCCompletionEvent*, bool); - void initializeContextOnImplThread(CCGraphicsContext*); - void initializeRendererOnImplThread(CCCompletionEvent*, bool* initializeSucceeded, RendererCapabilities*); - void layerTreeHostClosedOnImplThread(CCCompletionEvent*); - void setFullRootLayerDamageOnImplThread(); - void acquireLayerTexturesForMainThreadOnImplThread(CCCompletionEvent*); - void recreateContextOnImplThread(CCCompletionEvent*, CCGraphicsContext*, bool* recreateSucceeded, RendererCapabilities*); - void renderingStatsOnImplThread(CCCompletionEvent*, CCRenderingStats*); - CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapInternal(bool forcedDraw); - void forceSerializeOnSwapBuffersOnImplThread(CCCompletionEvent*); - void setNeedsForcedCommitOnImplThread(); - - // Accessed on main thread only. - bool m_animateRequested; // Set only when setNeedsAnimate is called. - bool m_commitRequested; // Set only when setNeedsCommit is called. - bool m_commitRequestSentToImplThread; // Set by setNeedsCommit and setNeedsAnimate. - bool m_forcedCommitRequested; - OwnPtr m_contextRecreationTimer; - CCLayerTreeHost* m_layerTreeHost; - bool m_rendererInitialized; - RendererCapabilities m_RendererCapabilitiesMainThreadCopy; - bool m_started; - bool m_texturesAcquired; - bool m_inCompositeAndReadback; - - scoped_ptr m_layerTreeHostImpl; - - scoped_ptr m_inputHandlerOnImplThread; - - OwnPtr m_schedulerOnImplThread; - - RefPtr m_mainThreadProxy; - - // Holds on to the context we might use for compositing in between initializeContext() - // and initializeRenderer() calls. - scoped_ptr m_contextBeforeInitializationOnImplThread; - - // Set when the main thread is waiting on a scheduledActionBeginFrame to be issued. - CCCompletionEvent* m_beginFrameCompletionEventOnImplThread; - - // Set when the main thread is waiting on a readback. - ReadbackRequest* m_readbackRequestOnImplThread; - - // Set when the main thread is waiting on a commit to complete. - CCCompletionEvent* m_commitCompletionEventOnImplThread; - - // Set when the main thread is waiting on layers to be drawn. - CCCompletionEvent* m_textureAcquisitionCompletionEventOnImplThread; - - OwnPtr m_currentTextureUpdateControllerOnImplThread; - - // Set when we need to reset the contentsTexturesPurged flag after the - // commit. - bool m_resetContentsTexturesPurgedAfterCommitOnImplThread; - - // Set when the next draw should post didCommitAndDrawFrame to the main thread. - bool m_nextFrameIsNewlyCommittedFrameOnImplThread; - - bool m_renderVSyncEnabled; - - base::TimeDelta m_totalCommitTime; - size_t m_totalCommitCount; -}; - -} - -#endif +// Temporary forwarding header +#include "cc/thread_proxy.h" diff --git a/cc/CCThreadTask.h b/cc/CCThreadTask.h index 25c5509d5c6c94..561156b712a7b3 100644 --- a/cc/CCThreadTask.h +++ b/cc/CCThreadTask.h @@ -1,305 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCThreadTask_h -#define CCThreadTask_h -#include "CCThread.h" -#include -#include - -namespace cc { - -template -class CCThreadTask0 : public CCThread::Task { -public: - typedef void (T::*Method)(); - typedef CCThreadTask0 CCThreadTaskImpl; - - static PassOwnPtr create(T* instance, Method method) - { - return adoptPtr(new CCThreadTaskImpl(instance, method)); - } - -private: - CCThreadTask0(T* instance, Method method) - : CCThread::Task(instance) - , m_method(method) - { - } - - virtual void performTask() OVERRIDE - { - (*static_cast(instance()).*m_method)(); - } - -private: - Method m_method; -}; - -template -class CCThreadTask1 : public CCThread::Task { -public: - typedef void (T::*Method)(MP1); - typedef CCThreadTask1 CCThreadTaskImpl; - - static PassOwnPtr create(T* instance, Method method, P1 parameter1) - { - return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1)); - } - -private: - CCThreadTask1(T* instance, Method method, P1 parameter1) - : CCThread::Task(instance) - , m_method(method) - , m_parameter1(parameter1) - { - } - - virtual void performTask() OVERRIDE - { - (*static_cast(instance()).*m_method)(m_parameter1); - } - -private: - Method m_method; - P1 m_parameter1; -}; - -template -class CCThreadTask2 : public CCThread::Task { -public: - typedef void (T::*Method)(MP1, MP2); - typedef CCThreadTask2 CCThreadTaskImpl; - - static PassOwnPtr create(T* instance, Method method, P1 parameter1, P2 parameter2) - { - return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2)); - } - -private: - CCThreadTask2(T* instance, Method method, P1 parameter1, P2 parameter2) - : CCThread::Task(instance) - , m_method(method) - , m_parameter1(parameter1) - , m_parameter2(parameter2) - { - } - - virtual void performTask() OVERRIDE - { - (*static_cast(instance()).*m_method)(m_parameter1, m_parameter2); - } - -private: - Method m_method; - P1 m_parameter1; - P2 m_parameter2; -}; - -template -class CCThreadTask3 : public CCThread::Task { -public: - typedef void (T::*Method)(MP1, MP2, MP3); - typedef CCThreadTask3 CCThreadTaskImpl; - - static PassOwnPtr create(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3) - { - return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2, parameter3)); - } - -private: - CCThreadTask3(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3) - : CCThread::Task(instance) - , m_method(method) - , m_parameter1(parameter1) - , m_parameter2(parameter2) - , m_parameter3(parameter3) - { - } - - virtual void performTask() OVERRIDE - { - (*static_cast(instance()).*m_method)(m_parameter1, m_parameter2, m_parameter3); - } - -private: - Method m_method; - P1 m_parameter1; - P2 m_parameter2; - P3 m_parameter3; -}; - - -template -class CCThreadTask4 : public CCThread::Task { -public: - typedef void (T::*Method)(MP1, MP2, MP3, MP4); - typedef CCThreadTask4 CCThreadTaskImpl; - - static PassOwnPtr create(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3, P4 parameter4) - { - return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2, parameter3, parameter4)); - } - -private: - CCThreadTask4(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3, P4 parameter4) - : CCThread::Task(instance) - , m_method(method) - , m_parameter1(parameter1) - , m_parameter2(parameter2) - , m_parameter3(parameter3) - , m_parameter4(parameter4) - { - } - - virtual void performTask() OVERRIDE - { - (*static_cast(instance()).*m_method)(m_parameter1, m_parameter2, m_parameter3, m_parameter4); - } - -private: - Method m_method; - P1 m_parameter1; - P2 m_parameter2; - P3 m_parameter3; - P4 m_parameter4; -}; - -template -class CCThreadTask5 : public CCThread::Task { -public: - typedef void (T::*Method)(MP1, MP2, MP3, MP4, MP5); - typedef CCThreadTask5 CCThreadTaskImpl; - - static PassOwnPtr create(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3, P4 parameter4, P5 parameter5) - { - return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2, parameter3, parameter4, parameter5)); - } - -private: - CCThreadTask5(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3, P4 parameter4, P5 parameter5) - : CCThread::Task(instance) - , m_method(method) - , m_parameter1(parameter1) - , m_parameter2(parameter2) - , m_parameter3(parameter3) - , m_parameter4(parameter4) - , m_parameter5(parameter5) - { - } - - virtual void performTask() OVERRIDE - { - (*static_cast(instance()).*m_method)(m_parameter1, m_parameter2, m_parameter3, m_parameter4, m_parameter5); - } - -private: - Method m_method; - P1 m_parameter1; - P2 m_parameter2; - P3 m_parameter3; - P4 m_parameter4; - P5 m_parameter5; -}; - -template -PassOwnPtr createCCThreadTask( - T* const callee, - void (T::*method)()); - -template -PassOwnPtr createCCThreadTask( - T* const callee, - void (T::*method)()) -{ - return CCThreadTask0::create( - callee, - method); -} - -template -PassOwnPtr createCCThreadTask( - T* const callee, - void (T::*method)(MP1), - const P1& parameter1) -{ - return CCThreadTask1::create( - callee, - method, - parameter1); -} - -template -PassOwnPtr createCCThreadTask( - T* const callee, - void (T::*method)(MP1, MP2), - const P1& parameter1, - const P2& parameter2) -{ - return CCThreadTask2::create( - callee, - method, - parameter1, - parameter2); -} - -template -PassOwnPtr createCCThreadTask( - T* const callee, - void (T::*method)(MP1, MP2, MP3), - const P1& parameter1, - const P2& parameter2, - const P3& parameter3) -{ - return CCThreadTask3::create( - callee, - method, - parameter1, - parameter2, - parameter3); -} - -template -PassOwnPtr createCCThreadTask( - T* const callee, - void (T::*method)(MP1, MP2, MP3, MP4), - const P1& parameter1, - const P2& parameter2, - const P3& parameter3, - const P4& parameter4) -{ - return CCThreadTask4::create( - callee, - method, - parameter1, - parameter2, - parameter3, - parameter4); - -} - -template -PassOwnPtr createCCThreadTask( - T* const callee, - void (T::*method)(MP1, MP2, MP3, MP4, MP5), - const P1& parameter1, - const P2& parameter2, - const P3& parameter3, - const P4& parameter4, - const P5& parameter5) -{ - return CCThreadTask5::create( - callee, - method, - parameter1, - parameter2, - parameter3, - parameter4, - parameter5); - -} - -} // namespace cc - -#endif // CCThreadTask_h +// Temporary forwarding header +#include "cc/thread_task.h" diff --git a/cc/CCTileDrawQuad.h b/cc/CCTileDrawQuad.h index 21a98cfb864a41..584c439f2d6eb9 100644 --- a/cc/CCTileDrawQuad.h +++ b/cc/CCTileDrawQuad.h @@ -2,53 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCTileDrawQuad_h -#define CCTileDrawQuad_h - -#include "CCDrawQuad.h" -#include "GraphicsTypes3D.h" -#include "IntPoint.h" -#include "IntSize.h" -#include "base/memory/scoped_ptr.h" - -namespace cc { - -#pragma pack(push, 4) - -class CCTileDrawQuad : public CCDrawQuad { -public: - static scoped_ptr create(const CCSharedQuadState*, const IntRect& quadRect, const IntRect& opaqueRect, unsigned resourceId, const IntPoint& textureOffset, const IntSize& textureSize, GC3Dint textureFilter, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA); - - unsigned resourceId() const { return m_resourceId; } - IntPoint textureOffset() const { return m_textureOffset; } - IntSize textureSize() const { return m_textureSize; } - GC3Dint textureFilter() const { return m_textureFilter; } - bool swizzleContents() const { return m_swizzleContents; } - - bool leftEdgeAA() const { return m_leftEdgeAA; } - bool topEdgeAA() const { return m_topEdgeAA; } - bool rightEdgeAA() const { return m_rightEdgeAA; } - bool bottomEdgeAA() const { return m_bottomEdgeAA; } - - bool isAntialiased() const { return leftEdgeAA() || topEdgeAA() || rightEdgeAA() || bottomEdgeAA(); } - - static const CCTileDrawQuad* materialCast(const CCDrawQuad*); -private: - CCTileDrawQuad(const CCSharedQuadState*, const IntRect& quadRect, const IntRect& opaqueRect, unsigned resourceId, const IntPoint& textureOffset, const IntSize& textureSize, GC3Dint textureFilter, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA); - - unsigned m_resourceId; - IntPoint m_textureOffset; - IntSize m_textureSize; - GC3Dint m_textureFilter; - bool m_swizzleContents; - bool m_leftEdgeAA; - bool m_topEdgeAA; - bool m_rightEdgeAA; - bool m_bottomEdgeAA; -}; - -#pragma pack(pop) - -} - -#endif +// Temporary forwarding header +#include "cc/tile_draw_quad.h" diff --git a/cc/CCTiledLayerImpl.h b/cc/CCTiledLayerImpl.h index 2d6803d512fed1..b9726e2580267d 100644 --- a/cc/CCTiledLayerImpl.h +++ b/cc/CCTiledLayerImpl.h @@ -1,62 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCTiledLayerImpl_h -#define CCTiledLayerImpl_h - -#include "CCLayerImpl.h" -#include - -namespace cc { - -class CCLayerTilingData; -class DrawableTile; - -class CCTiledLayerImpl : public CCLayerImpl { -public: - static scoped_ptr create(int id) - { - return make_scoped_ptr(new CCTiledLayerImpl(id)); - } - virtual ~CCTiledLayerImpl(); - - virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; - - virtual CCResourceProvider::ResourceId contentsResourceId() const OVERRIDE; - - virtual void dumpLayerProperties(std::string*, int indent) const OVERRIDE; - - void setSkipsDraw(bool skipsDraw) { m_skipsDraw = skipsDraw; } - void setTilingData(const CCLayerTilingData& tiler); - void pushTileProperties(int, int, CCResourceProvider::ResourceId, const IntRect& opaqueRect); - void pushInvalidTile(int, int); - - void setContentsSwizzled(bool contentsSwizzled) { m_contentsSwizzled = contentsSwizzled; } - bool contentsSwizzled() const { return m_contentsSwizzled; } - - virtual Region visibleContentOpaqueRegion() const OVERRIDE; - virtual void didLoseContext() OVERRIDE; - -protected: - explicit CCTiledLayerImpl(int id); - // Exposed for testing. - bool hasTileAt(int, int) const; - bool hasResourceIdForTileAt(int, int) const; - -private: - - virtual const char* layerTypeAsString() const OVERRIDE; - - DrawableTile* tileAt(int, int) const; - DrawableTile* createTile(int, int); - - bool m_skipsDraw; - bool m_contentsSwizzled; - - OwnPtr m_tiler; -}; - -} - -#endif // CCTiledLayerImpl_h +// Temporary forwarding header +#include "cc/tiled_layer_impl.h" diff --git a/cc/CCTimeSource.h b/cc/CCTimeSource.h index 6f24d35522d5f2..e0fa624fd138c2 100644 --- a/cc/CCTimeSource.h +++ b/cc/CCTimeSource.h @@ -1,40 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCTimeSource_h -#define CCTimeSource_h - -#include "base/time.h" -#include - -namespace cc { - -class CCThread; - -class CCTimeSourceClient { -public: - virtual void onTimerTick() = 0; - -protected: - virtual ~CCTimeSourceClient() { } -}; - -// An generic interface for getting a reliably-ticking timesource of -// a specified rate. -// -// Be sure to call setActive(false) before releasing your reference to the -// timer, or it will keep on ticking! -class CCTimeSource : public RefCounted { -public: - virtual ~CCTimeSource() { } - virtual void setClient(CCTimeSourceClient*) = 0; - virtual void setActive(bool) = 0; - virtual bool active() const = 0; - virtual void setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval) = 0; - virtual base::TimeTicks lastTickTime() = 0; - virtual base::TimeTicks nextTickTime() = 0; -}; - -} -#endif // CCSmoothedTimer_h +// Temporary forwarding header +#include "cc/time_source.h" diff --git a/cc/CCTimer.h b/cc/CCTimer.h index 9424aef99d48eb..5dee85aa215611 100644 --- a/cc/CCTimer.h +++ b/cc/CCTimer.h @@ -1,41 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCTimer_h -#define CCTimer_h - -namespace cc { - -class CCThread; -class CCTimerTask; - -class CCTimerClient { -public: - virtual ~CCTimerClient() { } - - virtual void onTimerFired() = 0; -}; - -class CCTimer { -public: - CCTimer(CCThread*, CCTimerClient*); - ~CCTimer(); - - // If a previous task is pending, it will be replaced with the new one. - void startOneShot(double intervalSeconds); - void stop(); - - bool isActive() const { return m_task; } - -private: - friend class CCTimerTask; - - CCTimerClient* m_client; - CCThread* m_thread; - CCTimerTask* m_task; // weak pointer -}; - -} // namespace cc - -#endif +// Temporary forwarding header +#include "cc/timer.h" diff --git a/cc/CCTimingFunction.h b/cc/CCTimingFunction.h index 993ab872b5bb2a..82dd931e4183f5 100644 --- a/cc/CCTimingFunction.h +++ b/cc/CCTimingFunction.h @@ -2,61 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCTimingFunction_h -#define CCTimingFunction_h - -#include "CCAnimationCurve.h" -#include "UnitBezier.h" - -namespace cc { - -// See http://www.w3.org/TR/css3-transitions/. -class CCTimingFunction : public CCFloatAnimationCurve { -public: - virtual ~CCTimingFunction(); - - // Partial implementation of CCFloatAnimationCurve. - virtual double duration() const OVERRIDE; - -protected: - CCTimingFunction(); -}; - -class CCCubicBezierTimingFunction : public CCTimingFunction { -public: - static scoped_ptr create(double x1, double y1, double x2, double y2); - virtual ~CCCubicBezierTimingFunction(); - - // Partial implementation of CCFloatAnimationCurve. - virtual float getValue(double time) const OVERRIDE; - virtual scoped_ptr clone() const OVERRIDE; - -protected: - CCCubicBezierTimingFunction(double x1, double y1, double x2, double y2); - - UnitBezier m_curve; -}; - -class CCEaseTimingFunction { -public: - static scoped_ptr create(); -}; - -class CCEaseInTimingFunction { -public: - static scoped_ptr create(); -}; - -class CCEaseOutTimingFunction { -public: - static scoped_ptr create(); -}; - -class CCEaseInOutTimingFunction { -public: - static scoped_ptr create(); -}; - -} // namespace cc - -#endif // CCTimingFunction_h +// Temporary forwarding header +#include "cc/timing_function.h" diff --git a/cc/CCVideoLayerImpl.h b/cc/CCVideoLayerImpl.h index b254e8c50b0d3b..f14754999d4da6 100644 --- a/cc/CCVideoLayerImpl.h +++ b/cc/CCVideoLayerImpl.h @@ -2,88 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCVideoLayerImpl_h -#define CCVideoLayerImpl_h - -#include "CCLayerImpl.h" -#include "GraphicsContext3D.h" -#include "IntSize.h" -#include -#include - -namespace WebKit { -class WebVideoFrame; -} - -namespace cc { - -class CCLayerTreeHostImpl; -class CCVideoLayerImpl; - -class CCVideoLayerImpl : public CCLayerImpl - , public WebKit::WebVideoFrameProvider::Client { -public: - static scoped_ptr create(int id, WebKit::WebVideoFrameProvider* provider) - { - return make_scoped_ptr(new CCVideoLayerImpl(id, provider)); - } - virtual ~CCVideoLayerImpl(); - - virtual void willDraw(CCResourceProvider*) OVERRIDE; - virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; - virtual void didDraw(CCResourceProvider*) OVERRIDE; - - virtual void dumpLayerProperties(std::string*, int indent) const OVERRIDE; - - Mutex& providerMutex() { return m_providerMutex; } - - // WebKit::WebVideoFrameProvider::Client implementation. - virtual void stopUsingProvider(); // Callable on any thread. - virtual void didReceiveFrame(); // Callable on impl thread. - virtual void didUpdateMatrix(const float*); // Callable on impl thread. - - virtual void didLoseContext() OVERRIDE; - - void setNeedsRedraw(); - - struct FramePlane { - CCResourceProvider::ResourceId resourceId; - IntSize size; - GC3Denum format; - IntSize visibleSize; - - FramePlane() : resourceId(0) { } - - bool allocateData(CCResourceProvider*); - void freeData(CCResourceProvider*); - }; - -private: - CCVideoLayerImpl(int, WebKit::WebVideoFrameProvider*); - - static IntSize computeVisibleSize(const WebKit::WebVideoFrame&, unsigned plane); - virtual const char* layerTypeAsString() const OVERRIDE; - - void willDrawInternal(CCResourceProvider*); - bool allocatePlaneData(CCResourceProvider*); - bool copyPlaneData(CCResourceProvider*); - void freePlaneData(CCResourceProvider*); - void freeUnusedPlaneData(CCResourceProvider*); - - // Guards the destruction of m_provider and the frame that it provides - Mutex m_providerMutex; - WebKit::WebVideoFrameProvider* m_provider; - - WebKit::WebTransformationMatrix m_streamTextureMatrix; - - WebKit::WebVideoFrame* m_frame; - GC3Denum m_format; - CCResourceProvider::ResourceId m_externalTextureResource; - - // Each index in this array corresponds to a plane in WebKit::WebVideoFrame. - FramePlane m_framePlanes[WebKit::WebVideoFrame::maxPlanes]; -}; - -} - -#endif // CCVideoLayerImpl_h +// Temporary forwarding header +#include "cc/video_layer_impl.h" diff --git a/cc/CCYUVVideoDrawQuad.h b/cc/CCYUVVideoDrawQuad.h index 5d574b7bb9b882..ebdd1e5534b6e7 100644 --- a/cc/CCYUVVideoDrawQuad.h +++ b/cc/CCYUVVideoDrawQuad.h @@ -2,35 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CCYUVVideoDrawQuad_h -#define CCYUVVideoDrawQuad_h - -#include "base/basictypes.h" -#include "base/memory/scoped_ptr.h" -#include "CCDrawQuad.h" -#include "CCVideoLayerImpl.h" - -namespace cc { - -class CCYUVVideoDrawQuad : public CCDrawQuad { -public: - static scoped_ptr create(const CCSharedQuadState*, const IntRect&, const CCVideoLayerImpl::FramePlane& yPlane, const CCVideoLayerImpl::FramePlane& uPlane, const CCVideoLayerImpl::FramePlane& vPlane); - - const CCVideoLayerImpl::FramePlane& yPlane() const { return m_yPlane; } - const CCVideoLayerImpl::FramePlane& uPlane() const { return m_uPlane; } - const CCVideoLayerImpl::FramePlane& vPlane() const { return m_vPlane; } - - static const CCYUVVideoDrawQuad* materialCast(const CCDrawQuad*); -private: - CCYUVVideoDrawQuad(const CCSharedQuadState*, const IntRect&, const CCVideoLayerImpl::FramePlane& yPlane, const CCVideoLayerImpl::FramePlane& uPlane, const CCVideoLayerImpl::FramePlane& vPlane); - - CCVideoLayerImpl::FramePlane m_yPlane; - CCVideoLayerImpl::FramePlane m_uPlane; - CCVideoLayerImpl::FramePlane m_vPlane; - - DISALLOW_COPY_AND_ASSIGN(CCYUVVideoDrawQuad); -}; - -} - -#endif +// Temporary forwarding header +#include "cc/yuv_video_draw_quad.h" diff --git a/cc/CanvasLayerTextureUpdater.h b/cc/CanvasLayerTextureUpdater.h index c8bb9b058a685d..cb14510d1c359d 100644 --- a/cc/CanvasLayerTextureUpdater.h +++ b/cc/CanvasLayerTextureUpdater.h @@ -1,39 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef CanvasLayerTextureUpdater_h -#define CanvasLayerTextureUpdater_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "LayerTextureUpdater.h" - -class SkCanvas; - -namespace cc { - -class LayerPainterChromium; - -// Base class for BitmapCanvasLayerTextureUpdater and -// SkPictureCanvasLayerTextureUpdater that reduces code duplication between -// their respective paintContents implementations. -class CanvasLayerTextureUpdater : public LayerTextureUpdater { -public: - virtual ~CanvasLayerTextureUpdater(); - -protected: - explicit CanvasLayerTextureUpdater(PassOwnPtr); - - void paintContents(SkCanvas*, const IntRect& contentRect, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, CCRenderingStats&); - const IntRect& contentRect() const { return m_contentRect; } - -private: - IntRect m_contentRect; - OwnPtr m_painter; -}; - -} // namespace cc -#endif // USE(ACCELERATED_COMPOSITING) -#endif // CanvasLayerTextureUpdater_h +// Temporary forwarding header +#include "cc/canvas_layer_texture_updater.h" diff --git a/cc/ContentLayerChromium.h b/cc/ContentLayerChromium.h index b8ac4627bf9b7d..687dbd4ef66765 100644 --- a/cc/ContentLayerChromium.h +++ b/cc/ContentLayerChromium.h @@ -1,67 +1,6 @@ -// Copyright 2010 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef ContentLayerChromium_h -#define ContentLayerChromium_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "base/basictypes.h" -#include "LayerPainterChromium.h" -#include "TiledLayerChromium.h" - -class SkCanvas; - -namespace cc { - -class ContentLayerChromiumClient; -class FloatRect; -class IntRect; -class LayerTextureUpdater; - -class ContentLayerPainter : public LayerPainterChromium { -public: - static PassOwnPtr create(ContentLayerChromiumClient*); - - virtual void paint(SkCanvas*, const IntRect& contentRect, FloatRect& opaque) OVERRIDE; - -private: - explicit ContentLayerPainter(ContentLayerChromiumClient*); - - ContentLayerChromiumClient* m_client; - - DISALLOW_COPY_AND_ASSIGN(ContentLayerPainter); -}; - -// A layer that renders its contents into an SkCanvas. -class ContentLayerChromium : public TiledLayerChromium { -public: - static scoped_refptr create(ContentLayerChromiumClient*); - - void clearClient() { m_client = 0; } - - virtual bool drawsContent() const OVERRIDE; - virtual void setTexturePriorities(const CCPriorityCalculator&) OVERRIDE; - virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) OVERRIDE; - virtual bool needMoreUpdates() OVERRIDE; - - virtual void setContentsOpaque(bool) OVERRIDE; - -protected: - explicit ContentLayerChromium(ContentLayerChromiumClient*); - virtual ~ContentLayerChromium(); - -private: - virtual LayerTextureUpdater* textureUpdater() const OVERRIDE; - virtual void createTextureUpdaterIfNeeded() OVERRIDE; - - ContentLayerChromiumClient* m_client; - RefPtr m_textureUpdater; -}; - -} -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/content_layer.h" diff --git a/cc/ContentLayerChromiumClient.h b/cc/ContentLayerChromiumClient.h index 54a92673def9aa..2bfb52a80eaf0b 100644 --- a/cc/ContentLayerChromiumClient.h +++ b/cc/ContentLayerChromiumClient.h @@ -2,23 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef ContentLayerChromiumClient_h -#define ContentLayerChromiumClient_h - -class SkCanvas; - -namespace cc { -class FloatRect; -class IntRect; - -class ContentLayerChromiumClient { -public: - virtual void paintContents(SkCanvas*, const IntRect& clip, FloatRect& opaque) = 0; - -protected: - virtual ~ContentLayerChromiumClient() { } -}; - -} - -#endif // ContentLayerChromiumClient_h +// Temporary forwarding header +#include "cc/content_layer_client.h" diff --git a/cc/DelegatedRendererLayerChromium.h b/cc/DelegatedRendererLayerChromium.h index c7f8d2c4d72be6..1b7e4e243d95ff 100644 --- a/cc/DelegatedRendererLayerChromium.h +++ b/cc/DelegatedRendererLayerChromium.h @@ -2,25 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef DelegatedRendererLayerChromium_h -#define DelegatedRendererLayerChromium_h - -#include "LayerChromium.h" - -namespace cc { - -class DelegatedRendererLayerChromium : public LayerChromium { -public: - static scoped_refptr create(); - - virtual scoped_ptr createCCLayerImpl() OVERRIDE; - -protected: - DelegatedRendererLayerChromium(); - -private: - virtual ~DelegatedRendererLayerChromium(); -}; - -} -#endif +// Temporary forwarding header +#include "cc/delegated_renderer_layer.h" diff --git a/cc/FrameBufferSkPictureCanvasLayerTextureUpdater.h b/cc/FrameBufferSkPictureCanvasLayerTextureUpdater.h index 79093f2f1de063..78c4b3301367d1 100644 --- a/cc/FrameBufferSkPictureCanvasLayerTextureUpdater.h +++ b/cc/FrameBufferSkPictureCanvasLayerTextureUpdater.h @@ -1,52 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef FrameBufferSkPictureCanvasLayerTextureUpdater_h -#define FrameBufferSkPictureCanvasLayerTextureUpdater_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "SkPictureCanvasLayerTextureUpdater.h" - -class GrContext; - -namespace WebKit { -class WebGraphicsContext3D; -class WebSharedGraphicsContext3D; -} - -namespace cc { - -// This class records the contentRect into an SkPicture, then uses accelerated -// drawing to update the texture. The accelerated drawing goes to an -// intermediate framebuffer and then is copied to the destination texture once done. -class FrameBufferSkPictureCanvasLayerTextureUpdater : public SkPictureCanvasLayerTextureUpdater { -public: - class Texture : public LayerTextureUpdater::Texture { - public: - Texture(FrameBufferSkPictureCanvasLayerTextureUpdater*, scoped_ptr); - virtual ~Texture(); - - virtual void updateRect(CCResourceProvider*, const IntRect& sourceRect, const IntSize& destOffset) OVERRIDE; - - private: - FrameBufferSkPictureCanvasLayerTextureUpdater* textureUpdater() { return m_textureUpdater; } - - FrameBufferSkPictureCanvasLayerTextureUpdater* m_textureUpdater; - }; - - static PassRefPtr create(PassOwnPtr); - virtual ~FrameBufferSkPictureCanvasLayerTextureUpdater(); - - virtual PassOwnPtr createTexture(CCPrioritizedTextureManager*) OVERRIDE; - virtual SampledTexelFormat sampledTexelFormat(GC3Denum textureFormat) OVERRIDE; - void updateTextureRect(WebKit::WebGraphicsContext3D*, GrContext*, CCResourceProvider*, CCPrioritizedTexture*, const IntRect& sourceRect, const IntSize& destOffset); - -private: - explicit FrameBufferSkPictureCanvasLayerTextureUpdater(PassOwnPtr); -}; -} // namespace cc -#endif // USE(ACCELERATED_COMPOSITING) -#endif // FrameBufferSkPictureCanvasLayerTextureUpdater_h +// Temporary forwarding header +#include "cc/frame_buffer_skpicture_canvas_layer_texture_updater.h" diff --git a/cc/GeometryBinding.h b/cc/GeometryBinding.h index f0b6e72a6ef561..9af39a8ab7bfde 100644 --- a/cc/GeometryBinding.h +++ b/cc/GeometryBinding.h @@ -1,48 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef GeometryBinding_h -#define GeometryBinding_h - -#include "FloatRect.h" - -#if USE(ACCELERATED_COMPOSITING) - -namespace WebKit { -class WebGraphicsContext3D; -} - -namespace cc { - -class GeometryBinding { -public: - GeometryBinding(WebKit::WebGraphicsContext3D*, const FloatRect& quadVertexRect); - ~GeometryBinding(); - - bool initialized() const { return m_initialized; } - - WebKit::WebGraphicsContext3D* context() const { return m_context; } - unsigned quadVerticesVbo() const { return m_quadVerticesVbo; } - unsigned quadElementsVbo() const { return m_quadElementsVbo; } - - void prepareForDraw(); - - // All layer shaders share the same attribute locations for the vertex - // positions and texture coordinates. This allows switching shaders without - // rebinding attribute arrays. - static int positionAttribLocation() { return 0; } - static int texCoordAttribLocation() { return 1; } - -private: - WebKit::WebGraphicsContext3D* m_context; - unsigned m_quadVerticesVbo; - unsigned m_quadElementsVbo; - bool m_initialized; -}; - -} // namespace cc - -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/geometry_binding.h" diff --git a/cc/HeadsUpDisplayLayerChromium.h b/cc/HeadsUpDisplayLayerChromium.h index cd2627e18f0bea..3d7a1385a6ab92 100644 --- a/cc/HeadsUpDisplayLayerChromium.h +++ b/cc/HeadsUpDisplayLayerChromium.h @@ -2,37 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef HeadsUpDisplayLayerChromium_h -#define HeadsUpDisplayLayerChromium_h - -#include "base/memory/scoped_ptr.h" -#include "CCFontAtlas.h" -#include "IntSize.h" -#include "LayerChromium.h" - -namespace cc { - -class HeadsUpDisplayLayerChromium : public LayerChromium { -public: - static scoped_refptr create(); - - virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) OVERRIDE; - virtual bool drawsContent() const OVERRIDE; - - void setFontAtlas(scoped_ptr); - - virtual scoped_ptr createCCLayerImpl() OVERRIDE; - virtual void pushPropertiesTo(CCLayerImpl*) OVERRIDE; - -protected: - HeadsUpDisplayLayerChromium(); - -private: - virtual ~HeadsUpDisplayLayerChromium(); - - scoped_ptr m_fontAtlas; -}; - -} // namespace cc - -#endif +// Temporary forwarding header +#include "cc/heads_up_display_layer.h" diff --git a/cc/IOSurfaceLayerChromium.h b/cc/IOSurfaceLayerChromium.h index f9c4b5f08d4840..085ec98021bae5 100644 --- a/cc/IOSurfaceLayerChromium.h +++ b/cc/IOSurfaceLayerChromium.h @@ -2,37 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef IOSurfaceLayerChromium_h -#define IOSurfaceLayerChromium_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "LayerChromium.h" - -namespace cc { - -class IOSurfaceLayerChromium : public LayerChromium { -public: - static scoped_refptr create(); - - void setIOSurfaceProperties(uint32_t ioSurfaceId, const IntSize&); - - virtual scoped_ptr createCCLayerImpl() OVERRIDE; - virtual bool drawsContent() const OVERRIDE; - virtual void pushPropertiesTo(CCLayerImpl*) OVERRIDE; - -protected: - IOSurfaceLayerChromium(); - -private: - virtual ~IOSurfaceLayerChromium(); - - uint32_t m_ioSurfaceId; - IntSize m_ioSurfaceSize; -}; - -} -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/io_surface_layer.h" diff --git a/cc/ImageLayerChromium.h b/cc/ImageLayerChromium.h index 12ac39716b8446..7b7e0c79c11bc2 100644 --- a/cc/ImageLayerChromium.h +++ b/cc/ImageLayerChromium.h @@ -1,48 +1,6 @@ -// Copyright 2010 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef ImageLayerChromium_h -#define ImageLayerChromium_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "ContentLayerChromium.h" -#include "SkBitmap.h" - -namespace cc { - -class ImageLayerTextureUpdater; - -// A Layer that contains only an Image element. -class ImageLayerChromium : public TiledLayerChromium { -public: - static scoped_refptr create(); - - virtual bool drawsContent() const OVERRIDE; - virtual void setTexturePriorities(const CCPriorityCalculator&) OVERRIDE; - virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) OVERRIDE; - virtual bool needsContentsScale() const OVERRIDE; - - void setBitmap(const SkBitmap& image); - -private: - ImageLayerChromium(); - virtual ~ImageLayerChromium(); - - void setTilingOption(TilingOption); - - virtual LayerTextureUpdater* textureUpdater() const OVERRIDE; - virtual void createTextureUpdaterIfNeeded() OVERRIDE; - virtual IntSize contentBounds() const OVERRIDE; - - SkBitmap m_bitmap; - - RefPtr m_textureUpdater; -}; - -} -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/image_layer.h" diff --git a/cc/LayerChromium.h b/cc/LayerChromium.h index a87caa0ca370de..ea56428ac7f524 100644 --- a/cc/LayerChromium.h +++ b/cc/LayerChromium.h @@ -1,390 +1,6 @@ -// Copyright 2010 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef LayerChromium_h -#define LayerChromium_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "base/memory/ref_counted.h" -#include "CCLayerAnimationController.h" -#include "CCOcclusionTracker.h" -#include "FloatPoint.h" -#include "Region.h" -#include "RenderSurfaceChromium.h" -#include "SkColor.h" -#include -#include -#include -#include - -namespace WebKit { -class WebAnimationDelegate; -class WebLayerScrollClient; -} - -namespace cc { - -class CCActiveAnimation; -struct CCAnimationEvent; -class CCLayerAnimationDelegate; -class CCLayerImpl; -class CCLayerTreeHost; -class CCPriorityCalculator; -class CCTextureUpdateQueue; -class ScrollbarLayerChromium; -struct CCAnimationEvent; -struct CCRenderingStats; - -// Base class for composited layers. Special layer types are derived from -// this class. -class LayerChromium : public base::RefCounted, public CCLayerAnimationControllerClient { -public: - typedef std::vector > LayerList; - - static scoped_refptr create(); - - // CCLayerAnimationControllerClient implementation - virtual int id() const OVERRIDE; - virtual void setOpacityFromAnimation(float) OVERRIDE; - virtual float opacity() const OVERRIDE; - virtual void setTransformFromAnimation(const WebKit::WebTransformationMatrix&) OVERRIDE; - // A layer's transform operates layer space. That is, entirely in logical, - // non-page-scaled pixels (that is, they have page zoom baked in, but not page scale). - // The root layer is a special case -- it operates in physical pixels. - virtual const WebKit::WebTransformationMatrix& transform() const OVERRIDE; - - LayerChromium* rootLayer(); - LayerChromium* parent() const; - void addChild(scoped_refptr); - void insertChild(scoped_refptr, size_t index); - void replaceChild(LayerChromium* reference, scoped_refptr newLayer); - void removeFromParent(); - void removeAllChildren(); - void setChildren(const LayerList&); - - const LayerList& children() const { return m_children; } - - void setAnchorPoint(const FloatPoint&); - FloatPoint anchorPoint() const { return m_anchorPoint; } - - void setAnchorPointZ(float); - float anchorPointZ() const { return m_anchorPointZ; } - - void setBackgroundColor(SkColor); - SkColor backgroundColor() const { return m_backgroundColor; } - - // A layer's bounds are in logical, non-page-scaled pixels (however, the - // root layer's bounds are in physical pixels). - void setBounds(const IntSize&); - const IntSize& bounds() const { return m_bounds; } - virtual IntSize contentBounds() const; - - void setMasksToBounds(bool); - bool masksToBounds() const { return m_masksToBounds; } - - void setMaskLayer(LayerChromium*); - LayerChromium* maskLayer() const { return m_maskLayer.get(); } - - virtual void setNeedsDisplayRect(const FloatRect& dirtyRect); - void setNeedsDisplay() { setNeedsDisplayRect(FloatRect(FloatPoint(), bounds())); } - virtual bool needsDisplay() const; - - void setOpacity(float); - bool opacityIsAnimating() const; - - void setFilters(const WebKit::WebFilterOperations&); - const WebKit::WebFilterOperations& filters() const { return m_filters; } - - // Background filters are filters applied to what is behind this layer, when they are viewed through non-opaque - // regions in this layer. They are used through the WebLayer interface, and are not exposed to HTML. - void setBackgroundFilters(const WebKit::WebFilterOperations&); - const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; } - - virtual void setContentsOpaque(bool); - bool contentsOpaque() const { return m_contentsOpaque; } - - void setPosition(const FloatPoint&); - FloatPoint position() const { return m_position; } - - void setIsContainerForFixedPositionLayers(bool); - bool isContainerForFixedPositionLayers() const { return m_isContainerForFixedPositionLayers; } - - void setFixedToContainerLayer(bool); - bool fixedToContainerLayer() const { return m_fixedToContainerLayer; } - - void setSublayerTransform(const WebKit::WebTransformationMatrix&); - const WebKit::WebTransformationMatrix& sublayerTransform() const { return m_sublayerTransform; } - - void setTransform(const WebKit::WebTransformationMatrix&); - bool transformIsAnimating() const; - - const IntRect& visibleContentRect() const { return m_visibleContentRect; } - void setVisibleContentRect(const IntRect& visibleContentRect) { m_visibleContentRect = visibleContentRect; } - - void setScrollPosition(const IntPoint&); - const IntPoint& scrollPosition() const { return m_scrollPosition; } - - void setMaxScrollPosition(const IntSize&); - const IntSize& maxScrollPosition() const { return m_maxScrollPosition; } - - void setScrollable(bool); - bool scrollable() const { return m_scrollable; } - - void setShouldScrollOnMainThread(bool); - bool shouldScrollOnMainThread() const { return m_shouldScrollOnMainThread; } - - void setHaveWheelEventHandlers(bool); - bool haveWheelEventHandlers() const { return m_haveWheelEventHandlers; } - - void setNonFastScrollableRegion(const Region&); - void setNonFastScrollableRegionChanged() { m_nonFastScrollableRegionChanged = true; } - const Region& nonFastScrollableRegion() const { return m_nonFastScrollableRegion; } - - void setLayerScrollClient(WebKit::WebLayerScrollClient* layerScrollClient) { m_layerScrollClient = layerScrollClient; } - - void setDrawCheckerboardForMissingTiles(bool); - bool drawCheckerboardForMissingTiles() const { return m_drawCheckerboardForMissingTiles; } - - bool forceRenderSurface() const { return m_forceRenderSurface; } - void setForceRenderSurface(bool); - - IntSize scrollDelta() const { return IntSize(); } - - void setImplTransform(const WebKit::WebTransformationMatrix&); - const WebKit::WebTransformationMatrix& implTransform() const { return m_implTransform; } - - void setDoubleSided(bool); - bool doubleSided() const { return m_doubleSided; } - - void setPreserves3D(bool preserve3D) { m_preserves3D = preserve3D; } - bool preserves3D() const { return m_preserves3D; } - - void setUseParentBackfaceVisibility(bool useParentBackfaceVisibility) { m_useParentBackfaceVisibility = useParentBackfaceVisibility; } - bool useParentBackfaceVisibility() const { return m_useParentBackfaceVisibility; } - - virtual void setUseLCDText(bool); - bool useLCDText() const { return m_useLCDText; } - - virtual void setLayerTreeHost(CCLayerTreeHost*); - - bool hasContributingDelegatedRenderPasses() const { return false; } - - void setIsDrawable(bool); - - void setReplicaLayer(LayerChromium*); - LayerChromium* replicaLayer() const { return m_replicaLayer.get(); } - - bool hasMask() const { return m_maskLayer; } - bool hasReplica() const { return m_replicaLayer; } - bool replicaHasMask() const { return m_replicaLayer && (m_maskLayer || m_replicaLayer->m_maskLayer); } - - // These methods typically need to be overwritten by derived classes. - virtual bool drawsContent() const; - virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) { } - virtual bool needMoreUpdates(); - virtual void setIsMask(bool) { } - virtual void bindContentsTexture() { } - virtual bool needsContentsScale() const; - - void setDebugBorderColor(SkColor); - void setDebugBorderWidth(float); - void setDebugName(const std::string&); - - virtual void pushPropertiesTo(CCLayerImpl*); - - void clearRenderSurface() { m_renderSurface.reset(); } - RenderSurfaceChromium* renderSurface() const { return m_renderSurface.get(); } - void createRenderSurface(); - - float drawOpacity() const { return m_drawOpacity; } - void setDrawOpacity(float opacity) { m_drawOpacity = opacity; } - - bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; } - void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; } - - LayerChromium* renderTarget() const { ASSERT(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; } - void setRenderTarget(LayerChromium* target) { m_renderTarget = target; } - - bool drawTransformIsAnimating() const { return m_drawTransformIsAnimating; } - void setDrawTransformIsAnimating(bool animating) { m_drawTransformIsAnimating = animating; } - bool screenSpaceTransformIsAnimating() const { return m_screenSpaceTransformIsAnimating; } - void setScreenSpaceTransformIsAnimating(bool animating) { m_screenSpaceTransformIsAnimating = animating; } - - // This moves from layer space, with origin in the center to target space with origin in the top left. - // That is, it converts from logical, non-page-scaled, to target pixels (and if the target is the - // root render surface, then this converts to physical pixels). - const WebKit::WebTransformationMatrix& drawTransform() const { return m_drawTransform; } - void setDrawTransform(const WebKit::WebTransformationMatrix& matrix) { m_drawTransform = matrix; } - // This moves from content space, with origin the top left to screen space with origin in the top left. - // It converts logical, non-page-scaled pixels to physical pixels. - const WebKit::WebTransformationMatrix& screenSpaceTransform() const { return m_screenSpaceTransform; } - void setScreenSpaceTransform(const WebKit::WebTransformationMatrix& matrix) { m_screenSpaceTransform = matrix; } - const IntRect& drawableContentRect() const { return m_drawableContentRect; } - void setDrawableContentRect(const IntRect& rect) { m_drawableContentRect = rect; } - // The contentsScale converts from logical, non-page-scaled pixels to target pixels. - // The contentsScale is 1 for the root layer as it is already in physical pixels. - float contentsScale() const { return m_contentsScale; } - void setContentsScale(float); - - // When true, the layer's contents are not scaled by the current page scale factor. - // setBoundsContainPageScale recursively sets the value on all child layers. - void setBoundsContainPageScale(bool); - bool boundsContainPageScale() const { return m_boundsContainPageScale; } - - // Returns true if any of the layer's descendants has content to draw. - bool descendantDrawsContent(); - - CCLayerTreeHost* layerTreeHost() const { return m_layerTreeHost; } - - // Set the priority of all desired textures in this layer. - virtual void setTexturePriorities(const CCPriorityCalculator&) { } - - bool addAnimation(scoped_ptr); - void pauseAnimation(int animationId, double timeOffset); - void removeAnimation(int animationId); - - void suspendAnimations(double monotonicTime); - void resumeAnimations(double monotonicTime); - - CCLayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); } - void setLayerAnimationController(scoped_ptr); - scoped_ptr releaseLayerAnimationController(); - - void setLayerAnimationDelegate(WebKit::WebAnimationDelegate* layerAnimationDelegate) { m_layerAnimationDelegate = layerAnimationDelegate; } - - bool hasActiveAnimation() const; - - virtual void notifyAnimationStarted(const CCAnimationEvent&, double wallClockTime); - virtual void notifyAnimationFinished(double wallClockTime); - - virtual Region visibleContentOpaqueRegion() const; - - virtual ScrollbarLayerChromium* toScrollbarLayerChromium(); - -protected: - friend class CCLayerImpl; - friend class TreeSynchronizer; - virtual ~LayerChromium(); - - LayerChromium(); - - void setNeedsCommit(); - - IntRect layerRectToContentRect(const WebKit::WebRect& layerRect); - - // This flag is set when layer need repainting/updating. - bool m_needsDisplay; - - // Tracks whether this layer may have changed stacking order with its siblings. - bool m_stackingOrderChanged; - - // The update rect is the region of the compositor resource that was actually updated by the compositor. - // For layers that may do updating outside the compositor's control (i.e. plugin layers), this information - // is not available and the update rect will remain empty. - // Note this rect is in layer space (not content space). - FloatRect m_updateRect; - - scoped_refptr m_maskLayer; - - // Constructs a CCLayerImpl of the correct runtime type for this LayerChromium type. - virtual scoped_ptr createCCLayerImpl(); - int m_layerId; - -private: - friend class base::RefCounted; - - void setParent(LayerChromium*); - bool hasAncestor(LayerChromium*) const; - bool descendantIsFixedToContainerLayer() const; - - size_t numChildren() const { return m_children.size(); } - - // Returns the index of the child or -1 if not found. - int indexOfChild(const LayerChromium*); - - // This should only be called from removeFromParent. - void removeChild(LayerChromium*); - - LayerList m_children; - LayerChromium* m_parent; - - // LayerChromium instances have a weak pointer to their CCLayerTreeHost. - // This pointer value is nil when a LayerChromium is not in a tree and is - // updated via setLayerTreeHost() if a layer moves between trees. - CCLayerTreeHost* m_layerTreeHost; - - scoped_ptr m_layerAnimationController; - - // Layer properties. - IntSize m_bounds; - - // Uses layer's content space. - IntRect m_visibleContentRect; - - IntPoint m_scrollPosition; - IntSize m_maxScrollPosition; - bool m_scrollable; - bool m_shouldScrollOnMainThread; - bool m_haveWheelEventHandlers; - Region m_nonFastScrollableRegion; - bool m_nonFastScrollableRegionChanged; - FloatPoint m_position; - FloatPoint m_anchorPoint; - SkColor m_backgroundColor; - SkColor m_debugBorderColor; - float m_debugBorderWidth; - std::string m_debugName; - float m_opacity; - WebKit::WebFilterOperations m_filters; - WebKit::WebFilterOperations m_backgroundFilters; - float m_anchorPointZ; - bool m_isContainerForFixedPositionLayers; - bool m_fixedToContainerLayer; - bool m_isDrawable; - bool m_masksToBounds; - bool m_contentsOpaque; - bool m_doubleSided; - bool m_useLCDText; - bool m_preserves3D; - bool m_useParentBackfaceVisibility; - bool m_drawCheckerboardForMissingTiles; - bool m_forceRenderSurface; - - WebKit::WebTransformationMatrix m_transform; - WebKit::WebTransformationMatrix m_sublayerTransform; - - // Replica layer used for reflections. - scoped_refptr m_replicaLayer; - - // Transient properties. - scoped_ptr m_renderSurface; - float m_drawOpacity; - bool m_drawOpacityIsAnimating; - - LayerChromium* m_renderTarget; - - WebKit::WebTransformationMatrix m_drawTransform; - WebKit::WebTransformationMatrix m_screenSpaceTransform; - bool m_drawTransformIsAnimating; - bool m_screenSpaceTransformIsAnimating; - - // Uses target surface space. - IntRect m_drawableContentRect; - float m_contentsScale; - bool m_boundsContainPageScale; - - WebKit::WebTransformationMatrix m_implTransform; - - WebKit::WebAnimationDelegate* m_layerAnimationDelegate; - WebKit::WebLayerScrollClient* m_layerScrollClient; -}; - -void sortLayers(std::vector >::iterator, std::vector >::iterator, void*); - -} -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/layer.h" diff --git a/cc/LayerPainterChromium.h b/cc/LayerPainterChromium.h index d552382d149af1..67987d9b01a593 100644 --- a/cc/LayerPainterChromium.h +++ b/cc/LayerPainterChromium.h @@ -1,26 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef LayerPainterChromium_h -#define LayerPainterChromium_h - -#if USE(ACCELERATED_COMPOSITING) - -class SkCanvas; - -namespace cc { - -class FloatRect; -class IntRect; - -class LayerPainterChromium { -public: - virtual ~LayerPainterChromium() { } - virtual void paint(SkCanvas*, const IntRect& contentRect, FloatRect& opaque) = 0; -}; - -} // namespace cc -#endif // USE(ACCELERATED_COMPOSITING) -#endif // LayerPainterChromium_h +// Temporary forwarding header +#include "cc/layer_painter.h" diff --git a/cc/LayerTextureSubImage.h b/cc/LayerTextureSubImage.h index 2c6cc14744430b..3efbf6a807cbcd 100644 --- a/cc/LayerTextureSubImage.h +++ b/cc/LayerTextureSubImage.h @@ -1,46 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef LayerTextureSubImage_h -#define LayerTextureSubImage_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "GraphicsTypes3D.h" -#include "IntRect.h" -#include "IntSize.h" -#include - -namespace WebKit { -class WebGraphicsContext3D; -} - -namespace cc { - -class LayerTextureSubImage { -public: - explicit LayerTextureSubImage(bool useMapSubForUpload); - ~LayerTextureSubImage(); - - void upload(const uint8_t* image, const IntRect& imageRect, - const IntRect& sourceRect, const IntSize& destOffset, - GC3Denum format, WebKit::WebGraphicsContext3D*); - -private: - void uploadWithTexSubImage(const uint8_t* image, const IntRect& imageRect, - const IntRect& sourceRect, const IntSize& destOffset, - GC3Denum format, WebKit::WebGraphicsContext3D*); - void uploadWithMapTexSubImage(const uint8_t* image, const IntRect& imageRect, - const IntRect& sourceRect, const IntSize& destOffset, - GC3Denum format, WebKit::WebGraphicsContext3D*); - - bool m_useMapTexSubImage; - size_t m_subImageSize; - OwnArrayPtr m_subImage; -}; - -} // namespace cc -#endif // USE(ACCELERATED_COMPOSITING) -#endif // LayerTextureSubImage_h +// Temporary forwarding header +#include "cc/layer_texture_sub_image.h" diff --git a/cc/LayerTextureUpdater.h b/cc/LayerTextureUpdater.h index 89fc520475a64d..74bd00ef511494 100644 --- a/cc/LayerTextureUpdater.h +++ b/cc/LayerTextureUpdater.h @@ -1,69 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef LayerTextureUpdater_h -#define LayerTextureUpdater_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "CCPrioritizedTexture.h" -#include "GraphicsTypes3D.h" -#include - -namespace cc { - -class IntRect; -class IntSize; -class TextureManager; -struct CCRenderingStats; - -class LayerTextureUpdater : public RefCounted { -public: - // Allows texture uploaders to store per-tile resources. - class Texture { - public: - virtual ~Texture(); - - CCPrioritizedTexture* texture() { return m_texture.get(); } - void swapTextureWith(scoped_ptr& texture) { m_texture.swap(texture); } - virtual void prepareRect(const IntRect& /* sourceRect */, CCRenderingStats&) { } - virtual void updateRect(CCResourceProvider*, const IntRect& sourceRect, const IntSize& destOffset) = 0; - virtual bool backingResourceWasEvicted() const; - protected: - explicit Texture(scoped_ptr texture); - - private: - scoped_ptr m_texture; - }; - - LayerTextureUpdater() - { - turnOffVerifier(); // In the component build we don't have WTF threading initialized in this DLL so the thread verifier explodes. - } - - virtual ~LayerTextureUpdater() { } - - enum SampledTexelFormat { - SampledTexelFormatRGBA, - SampledTexelFormatBGRA, - SampledTexelFormatInvalid, - }; - virtual PassOwnPtr createTexture(CCPrioritizedTextureManager*) = 0; - // Returns the format of the texel uploaded by this interface. - // This format should not be confused by texture internal format. - // This format specifies the component order in the sampled texel. - // If the format is TexelFormatBGRA, vec4.x is blue and vec4.z is red. - virtual SampledTexelFormat sampledTexelFormat(GC3Denum textureFormat) = 0; - // The |resultingOpaqueRect| gives back a region of the layer that was painted opaque. If the layer is marked opaque in the updater, - // then this region should be ignored in preference for the entire layer's area. - virtual void prepareToUpdate(const IntRect& contentRect, const IntSize& tileSize, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, CCRenderingStats&) { } - - // Set true by the layer when it is known that the entire output is going to be opaque. - virtual void setOpaque(bool) { } -}; - -} // namespace cc -#endif // USE(ACCELERATED_COMPOSITING) -#endif // LayerTextureUpdater_h +// Temporary forwarding header +#include "cc/layer_texture_updater.h" diff --git a/cc/PlatformColor.h b/cc/PlatformColor.h index 61ffd31bd49c71..24690aa6a66732 100644 --- a/cc/PlatformColor.h +++ b/cc/PlatformColor.h @@ -1,58 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef PlatformColor_h -#define PlatformColor_h - -#include "Extensions3D.h" -#include "GraphicsContext3D.h" -#include "SkTypes.h" -#include - -namespace cc { - -class PlatformColor { -public: - static GraphicsContext3D::SourceDataFormat format() - { - return SK_B32_SHIFT ? GraphicsContext3D::SourceFormatRGBA8 : GraphicsContext3D::SourceFormatBGRA8; - } - - // Returns the most efficient texture format for this platform. - static GC3Denum bestTextureFormat(WebKit::WebGraphicsContext3D* context, bool supportsBGRA8888) - { - GC3Denum textureFormat = GraphicsContext3D::RGBA; - switch (format()) { - case GraphicsContext3D::SourceFormatRGBA8: - break; - case GraphicsContext3D::SourceFormatBGRA8: - if (supportsBGRA8888) - textureFormat = Extensions3D::BGRA_EXT; - break; - default: - ASSERT_NOT_REACHED(); - break; - } - return textureFormat; - } - - // Return true if the given texture format has the same component order - // as the color on this platform. - static bool sameComponentOrder(GC3Denum textureFormat) - { - switch (format()) { - case GraphicsContext3D::SourceFormatRGBA8: - return textureFormat == GraphicsContext3D::RGBA; - case GraphicsContext3D::SourceFormatBGRA8: - return textureFormat == Extensions3D::BGRA_EXT; - default: - ASSERT_NOT_REACHED(); - return false; - } - } -}; - -} // namespace cc - -#endif +// Temporary forwarding header +#include "cc/platform_color.h" diff --git a/cc/ProgramBinding.h b/cc/ProgramBinding.h index 9f0d0673c2a384..f44ed1831c9056 100644 --- a/cc/ProgramBinding.h +++ b/cc/ProgramBinding.h @@ -1,84 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef ProgramBinding_h -#define ProgramBinding_h - -#if USE(ACCELERATED_COMPOSITING) - -#include - -namespace WebKit { -class WebGraphicsContext3D; -} - -namespace cc { - -class ProgramBindingBase { -public: - ProgramBindingBase(); - ~ProgramBindingBase(); - - void init(WebKit::WebGraphicsContext3D*, const std::string& vertexShader, const std::string& fragmentShader); - void link(WebKit::WebGraphicsContext3D*); - void cleanup(WebKit::WebGraphicsContext3D*); - - unsigned program() const { ASSERT(m_initialized); return m_program; } - bool initialized() const { return m_initialized; } - -protected: - - unsigned loadShader(WebKit::WebGraphicsContext3D*, unsigned type, const std::string& shaderSource); - unsigned createShaderProgram(WebKit::WebGraphicsContext3D*, unsigned vertexShader, unsigned fragmentShader); - void cleanupShaders(WebKit::WebGraphicsContext3D*); - - unsigned m_program; - unsigned m_vertexShaderId; - unsigned m_fragmentShaderId; - bool m_initialized; -}; - -template -class ProgramBinding : public ProgramBindingBase { -public: - explicit ProgramBinding(WebKit::WebGraphicsContext3D* context) - { - ProgramBindingBase::init(context, m_vertexShader.getShaderString(), m_fragmentShader.getShaderString()); - } - - void initialize(WebKit::WebGraphicsContext3D* context, bool usingBindUniform) - { - ASSERT(context); - ASSERT(m_program); - ASSERT(!m_initialized); - - // Need to bind uniforms before linking - if (!usingBindUniform) - link(context); - - int baseUniformIndex = 0; - m_vertexShader.init(context, m_program, usingBindUniform, &baseUniformIndex); - m_fragmentShader.init(context, m_program, usingBindUniform, &baseUniformIndex); - - // Link after binding uniforms - if (usingBindUniform) - link(context); - - m_initialized = true; - } - - const VertexShader& vertexShader() const { return m_vertexShader; } - const FragmentShader& fragmentShader() const { return m_fragmentShader; } - -private: - - VertexShader m_vertexShader; - FragmentShader m_fragmentShader; -}; - -} // namespace cc - -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/program_binding.h" diff --git a/cc/RateLimiter.h b/cc/RateLimiter.h index 7b48d742b7df08..90c7f54a8d8ae8 100644 --- a/cc/RateLimiter.h +++ b/cc/RateLimiter.h @@ -1,53 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef RateLimiter_h -#define RateLimiter_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "base/memory/ref_counted.h" - -namespace WebKit { -class WebGraphicsContext3D; -} - -namespace cc { - -class RateLimiterClient { -public: - virtual void rateLimit() = 0; -}; - -// A RateLimiter can be used to make sure that a single context does not dominate all execution time. -// To use, construct a RateLimiter class around the context and call start() whenever calls are made on the -// context outside of normal flow control. RateLimiter will block if the context is too far ahead of the -// compositor. -class RateLimiter : public base::RefCounted { -public: - static scoped_refptr create(WebKit::WebGraphicsContext3D*, RateLimiterClient*); - - void start(); - - // Context and client will not be accessed after stop(). - void stop(); - -private: - RateLimiter(WebKit::WebGraphicsContext3D*, RateLimiterClient*); - ~RateLimiter(); - friend class base::RefCounted; - - class Task; - friend class Task; - void rateLimitContext(); - - WebKit::WebGraphicsContext3D* m_context; - bool m_active; - RateLimiterClient *m_client; -}; - -} -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/rate_limiter.h" diff --git a/cc/RenderSurfaceChromium.h b/cc/RenderSurfaceChromium.h index 67ed62666dbb40..a7a91476ef5a2a 100644 --- a/cc/RenderSurfaceChromium.h +++ b/cc/RenderSurfaceChromium.h @@ -1,107 +1,6 @@ -// Copyright 2010 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef RenderSurfaceChromium_h -#define RenderSurfaceChromium_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "base/basictypes.h" -#include "base/memory/ref_counted.h" -#include "FloatRect.h" -#include "IntRect.h" -#include -#include - -namespace cc { - -class LayerChromium; - -class RenderSurfaceChromium { -public: - explicit RenderSurfaceChromium(LayerChromium*); - ~RenderSurfaceChromium(); - - // Returns the rect that encloses the RenderSurface including any reflection. - FloatRect drawableContentRect() const; - - const IntRect& contentRect() const { return m_contentRect; } - void setContentRect(const IntRect& contentRect) { m_contentRect = contentRect; } - - float drawOpacity() const { return m_drawOpacity; } - void setDrawOpacity(float drawOpacity) { m_drawOpacity = drawOpacity; } - - bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; } - void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; } - - // This goes from content space with the origin in the center of the rect being transformed to the target space with the origin in the top left of the - // rect being transformed. Position the rect so that the origin is in the center of it before applying this transform. - const WebKit::WebTransformationMatrix& drawTransform() const { return m_drawTransform; } - void setDrawTransform(const WebKit::WebTransformationMatrix& drawTransform) { m_drawTransform = drawTransform; } - - const WebKit::WebTransformationMatrix& screenSpaceTransform() const { return m_screenSpaceTransform; } - void setScreenSpaceTransform(const WebKit::WebTransformationMatrix& screenSpaceTransform) { m_screenSpaceTransform = screenSpaceTransform; } - - const WebKit::WebTransformationMatrix& replicaDrawTransform() const { return m_replicaDrawTransform; } - void setReplicaDrawTransform(const WebKit::WebTransformationMatrix& replicaDrawTransform) { m_replicaDrawTransform = replicaDrawTransform; } - - const WebKit::WebTransformationMatrix& replicaScreenSpaceTransform() const { return m_replicaScreenSpaceTransform; } - void setReplicaScreenSpaceTransform(const WebKit::WebTransformationMatrix& replicaScreenSpaceTransform) { m_replicaScreenSpaceTransform = replicaScreenSpaceTransform; } - - bool targetSurfaceTransformsAreAnimating() const { return m_targetSurfaceTransformsAreAnimating; } - void setTargetSurfaceTransformsAreAnimating(bool animating) { m_targetSurfaceTransformsAreAnimating = animating; } - bool screenSpaceTransformsAreAnimating() const { return m_screenSpaceTransformsAreAnimating; } - void setScreenSpaceTransformsAreAnimating(bool animating) { m_screenSpaceTransformsAreAnimating = animating; } - - const IntRect& clipRect() const { return m_clipRect; } - void setClipRect(const IntRect& clipRect) { m_clipRect = clipRect; } - - typedef std::vector > LayerList; - LayerList& layerList() { return m_layerList; } - // A no-op since DelegatedRendererLayers on the main thread don't have any - // RenderPasses so they can't contribute to a surface. - void addContributingDelegatedRenderPassLayer(LayerChromium*) { } - void clearLayerLists() { m_layerList.clear(); } - - void setNearestAncestorThatMovesPixels(RenderSurfaceChromium* surface) { m_nearestAncestorThatMovesPixels = surface; } - const RenderSurfaceChromium* nearestAncestorThatMovesPixels() const { return m_nearestAncestorThatMovesPixels; } - -private: - friend struct CCLayerIteratorActions; - - LayerChromium* m_owningLayer; - - // Uses this surface's space. - IntRect m_contentRect; - - float m_drawOpacity; - bool m_drawOpacityIsAnimating; - WebKit::WebTransformationMatrix m_drawTransform; - WebKit::WebTransformationMatrix m_screenSpaceTransform; - WebKit::WebTransformationMatrix m_replicaDrawTransform; - WebKit::WebTransformationMatrix m_replicaScreenSpaceTransform; - bool m_targetSurfaceTransformsAreAnimating; - bool m_screenSpaceTransformsAreAnimating; - - // Uses the space of the surface's target surface. - IntRect m_clipRect; - - LayerList m_layerList; - - // The nearest ancestor target surface that will contain the contents of this surface, and that is going - // to move pixels within the surface (such as with a blur). This can point to itself. - RenderSurfaceChromium* m_nearestAncestorThatMovesPixels; - - // For CCLayerIteratorActions - int m_targetRenderSurfaceLayerIndexHistory; - int m_currentLayerIndexHistory; - - DISALLOW_COPY_AND_ASSIGN(RenderSurfaceChromium); -}; - -} -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/render_surface.h" diff --git a/cc/ScrollbarLayerChromium.h b/cc/ScrollbarLayerChromium.h index 5c7cc5c0cd293c..1e7384a9650ffe 100644 --- a/cc/ScrollbarLayerChromium.h +++ b/cc/ScrollbarLayerChromium.h @@ -2,69 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef ScrollbarLayerChromium_h -#define ScrollbarLayerChromium_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "LayerChromium.h" -#include "caching_bitmap_canvas_layer_texture_updater.h" -#include -#include -#include - -namespace cc { - -class Scrollbar; -class ScrollbarThemeComposite; -class CCTextureUpdateQueue; - -class ScrollbarLayerChromium : public LayerChromium { -public: - virtual scoped_ptr createCCLayerImpl() OVERRIDE; - - static scoped_refptr create(PassOwnPtr, WebKit::WebScrollbarThemePainter, PassOwnPtr, int scrollLayerId); - - // LayerChromium interface - virtual bool needsContentsScale() const OVERRIDE; - virtual IntSize contentBounds() const OVERRIDE; - virtual void setTexturePriorities(const CCPriorityCalculator&) OVERRIDE; - virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) OVERRIDE; - virtual void setLayerTreeHost(CCLayerTreeHost*) OVERRIDE; - virtual void pushPropertiesTo(CCLayerImpl*) OVERRIDE; - - int scrollLayerId() const { return m_scrollLayerId; } - void setScrollLayerId(int id) { m_scrollLayerId = id; } - - virtual ScrollbarLayerChromium* toScrollbarLayerChromium() OVERRIDE; - -protected: - ScrollbarLayerChromium(PassOwnPtr, WebKit::WebScrollbarThemePainter, PassOwnPtr, int scrollLayerId); - virtual ~ScrollbarLayerChromium(); - -private: - void updatePart(CachingBitmapCanvasLayerTextureUpdater*, LayerTextureUpdater::Texture*, const IntRect&, CCTextureUpdateQueue&, CCRenderingStats&); - void createTextureUpdaterIfNeeded(); - - OwnPtr m_scrollbar; - WebKit::WebScrollbarThemePainter m_painter; - OwnPtr m_geometry; - int m_scrollLayerId; - - GC3Denum m_textureFormat; - - RefPtr m_backTrackUpdater; - RefPtr m_foreTrackUpdater; - RefPtr m_thumbUpdater; - - // All the parts of the scrollbar except the thumb - OwnPtr m_backTrack; - OwnPtr m_foreTrack; - OwnPtr m_thumb; -}; - -} -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/scrollbar_layer.h" diff --git a/cc/ShaderChromium.h b/cc/ShaderChromium.h index 2518382e318f06..5170597c9983cb 100644 --- a/cc/ShaderChromium.h +++ b/cc/ShaderChromium.h @@ -1,353 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef ShaderChromium_h -#define ShaderChromium_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "SkColorPriv.h" -#include - -namespace WebKit { -class WebGraphicsContext3D; -} - -namespace cc { - -class VertexShaderPosTex { -public: - VertexShaderPosTex(); - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - std::string getShaderString() const; - - int matrixLocation() const { return m_matrixLocation; } - -private: - int m_matrixLocation; -}; - -class VertexShaderPosTexYUVStretch { -public: - VertexShaderPosTexYUVStretch(); - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - std::string getShaderString() const; - - int matrixLocation() const { return m_matrixLocation; } - int yWidthScaleFactorLocation() const { return m_yWidthScaleFactorLocation; } - int uvWidthScaleFactorLocation() const { return m_uvWidthScaleFactorLocation; } - -private: - int m_matrixLocation; - int m_yWidthScaleFactorLocation; - int m_uvWidthScaleFactorLocation; -}; - -class VertexShaderPos { -public: - VertexShaderPos(); - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - std::string getShaderString() const; - - int matrixLocation() const { return m_matrixLocation; } - -private: - int m_matrixLocation; -}; - -class VertexShaderPosTexIdentity { -public: - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex) { } - std::string getShaderString() const; -}; - -class VertexShaderPosTexTransform { -public: - VertexShaderPosTexTransform(); - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - std::string getShaderString() const; - - int matrixLocation() const { return m_matrixLocation; } - int texTransformLocation() const { return m_texTransformLocation; } - -private: - int m_matrixLocation; - int m_texTransformLocation; -}; - -class VertexShaderQuad { -public: - VertexShaderQuad(); - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - std::string getShaderString() const; - - int matrixLocation() const { return m_matrixLocation; } - int pointLocation() const { return m_pointLocation; } - -private: - int m_matrixLocation; - int m_pointLocation; -}; - -class VertexShaderTile { -public: - VertexShaderTile(); - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - std::string getShaderString() const; - - int matrixLocation() const { return m_matrixLocation; } - int pointLocation() const { return m_pointLocation; } - int vertexTexTransformLocation() const { return m_vertexTexTransformLocation; } - -private: - int m_matrixLocation; - int m_pointLocation; - int m_vertexTexTransformLocation; -}; - -class VertexShaderVideoTransform { -public: - VertexShaderVideoTransform(); - - bool init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - std::string getShaderString() const; - - int matrixLocation() const { return m_matrixLocation; } - int texMatrixLocation() const { return m_texMatrixLocation; } - -private: - int m_matrixLocation; - int m_texMatrixLocation; -}; - -class FragmentTexAlphaBinding { -public: - FragmentTexAlphaBinding(); - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - int alphaLocation() const { return m_alphaLocation; } - int edgeLocation() const { return -1; } - int fragmentTexTransformLocation() const { return -1; } - int samplerLocation() const { return m_samplerLocation; } - -private: - int m_samplerLocation; - int m_alphaLocation; -}; - -class FragmentTexOpaqueBinding { -public: - FragmentTexOpaqueBinding(); - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - int alphaLocation() const { return -1; } - int edgeLocation() const { return -1; } - int fragmentTexTransformLocation() const { return -1; } - int samplerLocation() const { return m_samplerLocation; } - -private: - int m_samplerLocation; -}; - -class FragmentShaderRGBATexFlipAlpha : public FragmentTexAlphaBinding { -public: - std::string getShaderString() const; -}; - -class FragmentShaderRGBATexAlpha : public FragmentTexAlphaBinding { -public: - std::string getShaderString() const; -}; - -class FragmentShaderRGBATexRectFlipAlpha : public FragmentTexAlphaBinding { -public: - std::string getShaderString() const; -}; - -class FragmentShaderRGBATexRectAlpha : public FragmentTexAlphaBinding { -public: - std::string getShaderString() const; -}; - -class FragmentShaderRGBATexOpaque : public FragmentTexOpaqueBinding { -public: - std::string getShaderString() const; -}; - -class FragmentShaderRGBATex : public FragmentTexOpaqueBinding { -public: - std::string getShaderString() const; -}; - -// Swizzles the red and blue component of sampled texel with alpha. -class FragmentShaderRGBATexSwizzleAlpha : public FragmentTexAlphaBinding { -public: - std::string getShaderString() const; -}; - -// Swizzles the red and blue component of sampled texel without alpha. -class FragmentShaderRGBATexSwizzleOpaque : public FragmentTexOpaqueBinding { -public: - std::string getShaderString() const; -}; - -// Fragment shader for external textures. -class FragmentShaderOESImageExternal : public FragmentTexAlphaBinding { -public: - std::string getShaderString() const; - bool init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); -private: - int m_samplerLocation; -}; - -class FragmentShaderRGBATexAlphaAA { -public: - FragmentShaderRGBATexAlphaAA(); - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - std::string getShaderString() const; - - int alphaLocation() const { return m_alphaLocation; } - int samplerLocation() const { return m_samplerLocation; } - int edgeLocation() const { return m_edgeLocation; } - -private: - int m_samplerLocation; - int m_alphaLocation; - int m_edgeLocation; -}; - -class FragmentTexClampAlphaAABinding { -public: - FragmentTexClampAlphaAABinding(); - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - int alphaLocation() const { return m_alphaLocation; } - int samplerLocation() const { return m_samplerLocation; } - int fragmentTexTransformLocation() const { return m_fragmentTexTransformLocation; } - int edgeLocation() const { return m_edgeLocation; } - -private: - int m_samplerLocation; - int m_alphaLocation; - int m_fragmentTexTransformLocation; - int m_edgeLocation; -}; - -class FragmentShaderRGBATexClampAlphaAA : public FragmentTexClampAlphaAABinding { -public: - std::string getShaderString() const; -}; - -// Swizzles the red and blue component of sampled texel. -class FragmentShaderRGBATexClampSwizzleAlphaAA : public FragmentTexClampAlphaAABinding { -public: - std::string getShaderString() const; -}; - -class FragmentShaderRGBATexAlphaMask { -public: - FragmentShaderRGBATexAlphaMask(); - std::string getShaderString() const; - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - int alphaLocation() const { return m_alphaLocation; } - int samplerLocation() const { return m_samplerLocation; } - int maskSamplerLocation() const { return m_maskSamplerLocation; } - int maskTexCoordScaleLocation() const { return m_maskTexCoordScaleLocation; } - int maskTexCoordOffsetLocation() const { return m_maskTexCoordOffsetLocation; } - -private: - int m_samplerLocation; - int m_maskSamplerLocation; - int m_alphaLocation; - int m_maskTexCoordScaleLocation; - int m_maskTexCoordOffsetLocation; -}; - -class FragmentShaderRGBATexAlphaMaskAA { -public: - FragmentShaderRGBATexAlphaMaskAA(); - std::string getShaderString() const; - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - int alphaLocation() const { return m_alphaLocation; } - int samplerLocation() const { return m_samplerLocation; } - int maskSamplerLocation() const { return m_maskSamplerLocation; } - int edgeLocation() const { return m_edgeLocation; } - int maskTexCoordScaleLocation() const { return m_maskTexCoordScaleLocation; } - int maskTexCoordOffsetLocation() const { return m_maskTexCoordOffsetLocation; } - -private: - int m_samplerLocation; - int m_maskSamplerLocation; - int m_alphaLocation; - int m_edgeLocation; - int m_maskTexCoordScaleLocation; - int m_maskTexCoordOffsetLocation; -}; - -class FragmentShaderYUVVideo { -public: - FragmentShaderYUVVideo(); - std::string getShaderString() const; - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - - int yTextureLocation() const { return m_yTextureLocation; } - int uTextureLocation() const { return m_uTextureLocation; } - int vTextureLocation() const { return m_vTextureLocation; } - int alphaLocation() const { return m_alphaLocation; } - int ccMatrixLocation() const { return m_ccMatrixLocation; } - int yuvAdjLocation() const { return m_yuvAdjLocation; } - -private: - int m_yTextureLocation; - int m_uTextureLocation; - int m_vTextureLocation; - int m_alphaLocation; - int m_ccMatrixLocation; - int m_yuvAdjLocation; -}; - -class FragmentShaderColor { -public: - FragmentShaderColor(); - std::string getShaderString() const; - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - int colorLocation() const { return m_colorLocation; } - -private: - int m_colorLocation; -}; - -class FragmentShaderCheckerboard { -public: - FragmentShaderCheckerboard(); - std::string getShaderString() const; - - void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); - int alphaLocation() const { return m_alphaLocation; } - int texTransformLocation() const { return m_texTransformLocation; } - int frequencyLocation() const { return m_frequencyLocation; } - int colorLocation() const { return m_colorLocation; } -private: - int m_alphaLocation; - int m_texTransformLocation; - int m_frequencyLocation; - int m_colorLocation; -}; - -} // namespace cc - -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/shader.h" diff --git a/cc/SkPictureCanvasLayerTextureUpdater.h b/cc/SkPictureCanvasLayerTextureUpdater.h index fd9bb5fccd1703..8d3d49edbb3df8 100644 --- a/cc/SkPictureCanvasLayerTextureUpdater.h +++ b/cc/SkPictureCanvasLayerTextureUpdater.h @@ -1,48 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef SkPictureCanvasLayerTextureUpdater_h -#define SkPictureCanvasLayerTextureUpdater_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "CanvasLayerTextureUpdater.h" -#include "SkPicture.h" - -class SkCanvas; - -namespace cc { - -class LayerPainterChromium; - -// This class records the contentRect into an SkPicture. Subclasses, provide -// different implementations of tile updating based on this recorded picture. -// The BitmapSkPictureCanvasLayerTextureUpdater and -// FrameBufferSkPictureCanvasLayerTextureUpdater are two examples of such -// implementations. -class SkPictureCanvasLayerTextureUpdater : public CanvasLayerTextureUpdater { -public: - virtual ~SkPictureCanvasLayerTextureUpdater(); - - virtual void setOpaque(bool) OVERRIDE; - -protected: - explicit SkPictureCanvasLayerTextureUpdater(PassOwnPtr); - - virtual void prepareToUpdate(const IntRect& contentRect, const IntSize& tileSize, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, CCRenderingStats&) OVERRIDE; - void drawPicture(SkCanvas*); - - bool layerIsOpaque() const { return m_layerIsOpaque; } - -private: - // Recording canvas. - SkPicture m_picture; - // True when it is known that all output pixels will be opaque. - bool m_layerIsOpaque; -}; - -} // namespace cc -#endif // USE(ACCELERATED_COMPOSITING) -#endif // SkPictureCanvasLayerTextureUpdater_h +// Temporary forwarding header +#include "cc/skpicture_canvas_layer_texture_updater.h" diff --git a/cc/SolidColorLayerChromium.h b/cc/SolidColorLayerChromium.h index 912348410ae50f..a60d376b702881 100644 --- a/cc/SolidColorLayerChromium.h +++ b/cc/SolidColorLayerChromium.h @@ -2,32 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef SolidColorLayerChromium_h -#define SolidColorLayerChromium_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "LayerChromium.h" - -namespace cc { - -// A Layer that renders a solid color. The color is specified by using -// setBackgroundColor() on the base class. -class SolidColorLayerChromium : public LayerChromium { -public: - static scoped_refptr create(); - - virtual scoped_ptr createCCLayerImpl() OVERRIDE; - -protected: - SolidColorLayerChromium(); - -private: - virtual ~SolidColorLayerChromium(); -}; - -} -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/solid_color_layer.h" diff --git a/cc/TextureCopier.h b/cc/TextureCopier.h index ba8d7bf5e6af9b..de210fe65ab359 100644 --- a/cc/TextureCopier.h +++ b/cc/TextureCopier.h @@ -2,69 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef TextureCopier_h -#define TextureCopier_h - -#include "base/basictypes.h" -#include "GraphicsContext3D.h" -#include "ProgramBinding.h" -#include "ShaderChromium.h" -#include -#include - -namespace WebKit { -class WebGraphicsContext3D; -} - -namespace cc { -class IntSize; - -class TextureCopier { -public: - struct Parameters { - unsigned sourceTexture; - unsigned destTexture; - IntSize size; - }; - // Copy the base level contents of |sourceTexture| to |destTexture|. Both texture objects - // must be complete and have a base level of |size| dimensions. The color formats do not need - // to match, but |destTexture| must have a renderable format. - virtual void copyTexture(Parameters) = 0; - virtual void flush() = 0; - - virtual ~TextureCopier() { } -}; - -#if USE(ACCELERATED_COMPOSITING) - -class AcceleratedTextureCopier : public TextureCopier { -public: - static PassOwnPtr create(WebKit::WebGraphicsContext3D* context, bool usingBindUniforms) - { - return adoptPtr(new AcceleratedTextureCopier(context, usingBindUniforms)); - } - virtual ~AcceleratedTextureCopier(); - - virtual void copyTexture(Parameters) OVERRIDE; - virtual void flush() OVERRIDE; - -protected: - AcceleratedTextureCopier(WebKit::WebGraphicsContext3D*, bool usingBindUniforms); - -private: - typedef ProgramBinding BlitProgram; - - WebKit::WebGraphicsContext3D* m_context; - Platform3DObject m_fbo; - Platform3DObject m_positionBuffer; - OwnPtr m_blitProgram; - bool m_usingBindUniforms; - - DISALLOW_COPY_AND_ASSIGN(AcceleratedTextureCopier); -}; - -#endif // USE(ACCELERATED_COMPOSITING) - -} - -#endif +// Temporary forwarding header +#include "cc/texture_copier.h" diff --git a/cc/TextureLayerChromium.h b/cc/TextureLayerChromium.h index 124f84505d27b6..620c2d5c1d3019 100644 --- a/cc/TextureLayerChromium.h +++ b/cc/TextureLayerChromium.h @@ -1,77 +1,6 @@ -// Copyright 2010 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef TextureLayerChromium_h -#define TextureLayerChromium_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "LayerChromium.h" - -namespace WebKit { -class WebGraphicsContext3D; -} - -namespace cc { - -class TextureLayerChromiumClient; - -// A Layer containing a the rendered output of a plugin instance. -class TextureLayerChromium : public LayerChromium { -public: - // If this texture layer requires special preparation logic for each frame driven by - // the compositor, pass in a non-nil client. Pass in a nil client pointer if texture updates - // are driven by an external process. - static scoped_refptr create(TextureLayerChromiumClient*); - - void clearClient() { m_client = 0; } - - virtual scoped_ptr createCCLayerImpl() OVERRIDE; - - // Sets whether this texture should be Y-flipped at draw time. Defaults to true. - void setFlipped(bool); - - // Sets a UV transform to be used at draw time. Defaults to (0, 0, 1, 1). - void setUVRect(const FloatRect&); - - // Sets whether the alpha channel is premultiplied or unpremultiplied. Defaults to true. - void setPremultipliedAlpha(bool); - - // Sets whether this context should rate limit on damage to prevent too many frames from - // being queued up before the compositor gets a chance to run. Requires a non-nil client. - // Defaults to false. - void setRateLimitContext(bool); - - // Code path for plugins which supply their own texture ID. - void setTextureId(unsigned); - - void willModifyTexture(); - - virtual void setNeedsDisplayRect(const FloatRect&) OVERRIDE; - - virtual void setLayerTreeHost(CCLayerTreeHost*) OVERRIDE; - virtual bool drawsContent() const OVERRIDE; - virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) OVERRIDE; - virtual void pushPropertiesTo(CCLayerImpl*) OVERRIDE; - -protected: - explicit TextureLayerChromium(TextureLayerChromiumClient*); - virtual ~TextureLayerChromium(); - -private: - TextureLayerChromiumClient* m_client; - - bool m_flipped; - FloatRect m_uvRect; - bool m_premultipliedAlpha; - bool m_rateLimitContext; - bool m_contextLost; - - unsigned m_textureId; -}; - -} -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/texture_layer.h" diff --git a/cc/TextureLayerChromiumClient.h b/cc/TextureLayerChromiumClient.h index 4edbe9f5860ee0..bec4fa52502259 100644 --- a/cc/TextureLayerChromiumClient.h +++ b/cc/TextureLayerChromiumClient.h @@ -2,30 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef TextureLayerChromiumClient_h -#define TextureLayerChromiumClient_h - -namespace WebKit { -class WebGraphicsContext3D; -} - -namespace cc { -class CCTextureUpdateQueue; - -class TextureLayerChromiumClient { -public: - // Called to prepare this layer's texture for compositing. The client may queue a texture - // upload or copy on the CCTextureUpdateQueue. - // Returns the texture ID to be used for compositing. - virtual unsigned prepareTexture(CCTextureUpdateQueue&) = 0; - - // Returns the context that is providing the texture. Used for rate limiting and detecting lost context. - virtual WebKit::WebGraphicsContext3D* context() = 0; - -protected: - virtual ~TextureLayerChromiumClient() { } -}; - -} - -#endif // TextureLayerChromiumClient_h +// Temporary forwarding header +#include "cc/texture_layer_client.h" diff --git a/cc/TextureUploader.h b/cc/TextureUploader.h index 5505204a689060..0cf73f762243dd 100644 --- a/cc/TextureUploader.h +++ b/cc/TextureUploader.h @@ -2,31 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef TextureUploader_h -#define TextureUploader_h - -#include "LayerTextureUpdater.h" - -namespace cc { - -class TextureUploader { -public: - struct Parameters { - LayerTextureUpdater::Texture* texture; - IntRect sourceRect; - IntSize destOffset; - }; - - virtual ~TextureUploader() { } - - virtual size_t numBlockingUploads() = 0; - virtual void markPendingUploadsAsNonBlocking() = 0; - - // Returns our throughput on the GPU process - virtual double estimatedTexturesPerSecond() = 0; - virtual void uploadTexture(CCResourceProvider*, Parameters) = 0; -}; - -} - -#endif +// Temporary forwarding header +#include "cc/texture_uploader.h" diff --git a/cc/ThrottledTextureUploader.h b/cc/ThrottledTextureUploader.h index f51740158d1241..f839d2469b36c7 100644 --- a/cc/ThrottledTextureUploader.h +++ b/cc/ThrottledTextureUploader.h @@ -2,75 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef ThrottledTextureUploader_h -#define ThrottledTextureUploader_h - -#include "TextureUploader.h" - -#include "base/basictypes.h" -#include -#include - -namespace WebKit { -class WebGraphicsContext3D; -} - -namespace cc { - -class ThrottledTextureUploader : public TextureUploader { -public: - static PassOwnPtr create(WebKit::WebGraphicsContext3D* context) - { - return adoptPtr(new ThrottledTextureUploader(context)); - } - virtual ~ThrottledTextureUploader(); - - virtual size_t numBlockingUploads() OVERRIDE; - virtual void markPendingUploadsAsNonBlocking() OVERRIDE; - virtual double estimatedTexturesPerSecond() OVERRIDE; - virtual void uploadTexture(CCResourceProvider*, Parameters) OVERRIDE; - -private: - class Query { - public: - static PassOwnPtr create(WebKit::WebGraphicsContext3D* context) { return adoptPtr(new Query(context)); } - - virtual ~Query(); - - void begin(); - void end(); - bool isPending(); - void wait(); - unsigned value(); - size_t texturesUploaded(); - void markAsNonBlocking(); - bool isNonBlocking(); - - private: - explicit Query(WebKit::WebGraphicsContext3D*); - - WebKit::WebGraphicsContext3D* m_context; - unsigned m_queryId; - unsigned m_value; - bool m_hasValue; - bool m_isNonBlocking; - }; - - ThrottledTextureUploader(WebKit::WebGraphicsContext3D*); - - void beginQuery(); - void endQuery(); - void processQueries(); - - WebKit::WebGraphicsContext3D* m_context; - Deque > m_pendingQueries; - Deque > m_availableQueries; - std::deque m_texturesPerSecondHistory; - size_t m_numBlockingTextureUploads; - - DISALLOW_COPY_AND_ASSIGN(ThrottledTextureUploader); -}; - -} - -#endif +// Temporary forwarding header +#include "cc/throttled_texture_uploader.h" diff --git a/cc/TiledLayerChromium.h b/cc/TiledLayerChromium.h index 3c273821613c37..cdf78689165eeb 100644 --- a/cc/TiledLayerChromium.h +++ b/cc/TiledLayerChromium.h @@ -1,105 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef TiledLayerChromium_h -#define TiledLayerChromium_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "CCLayerTilingData.h" -#include "LayerChromium.h" -#include "LayerTextureUpdater.h" - -namespace cc { -class UpdatableTile; - -class TiledLayerChromium : public LayerChromium { -public: - enum TilingOption { AlwaysTile, NeverTile, AutoTile }; - - virtual void setIsMask(bool) OVERRIDE; - - virtual void pushPropertiesTo(CCLayerImpl*) OVERRIDE; - - virtual bool drawsContent() const OVERRIDE; - virtual bool needsContentsScale() const OVERRIDE; - - virtual IntSize contentBounds() const OVERRIDE; - - virtual void setNeedsDisplayRect(const FloatRect&) OVERRIDE; - - virtual void setUseLCDText(bool) OVERRIDE; - - virtual void setLayerTreeHost(CCLayerTreeHost*) OVERRIDE; - - virtual void setTexturePriorities(const CCPriorityCalculator&) OVERRIDE; - - virtual Region visibleContentOpaqueRegion() const OVERRIDE; - - virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) OVERRIDE; - -protected: - TiledLayerChromium(); - virtual ~TiledLayerChromium(); - - void updateTileSizeAndTilingOption(); - void updateBounds(); - - // Exposed to subclasses for testing. - void setTileSize(const IntSize&); - void setTextureFormat(GC3Denum textureFormat) { m_textureFormat = textureFormat; } - void setBorderTexelOption(CCLayerTilingData::BorderTexelOption); - void setSampledTexelFormat(LayerTextureUpdater::SampledTexelFormat sampledTexelFormat) { m_sampledTexelFormat = sampledTexelFormat; } - size_t numPaintedTiles() { return m_tiler->tiles().size(); } - - virtual LayerTextureUpdater* textureUpdater() const = 0; - virtual void createTextureUpdaterIfNeeded() = 0; - - // Set invalidations to be potentially repainted during update(). - void invalidateContentRect(const IntRect& contentRect); - - // Reset state on tiles that will be used for updating the layer. - void resetUpdateState(); - - // After preparing an update, returns true if more painting is needed. - bool needsIdlePaint(); - IntRect idlePaintRect(); - - bool skipsDraw() const { return m_skipsDraw; } - - // Virtual for testing - virtual CCPrioritizedTextureManager* textureManager() const; - -private: - virtual scoped_ptr createCCLayerImpl() OVERRIDE; - - void createTilerIfNeeded(); - void setTilingOption(TilingOption); - - bool tileOnlyNeedsPartialUpdate(UpdatableTile*); - bool tileNeedsBufferedUpdate(UpdatableTile*); - - void markOcclusionsAndRequestTextures(int left, int top, int right, int bottom, const CCOcclusionTracker*); - - bool updateTiles(int left, int top, int right, int bottom, CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&, bool& didPaint); - bool haveTexturesForTiles(int left, int top, int right, int bottom, bool ignoreOcclusions); - IntRect markTilesForUpdate(int left, int top, int right, int bottom, bool ignoreOcclusions); - void updateTileTextures(const IntRect& paintRect, int left, int top, int right, int bottom, CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&); - - UpdatableTile* tileAt(int, int) const; - UpdatableTile* createTile(int, int); - - GC3Denum m_textureFormat; - bool m_skipsDraw; - bool m_failedUpdate; - LayerTextureUpdater::SampledTexelFormat m_sampledTexelFormat; - - TilingOption m_tilingOption; - OwnPtr m_tiler; -}; - -} -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/tiled_layer.h" diff --git a/cc/TreeSynchronizer.h b/cc/TreeSynchronizer.h index 26098411b94294..f6e56c1b8705e0 100644 --- a/cc/TreeSynchronizer.h +++ b/cc/TreeSynchronizer.h @@ -1,41 +1,6 @@ -// Copyright 2011 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef TreeSynchronizer_h -#define TreeSynchronizer_h - -#include "base/basictypes.h" -#include "base/memory/scoped_ptr.h" -#include "cc/scoped_ptr_hash_map.h" - -namespace cc { - -class CCLayerImpl; -class CCLayerTreeHostImpl; -class LayerChromium; - -class TreeSynchronizer { -public: - // Accepts a LayerChromium tree and returns a reference to a CCLayerImpl tree that duplicates the structure - // of the LayerChromium tree, reusing the CCLayerImpls in the tree provided by oldCCLayerImplRoot if possible. - static scoped_ptr synchronizeTrees(LayerChromium* layerRoot, scoped_ptr oldCCLayerImplRoot, CCLayerTreeHostImpl*); - -private: - TreeSynchronizer(); // Not instantiable. - - typedef ScopedPtrHashMap ScopedPtrCCLayerImplMap; - typedef base::hash_map RawPtrCCLayerImplMap; - - // Declared as static member functions so they can access functions on LayerChromium as a friend class. - static scoped_ptr reuseOrCreateCCLayerImpl(RawPtrCCLayerImplMap& newLayers, ScopedPtrCCLayerImplMap& oldLayers, LayerChromium*); - static void collectExistingCCLayerImplRecursive(ScopedPtrCCLayerImplMap& oldLayers, scoped_ptr); - static scoped_ptr synchronizeTreeRecursive(RawPtrCCLayerImplMap& newLayers, ScopedPtrCCLayerImplMap& oldLayers, LayerChromium*, CCLayerTreeHostImpl*); - static void updateScrollbarLayerPointersRecursive(const RawPtrCCLayerImplMap& newLayers, LayerChromium*); - - DISALLOW_COPY_AND_ASSIGN(TreeSynchronizer); -}; - -} // namespace cc - -#endif // TreeSynchronizer_h +// Temporary forwarding header +#include "cc/tree_synchronizer.h" diff --git a/cc/UnthrottledTextureUploader.h b/cc/UnthrottledTextureUploader.h index bc0822ace22ea3..6df0878b53cce4 100644 --- a/cc/UnthrottledTextureUploader.h +++ b/cc/UnthrottledTextureUploader.h @@ -2,35 +2,5 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef UnthrottledTextureUploader_h -#define UnthrottledTextureUploader_h - -#include "base/basictypes.h" -#include "CCResourceProvider.h" -#include "TextureUploader.h" - -namespace cc { - -class UnthrottledTextureUploader : public TextureUploader { -public: - static PassOwnPtr create() - { - return adoptPtr(new UnthrottledTextureUploader()); - } - virtual ~UnthrottledTextureUploader() { } - - virtual size_t numBlockingUploads() OVERRIDE; - virtual void markPendingUploadsAsNonBlocking() OVERRIDE; - virtual double estimatedTexturesPerSecond() OVERRIDE; - virtual void uploadTexture(CCResourceProvider* resourceProvider, Parameters upload) OVERRIDE; - -protected: - UnthrottledTextureUploader() { } - -private: - DISALLOW_COPY_AND_ASSIGN(UnthrottledTextureUploader); -}; - -} - -#endif +// Temporary forwarding header +#include "cc/unthrottled_texture_uploader.h" diff --git a/cc/VideoLayerChromium.h b/cc/VideoLayerChromium.h index 92b5e1383d54ce..2d2179efdc505f 100644 --- a/cc/VideoLayerChromium.h +++ b/cc/VideoLayerChromium.h @@ -1,39 +1,6 @@ -// Copyright 2010 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. - -#ifndef VideoLayerChromium_h -#define VideoLayerChromium_h - -#if USE(ACCELERATED_COMPOSITING) - -#include "LayerChromium.h" - -namespace WebKit { -class WebVideoFrameProvider; -} - -namespace cc { - -class CCVideoLayerImpl; - -// A Layer that contains a Video element. -class VideoLayerChromium : public LayerChromium { -public: - static scoped_refptr create(WebKit::WebVideoFrameProvider*); - - virtual scoped_ptr createCCLayerImpl() OVERRIDE; - -private: - explicit VideoLayerChromium(WebKit::WebVideoFrameProvider*); - virtual ~VideoLayerChromium(); - - // This pointer is only for passing to CCVideoLayerImpl's constructor. It should never be dereferenced by this class. - WebKit::WebVideoFrameProvider* m_provider; -}; - -} -#endif // USE(ACCELERATED_COMPOSITING) - -#endif +// Temporary forwarding header +#include "cc/video_layer.h" diff --git a/cc/CCActiveAnimation.cpp b/cc/active_animation.cc similarity index 100% rename from cc/CCActiveAnimation.cpp rename to cc/active_animation.cc diff --git a/cc/active_animation.h b/cc/active_animation.h index 638cbb270ce9b2..b8d3607d9b1e7d 100644 --- a/cc/active_animation.h +++ b/cc/active_animation.h @@ -1,3 +1,161 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCActiveAnimation_h +#define CCActiveAnimation_h + +#include "base/basictypes.h" +#include "base/memory/scoped_ptr.h" + +namespace cc { + +class CCAnimationCurve; + +// A CCActiveAnimation, contains all the state required to play a CCAnimationCurve. +// Specifically, the affected property, the run state (paused, finished, etc.), +// loop count, last pause time, and the total time spent paused. +class CCActiveAnimation { +public: + // Animations begin in one of the 'waiting' states. Animations waiting for the next tick + // will start the next time the controller animates. Animations waiting for target + // availibility will run as soon as their target property is free (and all the animations + // animating with it are also able to run). Animations waiting for their start time to + // come have be scheduled to run at a particular point in time. When this time arrives, + // the controller will move the animations into the Running state. Running animations + // may toggle between Running and Paused, and may be stopped by moving into either the + // Aborted or Finished states. A Finished animation was allowed to run to completion, but + // an Aborted animation was not. + enum RunState { + WaitingForNextTick = 0, + WaitingForTargetAvailability, + WaitingForStartTime, + WaitingForDeletion, + Running, + Paused, + Finished, + Aborted, + // This sentinel must be last. + RunStateEnumSize + }; + + enum TargetProperty { + Transform = 0, + Opacity, + // This sentinel must be last. + TargetPropertyEnumSize + }; + + static scoped_ptr create(scoped_ptr, int animationId, int groupId, TargetProperty); + + virtual ~CCActiveAnimation(); + + int id() const { return m_id; } + int group() const { return m_group; } + TargetProperty targetProperty() const { return m_targetProperty; } + + RunState runState() const { return m_runState; } + void setRunState(RunState, double monotonicTime); + + // This is the number of times that the animation will play. If this + // value is zero the animation will not play. If it is negative, then + // the animation will loop indefinitely. + int iterations() const { return m_iterations; } + void setIterations(int n) { m_iterations = n; } + + double startTime() const { return m_startTime; } + void setStartTime(double monotonicTime) { m_startTime = monotonicTime; } + bool hasSetStartTime() const { return m_startTime; } + + double timeOffset() const { return m_timeOffset; } + void setTimeOffset(double monotonicTime) { m_timeOffset = monotonicTime; } + + void suspend(double monotonicTime); + void resume(double monotonicTime); + + // If alternatesDirection is true, on odd numbered iterations we reverse the curve. + bool alternatesDirection() const { return m_alternatesDirection; } + void setAlternatesDirection(bool alternates) { m_alternatesDirection = alternates; } + + bool isFinishedAt(double monotonicTime) const; + bool isFinished() const { return m_runState == Finished + || m_runState == Aborted + || m_runState == WaitingForDeletion; } + + CCAnimationCurve* curve() { return m_curve.get(); } + const CCAnimationCurve* curve() const { return m_curve.get(); } + + // If this is true, even if the animation is running, it will not be tickable until + // it is given a start time. This is true for animations running on the main thread. + bool needsSynchronizedStartTime() const { return m_needsSynchronizedStartTime; } + void setNeedsSynchronizedStartTime(bool needsSynchronizedStartTime) { m_needsSynchronizedStartTime = needsSynchronizedStartTime; } + + // Takes the given absolute time, and using the start time and the number + // of iterations, returns the relative time in the current iteration. + double trimTimeToCurrentIteration(double monotonicTime) const; + + enum InstanceType { + ControllingInstance = 0, + NonControllingInstance + }; + + scoped_ptr clone(InstanceType) const; + scoped_ptr cloneAndInitialize(InstanceType, RunState initialRunState, double startTime) const; + bool isControllingInstance() const { return m_isControllingInstance; } + + void pushPropertiesTo(CCActiveAnimation*) const; + +private: + CCActiveAnimation(scoped_ptr, int animationId, int groupId, TargetProperty); + + scoped_ptr m_curve; + + // IDs are not necessarily unique. + int m_id; + + // Animations that must be run together are called 'grouped' and have the same group id + // Grouped animations are guaranteed to start at the same time and no other animations + // may animate any of the group's target properties until all animations in the + // group have finished animating. Note: an active animation's group id and target + // property uniquely identify that animation. + int m_group; + + TargetProperty m_targetProperty; + RunState m_runState; + int m_iterations; + double m_startTime; + bool m_alternatesDirection; + + // The time offset effectively pushes the start of the animation back in time. This is + // used for resuming paused animations -- an animation is added with a non-zero time + // offset, causing the animation to skip ahead to the desired point in time. + double m_timeOffset; + + bool m_needsSynchronizedStartTime; + + // When an animation is suspended, it behaves as if it is paused and it also ignores + // all run state changes until it is resumed. This is used for testing purposes. + bool m_suspended; + + // These are used in trimTimeToCurrentIteration to account for time + // spent while paused. This is not included in AnimationState since it + // there is absolutely no need for clients of this controller to know + // about these values. + double m_pauseTime; + double m_totalPausedTime; + + // Animations lead dual lives. An active animation will be conceptually owned by + // two controllers, one on the impl thread and one on the main. In reality, there + // will be two separate CCActiveAnimation instances for the same animation. They + // will have the same group id and the same target property (these two values + // uniquely identify an animation). The instance on the impl thread is the instance + // that ultimately controls the values of the animating layer and so we will refer + // to it as the 'controlling instance'. + bool m_isControllingInstance; + + DISALLOW_COPY_AND_ASSIGN(CCActiveAnimation); +}; + +} // namespace cc + +#endif // CCActiveAnimation_h diff --git a/cc/CCAnimationCurve.cpp b/cc/animation_curve.cc similarity index 100% rename from cc/CCAnimationCurve.cpp rename to cc/animation_curve.cc diff --git a/cc/animation_curve.h b/cc/animation_curve.h index 638cbb270ce9b2..7ed6e7a9e50a43 100644 --- a/cc/animation_curve.h +++ b/cc/animation_curve.h @@ -1,3 +1,56 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCAnimationCurve_h +#define CCAnimationCurve_h + +#include "base/memory/scoped_ptr.h" +#include + +namespace cc { + +class CCFloatAnimationCurve; +class CCTransformAnimationCurve; +class IntSize; +class TransformOperations; + +// An animation curve is a function that returns a value given a time. +// There are currently only two types of curve, float and transform. +class CCAnimationCurve { +public: + enum Type { Float, Transform }; + + virtual ~CCAnimationCurve() { } + + virtual double duration() const = 0; + virtual Type type() const = 0; + virtual scoped_ptr clone() const = 0; + + const CCFloatAnimationCurve* toFloatAnimationCurve() const; + const CCTransformAnimationCurve* toTransformAnimationCurve() const; +}; + +class CCFloatAnimationCurve : public CCAnimationCurve { +public: + virtual ~CCFloatAnimationCurve() { } + + virtual float getValue(double t) const = 0; + + // Partial CCAnimation implementation. + virtual Type type() const OVERRIDE; +}; + +class CCTransformAnimationCurve : public CCAnimationCurve { +public: + virtual ~CCTransformAnimationCurve() { } + + virtual WebKit::WebTransformationMatrix getValue(double t) const = 0; + + // Partial CCAnimation implementation. + virtual Type type() const OVERRIDE; +}; + +} // namespace cc + +#endif // CCAnimation_h diff --git a/cc/animation_events.h b/cc/animation_events.h index 638cbb270ce9b2..5e86ef7381527b 100644 --- a/cc/animation_events.h +++ b/cc/animation_events.h @@ -1,3 +1,37 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCAnimationEvents_h +#define CCAnimationEvents_h + +#include + +#include "CCActiveAnimation.h" + +namespace cc { + +struct CCAnimationEvent { + enum Type { Started, Finished }; + + CCAnimationEvent(Type type, int layerId, int groupId, CCActiveAnimation::TargetProperty targetProperty, double monotonicTime) + : type(type) + , layerId(layerId) + , groupId(groupId) + , targetProperty(targetProperty) + , monotonicTime(monotonicTime) + { + } + + Type type; + int layerId; + int groupId; + CCActiveAnimation::TargetProperty targetProperty; + double monotonicTime; +}; + +typedef std::vector CCAnimationEventsVector; + +} // namespace cc + +#endif // CCAnimationEvents_h diff --git a/cc/append_quads_data.h b/cc/append_quads_data.h index 638cbb270ce9b2..b086de01a85269 100644 --- a/cc/append_quads_data.h +++ b/cc/append_quads_data.h @@ -1,3 +1,36 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCAppendQuadsData_h +#define CCAppendQuadsData_h + +#include "CCRenderPass.h" + +namespace cc { + +struct CCAppendQuadsData { + CCAppendQuadsData() + : hadOcclusionFromOutsideTargetSurface(false) + , hadMissingTiles(false) + , renderPassId(0, 0) + { + } + + explicit CCAppendQuadsData(CCRenderPass::Id renderPassId) + : hadOcclusionFromOutsideTargetSurface(false) + , hadMissingTiles(false) + , renderPassId(renderPassId) + { + } + + // Set by the QuadCuller. + bool hadOcclusionFromOutsideTargetSurface; + // Set by the layer appending quads. + bool hadMissingTiles; + // Given to the layer appending quads. + const CCRenderPass::Id renderPassId; +}; + +} +#endif // CCCCAppendQuadsData_h diff --git a/cc/BitmapCanvasLayerTextureUpdater.cpp b/cc/bitmap_canvas_layer_texture_updater.cc similarity index 100% rename from cc/BitmapCanvasLayerTextureUpdater.cpp rename to cc/bitmap_canvas_layer_texture_updater.cc diff --git a/cc/bitmap_canvas_layer_texture_updater.h b/cc/bitmap_canvas_layer_texture_updater.h index 638cbb270ce9b2..8cf4e2539b5ec1 100644 --- a/cc/bitmap_canvas_layer_texture_updater.h +++ b/cc/bitmap_canvas_layer_texture_updater.h @@ -1,3 +1,57 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef BitmapCanvasLayerTextureUpdater_h +#define BitmapCanvasLayerTextureUpdater_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "CanvasLayerTextureUpdater.h" + +class SkCanvas; + +namespace cc { + +class LayerPainterChromium; + +// This class rasterizes the contentRect into a skia bitmap canvas. It then updates +// textures by copying from the canvas into the texture, using MapSubImage if +// possible. +class BitmapCanvasLayerTextureUpdater : public CanvasLayerTextureUpdater { +public: + class Texture : public LayerTextureUpdater::Texture { + public: + Texture(BitmapCanvasLayerTextureUpdater*, scoped_ptr); + virtual ~Texture(); + + virtual void updateRect(CCResourceProvider*, const IntRect& sourceRect, const IntSize& destOffset) OVERRIDE; + + private: + BitmapCanvasLayerTextureUpdater* textureUpdater() { return m_textureUpdater; } + + BitmapCanvasLayerTextureUpdater* m_textureUpdater; + }; + + static PassRefPtr create(PassOwnPtr); + virtual ~BitmapCanvasLayerTextureUpdater(); + + virtual PassOwnPtr createTexture(CCPrioritizedTextureManager*) OVERRIDE; + virtual SampledTexelFormat sampledTexelFormat(GC3Denum textureFormat) OVERRIDE; + virtual void prepareToUpdate(const IntRect& contentRect, const IntSize& tileSize, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, CCRenderingStats&) OVERRIDE; + void updateTextureRect(CCResourceProvider*, CCPrioritizedTexture*, const IntRect& sourceRect, const IntSize& destOffset); + + virtual void setOpaque(bool) OVERRIDE; + +protected: + explicit BitmapCanvasLayerTextureUpdater(PassOwnPtr); + + OwnPtr m_canvas; + IntSize m_canvasSize; + bool m_opaque; +}; + +} // namespace cc +#endif // USE(ACCELERATED_COMPOSITING) +#endif // BitmapCanvasLayerTextureUpdater_h diff --git a/cc/BitmapSkPictureCanvasLayerTextureUpdater.cpp b/cc/bitmap_skpicture_canvas_layer_texture_updater.cc similarity index 100% rename from cc/BitmapSkPictureCanvasLayerTextureUpdater.cpp rename to cc/bitmap_skpicture_canvas_layer_texture_updater.cc diff --git a/cc/bitmap_skpicture_canvas_layer_texture_updater.h b/cc/bitmap_skpicture_canvas_layer_texture_updater.h index 638cbb270ce9b2..140f9beab6c707 100644 --- a/cc/bitmap_skpicture_canvas_layer_texture_updater.h +++ b/cc/bitmap_skpicture_canvas_layer_texture_updater.h @@ -1,3 +1,45 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef BitmapSkPictureCanvasLayerTextureUpdater_h +#define BitmapSkPictureCanvasLayerTextureUpdater_h + +#if USE(ACCELERATED_COMPOSITING) +#include "SkBitmap.h" +#include "SkPictureCanvasLayerTextureUpdater.h" + +namespace cc { + +// This class records the contentRect into an SkPicture, then software rasterizes +// the SkPicture into bitmaps for each tile. This implements CCSettings::perTilePainting. +class BitmapSkPictureCanvasLayerTextureUpdater : public SkPictureCanvasLayerTextureUpdater { +public: + class Texture : public CanvasLayerTextureUpdater::Texture { + public: + Texture(BitmapSkPictureCanvasLayerTextureUpdater*, scoped_ptr); + + virtual void prepareRect(const IntRect& sourceRect, CCRenderingStats&) OVERRIDE; + virtual void updateRect(CCResourceProvider*, const IntRect& sourceRect, const IntSize& destOffset) OVERRIDE; + + private: + BitmapSkPictureCanvasLayerTextureUpdater* textureUpdater() { return m_textureUpdater; } + + SkBitmap m_bitmap; + BitmapSkPictureCanvasLayerTextureUpdater* m_textureUpdater; + }; + + static PassRefPtr create(PassOwnPtr); + virtual ~BitmapSkPictureCanvasLayerTextureUpdater(); + + virtual PassOwnPtr createTexture(CCPrioritizedTextureManager*) OVERRIDE; + virtual SampledTexelFormat sampledTexelFormat(GC3Denum textureFormat) OVERRIDE; + void paintContentsRect(SkCanvas*, const IntRect& sourceRect, CCRenderingStats&); + +private: + explicit BitmapSkPictureCanvasLayerTextureUpdater(PassOwnPtr); +}; +} // namespace cc +#endif // USE(ACCELERATED_COMPOSITING) +#endif // BitmapSkPictureCanvasLayerTextureUpdater_h diff --git a/cc/CanvasLayerTextureUpdater.cpp b/cc/canvas_layer_texture_updater.cc similarity index 100% rename from cc/CanvasLayerTextureUpdater.cpp rename to cc/canvas_layer_texture_updater.cc diff --git a/cc/canvas_layer_texture_updater.h b/cc/canvas_layer_texture_updater.h index 638cbb270ce9b2..c8bb9b058a685d 100644 --- a/cc/canvas_layer_texture_updater.h +++ b/cc/canvas_layer_texture_updater.h @@ -1,3 +1,39 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef CanvasLayerTextureUpdater_h +#define CanvasLayerTextureUpdater_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "LayerTextureUpdater.h" + +class SkCanvas; + +namespace cc { + +class LayerPainterChromium; + +// Base class for BitmapCanvasLayerTextureUpdater and +// SkPictureCanvasLayerTextureUpdater that reduces code duplication between +// their respective paintContents implementations. +class CanvasLayerTextureUpdater : public LayerTextureUpdater { +public: + virtual ~CanvasLayerTextureUpdater(); + +protected: + explicit CanvasLayerTextureUpdater(PassOwnPtr); + + void paintContents(SkCanvas*, const IntRect& contentRect, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, CCRenderingStats&); + const IntRect& contentRect() const { return m_contentRect; } + +private: + IntRect m_contentRect; + OwnPtr m_painter; +}; + +} // namespace cc +#endif // USE(ACCELERATED_COMPOSITING) +#endif // CanvasLayerTextureUpdater_h diff --git a/cc/cc.gyp b/cc/cc.gyp index 264021ef74509b..be5b9608049190 100644 --- a/cc/cc.gyp +++ b/cc/cc.gyp @@ -11,220 +11,220 @@ 'own_ptr_vector.h', 'scoped_ptr_hash_map.h', 'scoped_ptr_vector.h', - 'BitmapCanvasLayerTextureUpdater.cpp', + 'bitmap_canvas_layer_texture_updater.cc', 'BitmapCanvasLayerTextureUpdater.h', - 'BitmapSkPictureCanvasLayerTextureUpdater.cpp', + 'bitmap_skpicture_canvas_layer_texture_updater.cc', 'BitmapSkPictureCanvasLayerTextureUpdater.h', 'caching_bitmap_canvas_layer_texture_updater.cc', 'caching_bitmap_canvas_layer_texture_updater.h', - 'CCActiveAnimation.cpp', + 'active_animation.cc', 'CCActiveAnimation.h', 'CCAppendQuadsData.h', - 'CCAnimationCurve.cpp', + 'animation_curve.cc', 'CCAnimationCurve.h', 'CCAnimationEvents.h', - 'CCCheckerboardDrawQuad.cpp', + 'checkerboard_draw_quad.cc', 'CCCheckerboardDrawQuad.h', 'CCCompletionEvent.h', - 'CCDamageTracker.cpp', + 'damage_tracker.cc', 'CCDamageTracker.h', - 'CCDebugBorderDrawQuad.cpp', + 'debug_border_draw_quad.cc', 'CCDebugBorderDrawQuad.h', - 'CCDebugRectHistory.cpp', + 'debug_rect_history.cc', 'CCDebugRectHistory.h', - 'CCDelayBasedTimeSource.cpp', + 'delay_based_time_source.cc', 'CCDelayBasedTimeSource.h', - 'CCDelegatedRendererLayerImpl.cpp', + 'delegated_renderer_layer_impl.cc', 'CCDelegatedRendererLayerImpl.h', - 'CCDirectRenderer.cpp', + 'direct_renderer.cc', 'CCDirectRenderer.h', - 'CCDrawQuad.cpp', + 'draw_quad.cc', 'CCDrawQuad.h', - 'CCFontAtlas.cpp', + 'font_atlas.cc', 'CCFontAtlas.h', - 'CCFrameRateController.cpp', + 'frame_rate_controller.cc', 'CCFrameRateController.h', - 'CCFrameRateCounter.cpp', + 'frame_rate_counter.cc', 'CCFrameRateCounter.h', 'CCGraphicsContext.h', - 'CCHeadsUpDisplayLayerImpl.cpp', + 'heads_up_display_layer_impl.cc', 'CCHeadsUpDisplayLayerImpl.h', - 'CCIOSurfaceDrawQuad.cpp', + 'io_surface_draw_quad.cc', 'CCIOSurfaceDrawQuad.h', - 'CCIOSurfaceLayerImpl.cpp', + 'io_surface_layer_impl.cc', 'CCIOSurfaceLayerImpl.h', 'CCInputHandler.h', - 'CCKeyframedAnimationCurve.cpp', + 'keyframed_animation_curve.cc', 'CCKeyframedAnimationCurve.h', - 'CCLayerAnimationController.cpp', + 'layer_animation_controller.cc', 'CCLayerAnimationController.h', - 'CCLayerImpl.cpp', + 'layer_impl.cc', 'CCLayerImpl.h', - 'CCLayerIterator.cpp', + 'layer_iterator.cc', 'CCLayerIterator.h', - 'CCLayerQuad.cpp', + 'layer_quad.cc', 'CCLayerQuad.h', - 'CCLayerSorter.cpp', + 'layer_sorter.cc', 'CCLayerSorter.h', - 'CCLayerTilingData.cpp', + 'layer_tiling_data.cc', 'CCLayerTilingData.h', - 'CCLayerTreeHost.cpp', + 'layer_tree_host.cc', 'CCLayerTreeHost.h', 'CCLayerTreeHostClient.h', - 'CCLayerTreeHostCommon.cpp', + 'layer_tree_host_common.cc', 'CCLayerTreeHostCommon.h', - 'CCLayerTreeHostImpl.cpp', + 'layer_tree_host_impl.cc', 'CCLayerTreeHostImpl.h', - 'CCMathUtil.cpp', + 'math_util.cc', 'CCMathUtil.h', - 'CCOcclusionTracker.cpp', + 'occlusion_tracker.cc', 'CCOcclusionTracker.h', - 'CCOverdrawMetrics.cpp', + 'overdraw_metrics.cc', 'CCOverdrawMetrics.h', - 'CCPageScaleAnimation.cpp', + 'page_scale_animation.cc', 'CCPageScaleAnimation.h', - 'CCPrioritizedTexture.cpp', + 'prioritized_texture.cc', 'CCPrioritizedTexture.h', - 'CCPrioritizedTextureManager.cpp', + 'prioritized_texture_manager.cc', 'CCPrioritizedTextureManager.h', - 'CCPriorityCalculator.cpp', + 'priority_calculator.cc', 'CCPriorityCalculator.h', - 'CCProxy.cpp', + 'proxy.cc', 'CCProxy.h', - 'CCQuadCuller.cpp', + 'quad_culler.cc', 'CCQuadCuller.h', 'CCQuadSink.h', - 'CCRenderPass.cpp', + 'render_pass.cc', 'CCRenderPass.h', - 'CCRenderPassDrawQuad.cpp', + 'render_pass_draw_quad.cc', 'CCRenderPassDrawQuad.h', 'CCRenderPassSink.h', - 'CCRenderSurface.cpp', + 'render_surface_impl.cc', 'CCRenderSurface.h', - 'CCRenderSurfaceFilters.cpp', + 'render_surface_filters.cc', 'CCRenderSurfaceFilters.h', - 'CCRenderer.cpp', + 'renderer.cc', 'CCRenderer.h', - 'CCRendererGL.cpp', + 'gl_renderer.cc', 'CCRendererGL.h', - 'CCRendererSoftware.cpp', + 'software_renderer.cc', 'CCRendererSoftware.h', 'CCRenderingStats.h', - 'CCResourceProvider.cpp', + 'resource_provider.cc', 'CCResourceProvider.h', - 'CCScheduler.cpp', + 'scheduler.cc', 'CCScheduler.h', - 'CCSchedulerStateMachine.cpp', + 'scheduler_state_machine.cc', 'CCSchedulerStateMachine.h', - 'CCScopedTexture.cpp', + 'scoped_texture.cc', 'CCScopedTexture.h', - 'CCScopedThreadProxy.cpp', + 'scoped_thread_proxy.cc', 'CCScopedThreadProxy.h', - 'CCScrollbarAnimationController.cpp', + 'scrollbar_animation_controller.cc', 'CCScrollbarAnimationController.h', - 'CCScrollbarAnimationControllerLinearFade.cpp', + 'scrollbar_animation_controller_linear_fade.cc', 'CCScrollbarAnimationControllerLinearFade.h', - 'CCScrollbarLayerImpl.cpp', + 'scrollbar_layer_impl.cc', 'CCScrollbarLayerImpl.h', - 'CCScrollbarGeometryFixedThumb.cpp', + 'scrollbar_geometry_fixed_thumb.cc', 'CCScrollbarGeometryFixedThumb.h', - 'CCScrollbarGeometryStub.cpp', + 'scrollbar_geometry_stub.cc', 'CCScrollbarGeometryStub.h', - 'CCSettings.cpp', + 'settings.cc', 'CCSettings.h', - 'CCSharedQuadState.cpp', + 'shared_quad_state.cc', 'CCSharedQuadState.h', - 'CCSingleThreadProxy.cpp', + 'single_thread_proxy.cc', 'CCSingleThreadProxy.h', - 'CCSolidColorDrawQuad.cpp', + 'solid_color_draw_quad.cc', 'CCSolidColorDrawQuad.h', - 'CCSolidColorLayerImpl.cpp', + 'solid_color_layer_impl.cc', 'CCSolidColorLayerImpl.h', - 'CCStreamVideoDrawQuad.cpp', + 'stream_video_draw_quad.cc', 'CCStreamVideoDrawQuad.h', - 'CCTexture.cpp', + 'texture.cc', 'CCTexture.h', - 'CCTextureDrawQuad.cpp', + 'texture_draw_quad.cc', 'CCTextureDrawQuad.h', - 'CCTextureLayerImpl.cpp', + 'texture_layer_impl.cc', 'CCTextureLayerImpl.h', - 'CCTextureUpdateController.cpp', + 'texture_update_controller.cc', 'CCTextureUpdateController.h', - 'CCTextureUpdateQueue.cpp', + 'texture_update_queue.cc', 'CCTextureUpdateQueue.h', 'CCThread.h', - 'CCThreadProxy.cpp', + 'thread_proxy.cc', 'CCThreadProxy.h', 'CCThreadTask.h', - 'CCTileDrawQuad.cpp', + 'tile_draw_quad.cc', 'CCTileDrawQuad.h', - 'CCTiledLayerImpl.cpp', + 'tiled_layer_impl.cc', 'CCTiledLayerImpl.h', 'CCTimeSource.h', - 'CCTimer.cpp', + 'timer.cc', 'CCTimer.h', - 'CCTimingFunction.cpp', + 'timing_function.cc', 'CCTimingFunction.h', - 'CCVideoLayerImpl.cpp', + 'video_layer_impl.cc', 'CCVideoLayerImpl.h', - 'CCYUVVideoDrawQuad.cpp', + 'yuv_video_draw_quad.cc', 'CCYUVVideoDrawQuad.h', - 'CanvasLayerTextureUpdater.cpp', + 'canvas_layer_texture_updater.cc', 'CanvasLayerTextureUpdater.h', - 'ContentLayerChromium.cpp', + 'content_layer.cc', 'ContentLayerChromium.h', 'ContentLayerChromiumClient.h', - 'DelegatedRendererLayerChromium.cpp', + 'delegated_renderer_layer.cc', 'DelegatedRendererLayerChromium.h', - 'FrameBufferSkPictureCanvasLayerTextureUpdater.cpp', + 'frame_buffer_skpicture_canvas_layer_texture_updater.cc', 'FrameBufferSkPictureCanvasLayerTextureUpdater.h', - 'GeometryBinding.cpp', + 'geometry_binding.cc', 'GeometryBinding.h', - 'HeadsUpDisplayLayerChromium.cpp', + 'heads_up_display_layer.cc', 'HeadsUpDisplayLayerChromium.h', - 'IOSurfaceLayerChromium.cpp', + 'io_surface_layer.cc', 'IOSurfaceLayerChromium.h', - 'ImageLayerChromium.cpp', + 'image_layer.cc', 'ImageLayerChromium.h', - 'LayerChromium.cpp', + 'layer.cc', 'LayerChromium.h', 'LayerPainterChromium.h', - 'LayerTextureSubImage.cpp', + 'layer_texture_sub_image.cc', 'LayerTextureSubImage.h', - 'LayerTextureUpdater.cpp', + 'layer_texture_updater.cc', 'LayerTextureUpdater.h', 'PlatformColor.h', - 'ProgramBinding.cpp', + 'program_binding.cc', 'ProgramBinding.h', - 'RateLimiter.cpp', + 'rate_limiter.cc', 'RateLimiter.h', - 'RenderSurfaceChromium.cpp', + 'render_surface.cc', 'RenderSurfaceChromium.h', - 'ScrollbarLayerChromium.cpp', + 'scrollbar_layer.cc', 'ScrollbarLayerChromium.h', - 'ShaderChromium.cpp', + 'shader.cc', 'ShaderChromium.h', - 'SkPictureCanvasLayerTextureUpdater.cpp', + 'skpicture_canvas_layer_texture_updater.cc', 'SkPictureCanvasLayerTextureUpdater.h', - 'SolidColorLayerChromium.cpp', + 'solid_color_layer.cc', 'SolidColorLayerChromium.h', 'switches.cc', 'switches.h', - 'TextureCopier.cpp', + 'texture_copier.cc', 'TextureCopier.h', - 'TextureLayerChromium.cpp', + 'texture_layer.cc', 'TextureLayerChromium.h', 'TextureLayerChromiumClient.h', 'TextureUploader.h', - 'ThrottledTextureUploader.cpp', + 'throttled_texture_uploader.cc', 'ThrottledTextureUploader.h', - 'UnthrottledTextureUploader.cpp', + 'unthrottled_texture_uploader.cc', 'UnthrottledTextureUploader.h', - 'TiledLayerChromium.cpp', + 'tiled_layer.cc', 'TiledLayerChromium.h', - 'TreeSynchronizer.cpp', + 'tree_synchronizer.cc', 'TreeSynchronizer.h', - 'VideoLayerChromium.cpp', + 'video_layer.cc', 'VideoLayerChromium.h', 'bitmap_canvas_layer_texture_updater.h', diff --git a/cc/CCCheckerboardDrawQuad.cpp b/cc/checkerboard_draw_quad.cc similarity index 100% rename from cc/CCCheckerboardDrawQuad.cpp rename to cc/checkerboard_draw_quad.cc diff --git a/cc/checkerboard_draw_quad.h b/cc/checkerboard_draw_quad.h index 638cbb270ce9b2..1ef147f3b4fb17 100644 --- a/cc/checkerboard_draw_quad.h +++ b/cc/checkerboard_draw_quad.h @@ -1,3 +1,33 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCCheckerboardDrawQuad_h +#define CCCheckerboardDrawQuad_h + +#include "CCDrawQuad.h" +#include "base/memory/scoped_ptr.h" +#include "SkColor.h" + +namespace cc { + +#pragma pack(push, 4) + +class CCCheckerboardDrawQuad : public CCDrawQuad { +public: + static scoped_ptr create(const CCSharedQuadState*, const IntRect&, SkColor); + + SkColor color() const { return m_color; }; + + static const CCCheckerboardDrawQuad* materialCast(const CCDrawQuad*); +private: + CCCheckerboardDrawQuad(const CCSharedQuadState*, const IntRect&, SkColor); + + SkColor m_color; +}; + +#pragma pack(pop) + +} + +#endif diff --git a/cc/completion_event.h b/cc/completion_event.h index 638cbb270ce9b2..462e4ba12f6885 100644 --- a/cc/completion_event.h +++ b/cc/completion_event.h @@ -1,3 +1,62 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCCompletionEvent_h +#define CCCompletionEvent_h + +#include "base/synchronization/waitable_event.h" + +namespace cc { + +// Used for making blocking calls from one thread to another. Use only when +// absolutely certain that doing-so will not lead to a deadlock. +// +// It is safe to destroy this object as soon as wait() returns. +class CCCompletionEvent { +public: + CCCompletionEvent() + : m_event(false /* manual_reset */, false /* initially_signaled */) + { +#ifndef NDEBUG + m_waited = false; + m_signaled = false; +#endif + } + + ~CCCompletionEvent() + { + ASSERT(m_waited); + ASSERT(m_signaled); + } + + void wait() + { + ASSERT(!m_waited); +#ifndef NDEBUG + m_waited = true; +#endif + m_event.Wait(); + } + + void signal() + { + ASSERT(!m_signaled); +#ifndef NDEBUG + m_signaled = true; +#endif + m_event.Signal(); + } + +private: + base::WaitableEvent m_event; +#ifndef NDEBUG + // Used to assert that wait() and signal() are each called exactly once. + bool m_waited; + bool m_signaled; +#endif +}; + +} + +#endif diff --git a/cc/ContentLayerChromium.cpp b/cc/content_layer.cc similarity index 100% rename from cc/ContentLayerChromium.cpp rename to cc/content_layer.cc diff --git a/cc/content_layer.h b/cc/content_layer.h index 638cbb270ce9b2..b8ac4627bf9b7d 100644 --- a/cc/content_layer.h +++ b/cc/content_layer.h @@ -1,3 +1,67 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2010 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef ContentLayerChromium_h +#define ContentLayerChromium_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "base/basictypes.h" +#include "LayerPainterChromium.h" +#include "TiledLayerChromium.h" + +class SkCanvas; + +namespace cc { + +class ContentLayerChromiumClient; +class FloatRect; +class IntRect; +class LayerTextureUpdater; + +class ContentLayerPainter : public LayerPainterChromium { +public: + static PassOwnPtr create(ContentLayerChromiumClient*); + + virtual void paint(SkCanvas*, const IntRect& contentRect, FloatRect& opaque) OVERRIDE; + +private: + explicit ContentLayerPainter(ContentLayerChromiumClient*); + + ContentLayerChromiumClient* m_client; + + DISALLOW_COPY_AND_ASSIGN(ContentLayerPainter); +}; + +// A layer that renders its contents into an SkCanvas. +class ContentLayerChromium : public TiledLayerChromium { +public: + static scoped_refptr create(ContentLayerChromiumClient*); + + void clearClient() { m_client = 0; } + + virtual bool drawsContent() const OVERRIDE; + virtual void setTexturePriorities(const CCPriorityCalculator&) OVERRIDE; + virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) OVERRIDE; + virtual bool needMoreUpdates() OVERRIDE; + + virtual void setContentsOpaque(bool) OVERRIDE; + +protected: + explicit ContentLayerChromium(ContentLayerChromiumClient*); + virtual ~ContentLayerChromium(); + +private: + virtual LayerTextureUpdater* textureUpdater() const OVERRIDE; + virtual void createTextureUpdaterIfNeeded() OVERRIDE; + + ContentLayerChromiumClient* m_client; + RefPtr m_textureUpdater; +}; + +} +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/content_layer_client.h b/cc/content_layer_client.h index 638cbb270ce9b2..54a92673def9aa 100644 --- a/cc/content_layer_client.h +++ b/cc/content_layer_client.h @@ -1,3 +1,24 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef ContentLayerChromiumClient_h +#define ContentLayerChromiumClient_h + +class SkCanvas; + +namespace cc { +class FloatRect; +class IntRect; + +class ContentLayerChromiumClient { +public: + virtual void paintContents(SkCanvas*, const IntRect& clip, FloatRect& opaque) = 0; + +protected: + virtual ~ContentLayerChromiumClient() { } +}; + +} + +#endif // ContentLayerChromiumClient_h diff --git a/cc/CCDamageTracker.cpp b/cc/damage_tracker.cc similarity index 100% rename from cc/CCDamageTracker.cpp rename to cc/damage_tracker.cc diff --git a/cc/damage_tracker.h b/cc/damage_tracker.h index 638cbb270ce9b2..c7550a26ba32b2 100644 --- a/cc/damage_tracker.h +++ b/cc/damage_tracker.h @@ -1,3 +1,63 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCDamageTracker_h +#define CCDamageTracker_h + +#include "base/memory/scoped_ptr.h" +#include "FloatRect.h" +#include +#include +#include + +namespace WebKit { +class WebFilterOperations; +} + +namespace cc { + +class CCLayerImpl; +class CCRenderSurface; + +// Computes the region where pixels have actually changed on a RenderSurface. This region is used +// to scissor what is actually drawn to the screen to save GPU computation and bandwidth. +class CCDamageTracker { +public: + static scoped_ptr create(); + ~CCDamageTracker(); + + void didDrawDamagedArea() { m_currentDamageRect = FloatRect(); } + void forceFullDamageNextUpdate() { m_forceFullDamageNextUpdate = true; } + void updateDamageTrackingState(const std::vector& layerList, int targetSurfaceLayerID, bool targetSurfacePropertyChangedOnlyFromDescendant, const IntRect& targetSurfaceContentRect, CCLayerImpl* targetSurfaceMaskLayer, const WebKit::WebFilterOperations&); + + const FloatRect& currentDamageRect() { return m_currentDamageRect; } + +private: + CCDamageTracker(); + + FloatRect trackDamageFromActiveLayers(const std::vector& layerList, int targetSurfaceLayerID); + FloatRect trackDamageFromSurfaceMask(CCLayerImpl* targetSurfaceMaskLayer); + FloatRect trackDamageFromLeftoverRects(); + + FloatRect removeRectFromCurrentFrame(int layerID, bool& layerIsNew); + void saveRectForNextFrame(int layerID, const FloatRect& targetSpaceRect); + + // These helper functions are used only in trackDamageFromActiveLayers(). + void extendDamageForLayer(CCLayerImpl*, FloatRect& targetDamageRect); + void extendDamageForRenderSurface(CCLayerImpl*, FloatRect& targetDamageRect); + + // To correctly track exposed regions, two hashtables of rects are maintained. + // The "current" map is used to compute exposed regions of the current frame, while + // the "next" map is used to collect layer rects that are used in the next frame. + typedef HashMap RectMap; + scoped_ptr m_currentRectHistory; + scoped_ptr m_nextRectHistory; + + FloatRect m_currentDamageRect; + bool m_forceFullDamageNextUpdate; +}; + +} // namespace cc + +#endif // CCDamageTracker_h diff --git a/cc/CCDebugBorderDrawQuad.cpp b/cc/debug_border_draw_quad.cc similarity index 100% rename from cc/CCDebugBorderDrawQuad.cpp rename to cc/debug_border_draw_quad.cc diff --git a/cc/debug_border_draw_quad.h b/cc/debug_border_draw_quad.h index 638cbb270ce9b2..fbba1c6bebad18 100644 --- a/cc/debug_border_draw_quad.h +++ b/cc/debug_border_draw_quad.h @@ -1,3 +1,35 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCDebugBorderDrawQuad_h +#define CCDebugBorderDrawQuad_h + +#include "CCDrawQuad.h" +#include "SkColor.h" +#include "base/memory/scoped_ptr.h" + +namespace cc { + +#pragma pack(push, 4) + +class CCDebugBorderDrawQuad : public CCDrawQuad { +public: + static scoped_ptr create(const CCSharedQuadState*, const IntRect&, SkColor, int width); + + SkColor color() const { return m_color; }; + int width() const { return m_width; } + + static const CCDebugBorderDrawQuad* materialCast(const CCDrawQuad*); +private: + CCDebugBorderDrawQuad(const CCSharedQuadState*, const IntRect&, SkColor, int width); + + SkColor m_color; + int m_width; +}; + +#pragma pack(pop) + +} + +#endif diff --git a/cc/CCDebugRectHistory.cpp b/cc/debug_rect_history.cc similarity index 100% rename from cc/CCDebugRectHistory.cpp rename to cc/debug_rect_history.cc diff --git a/cc/debug_rect_history.h b/cc/debug_rect_history.h index 638cbb270ce9b2..1b03f34aa79634 100644 --- a/cc/debug_rect_history.h +++ b/cc/debug_rect_history.h @@ -1,3 +1,87 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCDebugRectHistory_h +#define CCDebugRectHistory_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "base/basictypes.h" +#include "FloatRect.h" +#include "IntRect.h" +#include +#include +#include + +namespace cc { + +class CCLayerImpl; +struct CCLayerTreeSettings; + +// There are currently six types of debug rects: +// +// - Paint rects (update rects): regions of a layer that needed to be re-uploaded to the +// texture resource; in most cases implying that they had to be repainted, too. +// +// - Property-changed rects: enclosing bounds of layers that cause changes to the screen +// even if the layer did not change internally. (For example, if the layer's opacity or +// position changes.) +// +// - Surface damage rects: the aggregate damage on a target surface that is caused by all +// layers and surfaces that contribute to it. This includes (1) paint rects, (2) property- +// changed rects, and (3) newly exposed areas. +// +// - Screen space rects: this is the region the contents occupy in screen space. +// +// - Replica screen space rects: this is the region the replica's contents occupy in screen space. +// +// - Occluding rects: these are the regions that contribute to the occluded region. +// +enum DebugRectType { PaintRectType, PropertyChangedRectType, SurfaceDamageRectType, ScreenSpaceRectType, ReplicaScreenSpaceRectType, OccludingRectType }; + +struct CCDebugRect { + CCDebugRect(DebugRectType newType, FloatRect newRect) + : type(newType) + , rect(newRect) { } + + DebugRectType type; + FloatRect rect; +}; + +// This class maintains a history of rects of various types that can be used +// for debugging purposes. The overhead of collecting rects is performed only if +// the appropriate CCLayerTreeSettings are enabled. +class CCDebugRectHistory { +public: + static PassOwnPtr create() + { + return adoptPtr(new CCDebugRectHistory()); + } + + ~CCDebugRectHistory(); + + // Note: Saving debug rects must happen before layers' change tracking is reset. + void saveDebugRectsForCurrentFrame(CCLayerImpl* rootLayer, const std::vector& renderSurfaceLayerList, const Vector& occludingScreenSpaceRects, const CCLayerTreeSettings&); + + const Vector& debugRects() { return m_debugRects; } + +private: + CCDebugRectHistory(); + + void savePaintRects(CCLayerImpl*); + void savePropertyChangedRects(const std::vector& renderSurfaceLayerList); + void saveSurfaceDamageRects(const std::vector& renderSurfaceLayerList); + void saveScreenSpaceRects(const std::vector& renderSurfaceLayerList); + void saveOccludingRects(const Vector& occludingScreenSpaceRects); + + Vector m_debugRects; + + DISALLOW_COPY_AND_ASSIGN(CCDebugRectHistory); +}; + +} // namespace cc + +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCDelayBasedTimeSource.cpp b/cc/delay_based_time_source.cc similarity index 100% rename from cc/CCDelayBasedTimeSource.cpp rename to cc/delay_based_time_source.cc diff --git a/cc/delay_based_time_source.h b/cc/delay_based_time_source.h index 638cbb270ce9b2..bf183f7aa7313e 100644 --- a/cc/delay_based_time_source.h +++ b/cc/delay_based_time_source.h @@ -1,3 +1,79 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCDelayBasedTimeSource_h +#define CCDelayBasedTimeSource_h + +#include "CCTimeSource.h" +#include "CCTimer.h" +#include + +namespace cc { + +class CCThread; + +// This timer implements a time source that achieves the specified interval +// in face of millisecond-precision delayed callbacks and random queueing delays. +class CCDelayBasedTimeSource : public CCTimeSource, CCTimerClient { +public: + static PassRefPtr create(base::TimeDelta interval, CCThread*); + + virtual ~CCDelayBasedTimeSource(); + + virtual void setClient(CCTimeSourceClient* client) OVERRIDE; + + // CCTimeSource implementation + virtual void setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval) OVERRIDE; + + virtual void setActive(bool) OVERRIDE; + virtual bool active() const OVERRIDE; + + // Get the last and next tick times. nextTimeTime() returns null when + // inactive. + virtual base::TimeTicks lastTickTime() OVERRIDE; + virtual base::TimeTicks nextTickTime() OVERRIDE; + + // CCTimerClient implementation. + virtual void onTimerFired() OVERRIDE; + + // Virtual for testing. + virtual base::TimeTicks now() const; + +protected: + CCDelayBasedTimeSource(base::TimeDelta interval, CCThread*); + base::TimeTicks nextTickTarget(base::TimeTicks now); + void postNextTickTask(base::TimeTicks now); + + enum State { + STATE_INACTIVE, + STATE_STARTING, + STATE_ACTIVE, + }; + + struct Parameters { + Parameters(base::TimeDelta interval, base::TimeTicks tickTarget) + : interval(interval), tickTarget(tickTarget) + { } + base::TimeDelta interval; + base::TimeTicks tickTarget; + }; + + CCTimeSourceClient* m_client; + bool m_hasTickTarget; + base::TimeTicks m_lastTickTime; + + // m_currentParameters should only be written by postNextTickTask. + // m_nextParameters will take effect on the next call to postNextTickTask. + // Maintaining a pending set of parameters allows nextTickTime() to always + // reflect the actual time we expect onTimerFired to be called. + Parameters m_currentParameters; + Parameters m_nextParameters; + + State m_state; + CCThread* m_thread; + CCTimer m_timer; +}; + +} +#endif // CCDelayBasedTimeSource_h diff --git a/cc/DelegatedRendererLayerChromium.cpp b/cc/delegated_renderer_layer.cc similarity index 100% rename from cc/DelegatedRendererLayerChromium.cpp rename to cc/delegated_renderer_layer.cc diff --git a/cc/delegated_renderer_layer.h b/cc/delegated_renderer_layer.h index 638cbb270ce9b2..c7f8d2c4d72be6 100644 --- a/cc/delegated_renderer_layer.h +++ b/cc/delegated_renderer_layer.h @@ -1,3 +1,26 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef DelegatedRendererLayerChromium_h +#define DelegatedRendererLayerChromium_h + +#include "LayerChromium.h" + +namespace cc { + +class DelegatedRendererLayerChromium : public LayerChromium { +public: + static scoped_refptr create(); + + virtual scoped_ptr createCCLayerImpl() OVERRIDE; + +protected: + DelegatedRendererLayerChromium(); + +private: + virtual ~DelegatedRendererLayerChromium(); +}; + +} +#endif diff --git a/cc/CCDelegatedRendererLayerImpl.cpp b/cc/delegated_renderer_layer_impl.cc similarity index 100% rename from cc/CCDelegatedRendererLayerImpl.cpp rename to cc/delegated_renderer_layer_impl.cc diff --git a/cc/delegated_renderer_layer_impl.h b/cc/delegated_renderer_layer_impl.h index 638cbb270ce9b2..4ed842e560145d 100644 --- a/cc/delegated_renderer_layer_impl.h +++ b/cc/delegated_renderer_layer_impl.h @@ -1,3 +1,50 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCDelegatedRendererLayerImpl_h +#define CCDelegatedRendererLayerImpl_h + +#include "CCLayerImpl.h" +#include "cc/scoped_ptr_vector.h" + +namespace cc { + +class CCDelegatedRendererLayerImpl : public CCLayerImpl { +public: + static scoped_ptr create(int id) { return make_scoped_ptr(new CCDelegatedRendererLayerImpl(id)); } + virtual ~CCDelegatedRendererLayerImpl(); + + virtual bool descendantDrawsContent() OVERRIDE; + virtual bool hasContributingDelegatedRenderPasses() const OVERRIDE; + + // This gives ownership of the RenderPasses to the layer. + void setRenderPasses(ScopedPtrVector&); + void clearRenderPasses(); + + virtual void didLoseContext() OVERRIDE; + + virtual CCRenderPass::Id firstContributingRenderPassId() const OVERRIDE; + virtual CCRenderPass::Id nextContributingRenderPassId(CCRenderPass::Id) const OVERRIDE; + + void appendContributingRenderPasses(CCRenderPassSink&); + virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; + +private: + explicit CCDelegatedRendererLayerImpl(int); + + CCRenderPass::Id convertDelegatedRenderPassId(CCRenderPass::Id delegatedRenderPassId) const; + + void appendRenderPassQuads(CCQuadSink&, CCAppendQuadsData&, CCRenderPass* fromDelegatedRenderPass) const; + + PassOwnPtr createCopyOfQuad(const CCDrawQuad*); + + virtual const char* layerTypeAsString() const OVERRIDE; + + ScopedPtrVector m_renderPassesInDrawOrder; + base::hash_map m_renderPassesIndexById; +}; + +} + +#endif // CCDelegatedRendererLayerImpl_h diff --git a/cc/CCDirectRenderer.cpp b/cc/direct_renderer.cc similarity index 100% rename from cc/CCDirectRenderer.cpp rename to cc/direct_renderer.cc diff --git a/cc/direct_renderer.h b/cc/direct_renderer.h index 638cbb270ce9b2..73e6dc685377a5 100644 --- a/cc/direct_renderer.h +++ b/cc/direct_renderer.h @@ -1,3 +1,105 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCDirectRenderer_h +#define CCDirectRenderer_h + +#include "base/basictypes.h" +#include "CCRenderer.h" +#include "CCResourceProvider.h" +#include "CCScopedTexture.h" + +namespace cc { + +class CCResourceProvider; + +// This is the base class for code shared between the GL and software +// renderer implementations. "Direct" refers to the fact that it does not +// delegate rendering to another compositor. +class CCDirectRenderer : public CCRenderer { +public: + virtual ~CCDirectRenderer(); + + CCResourceProvider* resourceProvider() const { return m_resourceProvider; } + + virtual void decideRenderPassAllocationsForFrame(const CCRenderPassList& renderPassesInDrawOrder) OVERRIDE; + virtual bool haveCachedResourcesForRenderPassId(CCRenderPass::Id) const OVERRIDE; + virtual void drawFrame(const CCRenderPassList& renderPassesInDrawOrder, const CCRenderPassIdHashMap& renderPassesById) OVERRIDE; + +protected: + CCDirectRenderer(CCRendererClient* client, CCResourceProvider* resourceProvider); + + struct DrawingFrame { + DrawingFrame(); + ~DrawingFrame(); + + const CCRenderPassIdHashMap* renderPassesById; + const CCRenderPass* rootRenderPass; + const CCRenderPass* currentRenderPass; + const CCScopedTexture* currentTexture; + + FloatRect rootDamageRect; + + WebKit::WebTransformationMatrix projectionMatrix; + WebKit::WebTransformationMatrix windowMatrix; + bool flippedY; + FloatRect scissorRectInRenderPassSpace; + }; + + class CachedTexture : public CCScopedTexture { + public: + static scoped_ptr create(CCResourceProvider* resourceProvider) { + return make_scoped_ptr(new CachedTexture(resourceProvider)); + } + virtual ~CachedTexture() {} + + bool isComplete() const { return m_isComplete; } + void setIsComplete(bool isComplete) { m_isComplete = isComplete; } + + protected: + explicit CachedTexture(CCResourceProvider* resourceProvider) + : CCScopedTexture(resourceProvider) + , m_isComplete(false) + { + } + + private: + bool m_isComplete; + + DISALLOW_COPY_AND_ASSIGN(CachedTexture); + }; + + static FloatRect quadVertexRect(); + static void quadRectTransform(WebKit::WebTransformationMatrix* quadRectTransform, const WebKit::WebTransformationMatrix& quadTransform, const FloatRect& quadRect); + static void initializeMatrices(DrawingFrame&, const IntRect& drawRect, bool flipY); + static IntRect moveScissorToWindowSpace(const DrawingFrame&, FloatRect scissorRect); + + bool haveCachedResources(CCRenderPass::Id) const; + static IntSize renderPassTextureSize(const CCRenderPass*); + static GC3Denum renderPassTextureFormat(const CCRenderPass*); + + void drawRenderPass(DrawingFrame&, const CCRenderPass*); + bool useRenderPass(DrawingFrame&, const CCRenderPass*); + + virtual void bindFramebufferToOutputSurface(DrawingFrame&) = 0; + virtual bool bindFramebufferToTexture(DrawingFrame&, const CCScopedTexture*, const IntRect& framebufferRect) = 0; + virtual void setDrawViewportSize(const IntSize&) = 0; + virtual void enableScissorTestRect(const IntRect& scissorRect) = 0; + virtual void disableScissorTest() = 0; + virtual void clearFramebuffer(DrawingFrame&) = 0; + virtual void drawQuad(DrawingFrame&, const CCDrawQuad*) = 0; + virtual void beginDrawingFrame(DrawingFrame&) = 0; + virtual void finishDrawingFrame(DrawingFrame&) = 0; + virtual bool flippedFramebuffer() const = 0; + + ScopedPtrHashMap m_renderPassTextures; + CCResourceProvider* m_resourceProvider; + +private: + DISALLOW_COPY_AND_ASSIGN(CCDirectRenderer); +}; + +} // namespace cc + +#endif // CCDirectRenderer_h diff --git a/cc/CCDrawQuad.cpp b/cc/draw_quad.cc similarity index 100% rename from cc/CCDrawQuad.cpp rename to cc/draw_quad.cc diff --git a/cc/draw_quad.h b/cc/draw_quad.h index 638cbb270ce9b2..05a69065468192 100644 --- a/cc/draw_quad.h +++ b/cc/draw_quad.h @@ -1,3 +1,96 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCDrawQuad_h +#define CCDrawQuad_h + +#include "CCSharedQuadState.h" + +namespace cc { + +// WARNING! All CCXYZDrawQuad classes must remain PODs (plain old data). +// They are intended to be "serializable" by copying their raw bytes, so they +// must not contain any non-bit-copyable member variables! +// +// Furthermore, the class members need to be packed so they are aligned +// properly and don't have paddings/gaps, otherwise memory check tools +// like Valgrind will complain about uninitialized memory usage when +// transferring these classes over the wire. +#pragma pack(push, 4) + +// CCDrawQuad is a bag of data used for drawing a quad. Because different +// materials need different bits of per-quad data to render, classes that derive +// from CCDrawQuad store additional data in their derived instance. The Material +// enum is used to "safely" downcast to the derived class. +class CCDrawQuad { +public: + enum Material { + Invalid, + Checkerboard, + DebugBorder, + IOSurfaceContent, + RenderPass, + TextureContent, + SolidColor, + TiledContent, + YUVVideoContent, + StreamVideoContent, + }; + + IntRect quadRect() const { return m_quadRect; } + const WebKit::WebTransformationMatrix& quadTransform() const { return m_sharedQuadState->quadTransform; } + IntRect visibleContentRect() const { return m_sharedQuadState->visibleContentRect; } + IntRect clippedRectInTarget() const { return m_sharedQuadState->clippedRectInTarget; } + float opacity() const { return m_sharedQuadState->opacity; } + // For the purposes of blending, what part of the contents of this quad are opaque? + IntRect opaqueRect() const; + bool needsBlending() const { return m_needsBlending || !opaqueRect().contains(m_quadVisibleRect); } + + // Allows changing the rect that gets drawn to make it smaller. Parameter passed + // in will be clipped to quadRect(). + void setQuadVisibleRect(const IntRect&); + IntRect quadVisibleRect() const { return m_quadVisibleRect; } + bool isDebugQuad() const { return m_material == DebugBorder; } + + Material material() const { return m_material; } + + // Returns transfer size of this object based on the derived class (by + // looking at the material type). + unsigned size() const; + + scoped_ptr copy(const CCSharedQuadState* copiedSharedQuadState) const; + + const CCSharedQuadState* sharedQuadState() const { return m_sharedQuadState; } + int sharedQuadStateId() const { return m_sharedQuadStateId; } + void setSharedQuadState(const CCSharedQuadState*); + +protected: + CCDrawQuad(const CCSharedQuadState*, Material, const IntRect&); + + // Stores state common to a large bundle of quads; kept separate for memory + // efficiency. There is special treatment to reconstruct these pointers + // during serialization. + const CCSharedQuadState* m_sharedQuadState; + int m_sharedQuadStateId; + + Material m_material; + IntRect m_quadRect; + IntRect m_quadVisibleRect; + + // By default, the shared quad state determines whether or not this quad is + // opaque or needs blending. Derived classes can override with these + // variables. + bool m_quadOpaque; + bool m_needsBlending; + + // Be default, this rect is empty. It is used when the shared quad state and above + // variables determine that the quad is not fully opaque but may be partially opaque. + IntRect m_opaqueRect; +}; + +#pragma pack(pop) + +} + +#endif diff --git a/cc/CCFontAtlas.cpp b/cc/font_atlas.cc similarity index 100% rename from cc/CCFontAtlas.cpp rename to cc/font_atlas.cc diff --git a/cc/font_atlas.h b/cc/font_atlas.h index 638cbb270ce9b2..2881ee9a55abc9 100644 --- a/cc/font_atlas.h +++ b/cc/font_atlas.h @@ -1,3 +1,70 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCFontAtlas_h +#define CCFontAtlas_h + +#if USE(ACCELERATED_COMPOSITING) + +#include + +#include "base/basictypes.h" +#include "base/memory/scoped_ptr.h" +#include "IntRect.h" +#include "SkBitmap.h" + +class SkCanvas; + +namespace gfx { +class Point; +} + +namespace cc { + +class Color; +class FontDescription; +class GraphicsContext; +class IntSize; + +// This class provides basic ability to draw text onto the heads-up display. +class CCFontAtlas { +public: + static scoped_ptr create(SkBitmap bitmap, IntRect asciiToRectTable[128], int fontHeight) + { + return make_scoped_ptr(new CCFontAtlas(bitmap, asciiToRectTable, fontHeight)); + } + ~CCFontAtlas(); + + // Draws multiple lines of text where each line of text is separated by '\n'. + // - Correct glyphs will be drawn for ASCII codes in the range 32-127; any characters + // outside that range will be displayed as a default rectangle glyph. + // - IntSize clip is used to avoid wasting time drawing things that are outside the + // target canvas bounds. + // - Should only be called only on the impl thread. + void drawText(SkCanvas*, const SkPaint&, const std::string& text, const gfx::Point& destPosition, const IntSize& clip) const; + + // Draws the entire atlas at the specified position, just for debugging purposes. + void drawDebugAtlas(SkCanvas*, const gfx::Point& destPosition) const; + +private: + CCFontAtlas(SkBitmap, IntRect asciiToRectTable[128], int fontHeight); + + void drawOneLineOfTextInternal(SkCanvas*, const SkPaint&, const std::string&, const gfx::Point& destPosition) const; + + // The actual texture atlas containing all the pre-rendered glyphs. + SkBitmap m_atlas; + + // The look-up tables mapping ascii characters to their IntRect locations on the atlas. + IntRect m_asciiToRectTable[128]; + + int m_fontHeight; + + DISALLOW_COPY_AND_ASSIGN(CCFontAtlas); +}; + +} // namespace cc + +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/FrameBufferSkPictureCanvasLayerTextureUpdater.cpp b/cc/frame_buffer_skpicture_canvas_layer_texture_updater.cc similarity index 100% rename from cc/FrameBufferSkPictureCanvasLayerTextureUpdater.cpp rename to cc/frame_buffer_skpicture_canvas_layer_texture_updater.cc diff --git a/cc/frame_buffer_skpicture_canvas_layer_texture_updater.h b/cc/frame_buffer_skpicture_canvas_layer_texture_updater.h index 638cbb270ce9b2..79093f2f1de063 100644 --- a/cc/frame_buffer_skpicture_canvas_layer_texture_updater.h +++ b/cc/frame_buffer_skpicture_canvas_layer_texture_updater.h @@ -1,3 +1,52 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef FrameBufferSkPictureCanvasLayerTextureUpdater_h +#define FrameBufferSkPictureCanvasLayerTextureUpdater_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "SkPictureCanvasLayerTextureUpdater.h" + +class GrContext; + +namespace WebKit { +class WebGraphicsContext3D; +class WebSharedGraphicsContext3D; +} + +namespace cc { + +// This class records the contentRect into an SkPicture, then uses accelerated +// drawing to update the texture. The accelerated drawing goes to an +// intermediate framebuffer and then is copied to the destination texture once done. +class FrameBufferSkPictureCanvasLayerTextureUpdater : public SkPictureCanvasLayerTextureUpdater { +public: + class Texture : public LayerTextureUpdater::Texture { + public: + Texture(FrameBufferSkPictureCanvasLayerTextureUpdater*, scoped_ptr); + virtual ~Texture(); + + virtual void updateRect(CCResourceProvider*, const IntRect& sourceRect, const IntSize& destOffset) OVERRIDE; + + private: + FrameBufferSkPictureCanvasLayerTextureUpdater* textureUpdater() { return m_textureUpdater; } + + FrameBufferSkPictureCanvasLayerTextureUpdater* m_textureUpdater; + }; + + static PassRefPtr create(PassOwnPtr); + virtual ~FrameBufferSkPictureCanvasLayerTextureUpdater(); + + virtual PassOwnPtr createTexture(CCPrioritizedTextureManager*) OVERRIDE; + virtual SampledTexelFormat sampledTexelFormat(GC3Denum textureFormat) OVERRIDE; + void updateTextureRect(WebKit::WebGraphicsContext3D*, GrContext*, CCResourceProvider*, CCPrioritizedTexture*, const IntRect& sourceRect, const IntSize& destOffset); + +private: + explicit FrameBufferSkPictureCanvasLayerTextureUpdater(PassOwnPtr); +}; +} // namespace cc +#endif // USE(ACCELERATED_COMPOSITING) +#endif // FrameBufferSkPictureCanvasLayerTextureUpdater_h diff --git a/cc/CCFrameRateController.cpp b/cc/frame_rate_controller.cc similarity index 100% rename from cc/CCFrameRateController.cpp rename to cc/frame_rate_controller.cc diff --git a/cc/frame_rate_controller.h b/cc/frame_rate_controller.h index 638cbb270ce9b2..2aeeae156d6580 100644 --- a/cc/frame_rate_controller.h +++ b/cc/frame_rate_controller.h @@ -1,3 +1,82 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCFrameRateController_h +#define CCFrameRateController_h + +#include "base/memory/scoped_ptr.h" +#include "base/time.h" +#include "CCTimer.h" +#include +#include + +namespace cc { + +class CCThread; +class CCTimeSource; + +class CCFrameRateControllerClient { +public: + // Throttled is true when we have a maximum number of frames pending. + virtual void vsyncTick(bool throttled) = 0; + +protected: + virtual ~CCFrameRateControllerClient() {} +}; + +class CCFrameRateControllerTimeSourceAdapter; + +class CCFrameRateController : public CCTimerClient { +public: + explicit CCFrameRateController(PassRefPtr); + // Alternate form of CCFrameRateController with unthrottled frame-rate. + explicit CCFrameRateController(CCThread*); + virtual ~CCFrameRateController(); + + void setClient(CCFrameRateControllerClient* client) { m_client = client; } + + void setActive(bool); + + // Use the following methods to adjust target frame rate. + // + // Multiple frames can be in-progress, but for every didBeginFrame, a + // didFinishFrame should be posted. + // + // If the rendering pipeline crashes, call didAbortAllPendingFrames. + void didBeginFrame(); + void didFinishFrame(); + void didAbortAllPendingFrames(); + void setMaxFramesPending(int); // 0 for unlimited. + + // This returns null for unthrottled frame-rate. + base::TimeTicks nextTickTime(); + + void setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval); + void setSwapBuffersCompleteSupported(bool); + +protected: + friend class CCFrameRateControllerTimeSourceAdapter; + void onTimerTick(); + + void postManualTick(); + + // CCTimerClient implementation (used for unthrottled frame-rate). + virtual void onTimerFired() OVERRIDE; + + CCFrameRateControllerClient* m_client; + int m_numFramesPending; + int m_maxFramesPending; + RefPtr m_timeSource; + scoped_ptr m_timeSourceClientAdapter; + bool m_active; + bool m_swapBuffersCompleteSupported; + + // Members for unthrottled frame-rate. + bool m_isTimeSourceThrottling; + scoped_ptr m_manualTicker; +}; + +} // namespace cc + +#endif // CCFrameRateController_h diff --git a/cc/CCFrameRateCounter.cpp b/cc/frame_rate_counter.cc similarity index 100% rename from cc/CCFrameRateCounter.cpp rename to cc/frame_rate_counter.cc diff --git a/cc/frame_rate_counter.h b/cc/frame_rate_counter.h index 638cbb270ce9b2..76b42242565b74 100644 --- a/cc/frame_rate_counter.h +++ b/cc/frame_rate_counter.h @@ -1,3 +1,72 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCFrameRateCounter_h +#define CCFrameRateCounter_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "base/basictypes.h" +#include + +namespace cc { + +// This class maintains a history of timestamps, and provides functionality to +// intelligently compute average frames per second (and standard deviation). +class CCFrameRateCounter { +public: + static PassOwnPtr create() + { + return adoptPtr(new CCFrameRateCounter()); + } + + void markBeginningOfFrame(double timestamp); + void markEndOfFrame(); + int currentFrameNumber() const { return m_currentFrameNumber; } + void getAverageFPSAndStandardDeviation(double& averageFPS, double& standardDeviation) const; + int timeStampHistorySize() const { return kTimeStampHistorySize; } + + // n = 0 returns the oldest frame retained in the history, + // while n = timeStampHistorySize() - 1 returns the timestamp most recent frame. + double timeStampOfRecentFrame(int /* n */); + + // This is a heuristic that can be used to ignore frames in a reasonable way. Returns + // true if the given frame interval is too fast or too slow, based on constant thresholds. + bool isBadFrameInterval(double intervalBetweenConsecutiveFrames) const; + + int droppedFrameCount() const { return m_droppedFrameCount; } + +private: + CCFrameRateCounter(); + + double frameInterval(int frameNumber) const; + int frameIndex(int frameNumber) const; + bool isBadFrame(int frameNumber) const; + + // Two thresholds (measured in seconds) that describe what is considered to be a "no-op frame" that should not be counted. + // - if the frame is too fast, then given our compositor implementation, the frame probably was a no-op and did not draw. + // - if the frame is too slow, then there is probably not animating content, so we should not pollute the average. + static const double kFrameTooFast; + static const double kFrameTooSlow; + + // If a frame takes longer than this threshold (measured in seconds) then we + // (naively) assume that it missed a screen refresh; that is, we dropped a frame. + // FIXME: Determine this threshold based on monitor refresh rate, crbug.com/138642. + static const double kDroppedFrameTime; + + static const int kTimeStampHistorySize = 120; + + int m_currentFrameNumber; + double m_timeStampHistory[kTimeStampHistorySize]; + + int m_droppedFrameCount; + + DISALLOW_COPY_AND_ASSIGN(CCFrameRateCounter); +}; + +} // namespace cc + +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/GeometryBinding.cpp b/cc/geometry_binding.cc similarity index 100% rename from cc/GeometryBinding.cpp rename to cc/geometry_binding.cc diff --git a/cc/geometry_binding.h b/cc/geometry_binding.h index 638cbb270ce9b2..f0b6e72a6ef561 100644 --- a/cc/geometry_binding.h +++ b/cc/geometry_binding.h @@ -1,3 +1,48 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef GeometryBinding_h +#define GeometryBinding_h + +#include "FloatRect.h" + +#if USE(ACCELERATED_COMPOSITING) + +namespace WebKit { +class WebGraphicsContext3D; +} + +namespace cc { + +class GeometryBinding { +public: + GeometryBinding(WebKit::WebGraphicsContext3D*, const FloatRect& quadVertexRect); + ~GeometryBinding(); + + bool initialized() const { return m_initialized; } + + WebKit::WebGraphicsContext3D* context() const { return m_context; } + unsigned quadVerticesVbo() const { return m_quadVerticesVbo; } + unsigned quadElementsVbo() const { return m_quadElementsVbo; } + + void prepareForDraw(); + + // All layer shaders share the same attribute locations for the vertex + // positions and texture coordinates. This allows switching shaders without + // rebinding attribute arrays. + static int positionAttribLocation() { return 0; } + static int texCoordAttribLocation() { return 1; } + +private: + WebKit::WebGraphicsContext3D* m_context; + unsigned m_quadVerticesVbo; + unsigned m_quadElementsVbo; + bool m_initialized; +}; + +} // namespace cc + +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCRendererGL.cpp b/cc/gl_renderer.cc similarity index 100% rename from cc/CCRendererGL.cpp rename to cc/gl_renderer.cc diff --git a/cc/gl_renderer.h b/cc/gl_renderer.h index 638cbb270ce9b2..a5f2c4f056da0f 100644 --- a/cc/gl_renderer.h +++ b/cc/gl_renderer.h @@ -1,3 +1,240 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2010 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef CCRendererGL_h +#define CCRendererGL_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "base/basictypes.h" +#include "CCCheckerboardDrawQuad.h" +#include "CCDebugBorderDrawQuad.h" +#include "CCDirectRenderer.h" +#include "CCIOSurfaceDrawQuad.h" +#include "CCRenderPassDrawQuad.h" +#include "CCRenderer.h" +#include "CCSolidColorDrawQuad.h" +#include "CCStreamVideoDrawQuad.h" +#include "CCTextureDrawQuad.h" +#include "CCTileDrawQuad.h" +#include "CCYUVVideoDrawQuad.h" +#include "Extensions3DChromium.h" +#include + +namespace WebKit { +class WebGraphicsContext3D; +} + +namespace cc { + +class CCScopedTexture; +class GeometryBinding; +class ScopedEnsureFramebufferAllocation; + +// Class that handles drawing of composited render layers using GL. +class CCRendererGL : public CCDirectRenderer, + public WebKit::WebGraphicsContext3D::WebGraphicsSwapBuffersCompleteCallbackCHROMIUM, + public WebKit::WebGraphicsContext3D::WebGraphicsMemoryAllocationChangedCallbackCHROMIUM , + public WebKit::WebGraphicsContext3D::WebGraphicsContextLostCallback { +public: + static PassOwnPtr create(CCRendererClient*, CCResourceProvider*); + + virtual ~CCRendererGL(); + + virtual const RendererCapabilities& capabilities() const OVERRIDE; + + WebKit::WebGraphicsContext3D* context(); + + virtual void viewportChanged() OVERRIDE; + + const FloatQuad& sharedGeometryQuad() const { return m_sharedGeometryQuad; } + + // waits for rendering to finish + virtual void finish() OVERRIDE; + + virtual void doNoOp() OVERRIDE; + // puts backbuffer onscreen + virtual bool swapBuffers() OVERRIDE; + + static void debugGLCall(WebKit::WebGraphicsContext3D*, const char* command, const char* file, int line); + + const GeometryBinding* sharedGeometry() const { return m_sharedGeometry.get(); } + + virtual void getFramebufferPixels(void *pixels, const IntRect&) OVERRIDE; + bool getFramebufferTexture(CCScopedTexture*, const IntRect& deviceRect); + + virtual bool isContextLost() OVERRIDE; + + virtual void setVisible(bool) OVERRIDE; + +protected: + CCRendererGL(CCRendererClient*, CCResourceProvider*); + + bool isFramebufferDiscarded() const { return m_isFramebufferDiscarded; } + bool initialize(); + + void releaseRenderPassTextures(); + + virtual void bindFramebufferToOutputSurface(DrawingFrame&) OVERRIDE; + virtual bool bindFramebufferToTexture(DrawingFrame&, const CCScopedTexture*, const IntRect& framebufferRect) OVERRIDE; + virtual void setDrawViewportSize(const IntSize&) OVERRIDE; + virtual void enableScissorTestRect(const IntRect& scissorRect) OVERRIDE; + virtual void disableScissorTest() OVERRIDE; + virtual void clearFramebuffer(DrawingFrame&) OVERRIDE; + virtual void drawQuad(DrawingFrame&, const CCDrawQuad*) OVERRIDE; + virtual void beginDrawingFrame(DrawingFrame&) OVERRIDE; + virtual void finishDrawingFrame(DrawingFrame&) OVERRIDE; + virtual bool flippedFramebuffer() const OVERRIDE; + +private: + static void toGLMatrix(float*, const WebKit::WebTransformationMatrix&); + + void drawCheckerboardQuad(const DrawingFrame&, const CCCheckerboardDrawQuad*); + void drawDebugBorderQuad(const DrawingFrame&, const CCDebugBorderDrawQuad*); + PassOwnPtr drawBackgroundFilters(DrawingFrame&, const CCRenderPassDrawQuad*, const WebKit::WebFilterOperations&, const WebKit::WebTransformationMatrix& deviceTransform); + void drawRenderPassQuad(DrawingFrame&, const CCRenderPassDrawQuad*); + void drawSolidColorQuad(const DrawingFrame&, const CCSolidColorDrawQuad*); + void drawStreamVideoQuad(const DrawingFrame&, const CCStreamVideoDrawQuad*); + void drawTextureQuad(const DrawingFrame&, const CCTextureDrawQuad*); + void drawIOSurfaceQuad(const DrawingFrame&, const CCIOSurfaceDrawQuad*); + void drawTileQuad(const DrawingFrame&, const CCTileDrawQuad*); + void drawYUVVideoQuad(const DrawingFrame&, const CCYUVVideoDrawQuad*); + + void setShaderOpacity(float opacity, int alphaLocation); + void setShaderFloatQuad(const FloatQuad&, int quadLocation); + void drawQuadGeometry(const DrawingFrame&, const WebKit::WebTransformationMatrix& drawTransform, const FloatRect& quadRect, int matrixLocation); + + void copyTextureToFramebuffer(const DrawingFrame&, int textureId, const IntRect&, const WebKit::WebTransformationMatrix& drawMatrix); + + bool useScopedTexture(DrawingFrame&, const CCScopedTexture*, const IntRect& viewportRect); + + bool makeContextCurrent(); + + bool initializeSharedObjects(); + void cleanupSharedObjects(); + + // WebKit::WebGraphicsContext3D::WebGraphicsSwapBuffersCompleteCallbackCHROMIUM implementation. + virtual void onSwapBuffersComplete() OVERRIDE; + + // WebKit::WebGraphicsContext3D::WebGraphicsMemoryAllocationChangedCallbackCHROMIUM implementation. + virtual void onMemoryAllocationChanged(WebKit::WebGraphicsMemoryAllocation) OVERRIDE; + void onMemoryAllocationChangedOnImplThread(WebKit::WebGraphicsMemoryAllocation); + void discardFramebuffer(); + void ensureFramebuffer(); + + // WebGraphicsContext3D::WebGraphicsContextLostCallback implementation. + virtual void onContextLost() OVERRIDE; + + RendererCapabilities m_capabilities; + + unsigned m_offscreenFramebufferId; + + OwnPtr m_sharedGeometry; + FloatQuad m_sharedGeometryQuad; + + // This block of bindings defines all of the programs used by the compositor itself. + + // Tiled layer shaders. + typedef ProgramBinding TileProgram; + typedef ProgramBinding TileProgramAA; + typedef ProgramBinding TileProgramSwizzleAA; + typedef ProgramBinding TileProgramOpaque; + typedef ProgramBinding TileProgramSwizzle; + typedef ProgramBinding TileProgramSwizzleOpaque; + typedef ProgramBinding TileCheckerboardProgram; + + // Render surface shaders. + typedef ProgramBinding RenderPassProgram; + typedef ProgramBinding RenderPassMaskProgram; + typedef ProgramBinding RenderPassProgramAA; + typedef ProgramBinding RenderPassMaskProgramAA; + + // Texture shaders. + typedef ProgramBinding TextureProgram; + typedef ProgramBinding TextureProgramFlip; + typedef ProgramBinding TextureIOSurfaceProgram; + + // Video shaders. + typedef ProgramBinding VideoStreamTextureProgram; + typedef ProgramBinding VideoYUVProgram; + + // Special purpose / effects shaders. + typedef ProgramBinding SolidColorProgram; + + const TileProgram* tileProgram(); + const TileProgramOpaque* tileProgramOpaque(); + const TileProgramAA* tileProgramAA(); + const TileProgramSwizzle* tileProgramSwizzle(); + const TileProgramSwizzleOpaque* tileProgramSwizzleOpaque(); + const TileProgramSwizzleAA* tileProgramSwizzleAA(); + const TileCheckerboardProgram* tileCheckerboardProgram(); + + const RenderPassProgram* renderPassProgram(); + const RenderPassProgramAA* renderPassProgramAA(); + const RenderPassMaskProgram* renderPassMaskProgram(); + const RenderPassMaskProgramAA* renderPassMaskProgramAA(); + + const TextureProgram* textureProgram(); + const TextureProgramFlip* textureProgramFlip(); + const TextureIOSurfaceProgram* textureIOSurfaceProgram(); + + const VideoYUVProgram* videoYUVProgram(); + const VideoStreamTextureProgram* videoStreamTextureProgram(); + + const SolidColorProgram* solidColorProgram(); + + OwnPtr m_tileProgram; + OwnPtr m_tileProgramOpaque; + OwnPtr m_tileProgramAA; + OwnPtr m_tileProgramSwizzle; + OwnPtr m_tileProgramSwizzleOpaque; + OwnPtr m_tileProgramSwizzleAA; + OwnPtr m_tileCheckerboardProgram; + + OwnPtr m_renderPassProgram; + OwnPtr m_renderPassProgramAA; + OwnPtr m_renderPassMaskProgram; + OwnPtr m_renderPassMaskProgramAA; + + OwnPtr m_textureProgram; + OwnPtr m_textureProgramFlip; + OwnPtr m_textureIOSurfaceProgram; + + OwnPtr m_videoYUVProgram; + OwnPtr m_videoStreamTextureProgram; + + OwnPtr m_solidColorProgram; + + WebKit::WebGraphicsContext3D* m_context; + + IntRect m_swapBufferRect; + bool m_isViewportChanged; + bool m_isFramebufferDiscarded; + bool m_isUsingBindUniform; + bool m_visible; + + OwnPtr m_currentFramebufferLock; + + DISALLOW_COPY_AND_ASSIGN(CCRendererGL); +}; + + +// Setting DEBUG_GL_CALLS to 1 will call glGetError() after almost every GL +// call made by the compositor. Useful for debugging rendering issues but +// will significantly degrade performance. +#define DEBUG_GL_CALLS 0 + +#if DEBUG_GL_CALLS && !defined ( NDEBUG ) +#define GLC(context, x) (x, CCRendererGL::debugGLCall(&*context, #x, __FILE__, __LINE__)) +#else +#define GLC(context, x) (x) +#endif + + +} + +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/graphics_context.h b/cc/graphics_context.h index 638cbb270ce9b2..6eb5b3407cbd07 100644 --- a/cc/graphics_context.h +++ b/cc/graphics_context.h @@ -1,3 +1,18 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCGraphicsContext_h +#define CCGraphicsContext_h + +#include +#include + +namespace cc { + +// FIXME: rename fully to CCOutputSurface. +typedef WebKit::WebCompositorOutputSurface CCGraphicsContext; + +} // namespace cc + +#endif // CCGraphicsContext_h diff --git a/cc/HeadsUpDisplayLayerChromium.cpp b/cc/heads_up_display_layer.cc similarity index 100% rename from cc/HeadsUpDisplayLayerChromium.cpp rename to cc/heads_up_display_layer.cc diff --git a/cc/heads_up_display_layer.h b/cc/heads_up_display_layer.h index 638cbb270ce9b2..cd2627e18f0bea 100644 --- a/cc/heads_up_display_layer.h +++ b/cc/heads_up_display_layer.h @@ -1,3 +1,38 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef HeadsUpDisplayLayerChromium_h +#define HeadsUpDisplayLayerChromium_h + +#include "base/memory/scoped_ptr.h" +#include "CCFontAtlas.h" +#include "IntSize.h" +#include "LayerChromium.h" + +namespace cc { + +class HeadsUpDisplayLayerChromium : public LayerChromium { +public: + static scoped_refptr create(); + + virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) OVERRIDE; + virtual bool drawsContent() const OVERRIDE; + + void setFontAtlas(scoped_ptr); + + virtual scoped_ptr createCCLayerImpl() OVERRIDE; + virtual void pushPropertiesTo(CCLayerImpl*) OVERRIDE; + +protected: + HeadsUpDisplayLayerChromium(); + +private: + virtual ~HeadsUpDisplayLayerChromium(); + + scoped_ptr m_fontAtlas; +}; + +} // namespace cc + +#endif diff --git a/cc/CCHeadsUpDisplayLayerImpl.cpp b/cc/heads_up_display_layer_impl.cc similarity index 100% rename from cc/CCHeadsUpDisplayLayerImpl.cpp rename to cc/heads_up_display_layer_impl.cc diff --git a/cc/heads_up_display_layer_impl.h b/cc/heads_up_display_layer_impl.h index 638cbb270ce9b2..47e7cfe73e4252 100644 --- a/cc/heads_up_display_layer_impl.h +++ b/cc/heads_up_display_layer_impl.h @@ -1,3 +1,57 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCHeadsUpDisplayLayerImpl_h +#define CCHeadsUpDisplayLayerImpl_h + +#include "base/memory/scoped_ptr.h" +#include "CCFontAtlas.h" +#include "CCLayerImpl.h" +#include "CCScopedTexture.h" + +class SkCanvas; + +namespace cc { + +class CCDebugRectHistory; +class CCFontAtlas; +class CCFrameRateCounter; + +class CCHeadsUpDisplayLayerImpl : public CCLayerImpl { +public: + static scoped_ptr create(int id) + { + return make_scoped_ptr(new CCHeadsUpDisplayLayerImpl(id)); + } + virtual ~CCHeadsUpDisplayLayerImpl(); + + void setFontAtlas(scoped_ptr); + + virtual void willDraw(CCResourceProvider*) OVERRIDE; + virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; + void updateHudTexture(CCResourceProvider*); + virtual void didDraw(CCResourceProvider*) OVERRIDE; + + virtual void didLoseContext() OVERRIDE; + + virtual bool layerIsAlwaysDamaged() const OVERRIDE; + +private: + explicit CCHeadsUpDisplayLayerImpl(int); + + virtual const char* layerTypeAsString() const OVERRIDE; + + void drawHudContents(SkCanvas*); + void drawFPSCounter(SkCanvas*, CCFrameRateCounter*, int top, int height); + void drawFPSCounterText(SkCanvas*, CCFrameRateCounter*, int top, int width, int height); + void drawDebugRects(SkCanvas*, CCDebugRectHistory*); + + scoped_ptr m_fontAtlas; + OwnPtr m_hudTexture; + OwnPtr m_hudCanvas; +}; + +} // namespace cc + +#endif // CCHeadsUpDisplayLayerImpl_h diff --git a/cc/ImageLayerChromium.cpp b/cc/image_layer.cc similarity index 100% rename from cc/ImageLayerChromium.cpp rename to cc/image_layer.cc diff --git a/cc/image_layer.h b/cc/image_layer.h index 638cbb270ce9b2..12ac39716b8446 100644 --- a/cc/image_layer.h +++ b/cc/image_layer.h @@ -1,3 +1,48 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2010 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef ImageLayerChromium_h +#define ImageLayerChromium_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "ContentLayerChromium.h" +#include "SkBitmap.h" + +namespace cc { + +class ImageLayerTextureUpdater; + +// A Layer that contains only an Image element. +class ImageLayerChromium : public TiledLayerChromium { +public: + static scoped_refptr create(); + + virtual bool drawsContent() const OVERRIDE; + virtual void setTexturePriorities(const CCPriorityCalculator&) OVERRIDE; + virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) OVERRIDE; + virtual bool needsContentsScale() const OVERRIDE; + + void setBitmap(const SkBitmap& image); + +private: + ImageLayerChromium(); + virtual ~ImageLayerChromium(); + + void setTilingOption(TilingOption); + + virtual LayerTextureUpdater* textureUpdater() const OVERRIDE; + virtual void createTextureUpdaterIfNeeded() OVERRIDE; + virtual IntSize contentBounds() const OVERRIDE; + + SkBitmap m_bitmap; + + RefPtr m_textureUpdater; +}; + +} +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/input_handler.h b/cc/input_handler.h index 638cbb270ce9b2..7188cabafae213 100644 --- a/cc/input_handler.h +++ b/cc/input_handler.h @@ -1,3 +1,83 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCInputHandler_h +#define CCInputHandler_h + +#include "base/basictypes.h" +#include + +namespace cc { + +class IntPoint; +class IntSize; + +// The CCInputHandler is a way for the embedders to interact with +// the impl thread side of the compositor implementation. +// +// There is one CCInputHandler for every CCLayerTreeHost. It is +// created on the main thread and used only on the impl thread. +// +// The CCInputHandler is constructed with a CCInputHandlerClient, which is the +// interface by which the handler can manipulate the LayerTree. +class CCInputHandlerClient { +public: + enum ScrollStatus { ScrollOnMainThread, ScrollStarted, ScrollIgnored }; + enum ScrollInputType { Gesture, Wheel }; + + // Selects a layer to be scrolled at a given point in window coordinates. + // Returns ScrollStarted if the layer at the coordinates can be scrolled, + // ScrollOnMainThread if the scroll event should instead be delegated to the + // main thread, or ScrollIgnored if there is nothing to be scrolled at the + // given coordinates. + virtual ScrollStatus scrollBegin(const IntPoint&, ScrollInputType) = 0; + + // Scroll the selected layer starting at the given window coordinate. If + // there is no room to move the layer in the requested direction, its first + // ancestor layer that can be scrolled will be moved instead. Should only be + // called if scrollBegin() returned ScrollStarted. + virtual void scrollBy(const IntPoint&, const IntSize&) = 0; + + // Stop scrolling the selected layer. Should only be called if scrollBegin() + // returned ScrollStarted. + virtual void scrollEnd() = 0; + + virtual void pinchGestureBegin() = 0; + virtual void pinchGestureUpdate(float magnifyDelta, const IntPoint& anchor) = 0; + virtual void pinchGestureEnd() = 0; + + virtual void startPageScaleAnimation(const IntSize& targetPosition, + bool anchorPoint, + float pageScale, + double startTime, + double duration) = 0; + + // Request another callback to CCInputHandler::animate(). + virtual void scheduleAnimation() = 0; + +protected: + CCInputHandlerClient() { } + virtual ~CCInputHandlerClient() { } + +private: + DISALLOW_COPY_AND_ASSIGN(CCInputHandlerClient); +}; + +class CCInputHandler { +public: + virtual ~CCInputHandler() { } + + virtual void bindToClient(CCInputHandlerClient*) = 0; + virtual void animate(double monotonicTime) = 0; + +protected: + CCInputHandler() { } + +private: + DISALLOW_COPY_AND_ASSIGN(CCInputHandler); +}; + +} + +#endif diff --git a/cc/CCIOSurfaceDrawQuad.cpp b/cc/io_surface_draw_quad.cc similarity index 100% rename from cc/CCIOSurfaceDrawQuad.cpp rename to cc/io_surface_draw_quad.cc diff --git a/cc/io_surface_draw_quad.h b/cc/io_surface_draw_quad.h index 638cbb270ce9b2..bb5b028291394a 100644 --- a/cc/io_surface_draw_quad.h +++ b/cc/io_surface_draw_quad.h @@ -1,3 +1,42 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCIOSurfaceDrawQuad_h +#define CCIOSurfaceDrawQuad_h + +#include "CCDrawQuad.h" +#include "IntSize.h" +#include "base/memory/scoped_ptr.h" + +namespace cc { + +#pragma pack(push, 4) + +class CCIOSurfaceDrawQuad : public CCDrawQuad { +public: + enum Orientation { + Flipped, + Unflipped + }; + + static scoped_ptr create(const CCSharedQuadState*, const IntRect&, const IntSize& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation); + + IntSize ioSurfaceSize() const { return m_ioSurfaceSize; } + unsigned ioSurfaceTextureId() const { return m_ioSurfaceTextureId; } + Orientation orientation() const { return m_orientation; } + + static const CCIOSurfaceDrawQuad* materialCast(const CCDrawQuad*); +private: + CCIOSurfaceDrawQuad(const CCSharedQuadState*, const IntRect&, const IntSize& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation); + + IntSize m_ioSurfaceSize; + unsigned m_ioSurfaceTextureId; + Orientation m_orientation; +}; + +#pragma pack(pop) + +} + +#endif diff --git a/cc/IOSurfaceLayerChromium.cpp b/cc/io_surface_layer.cc similarity index 100% rename from cc/IOSurfaceLayerChromium.cpp rename to cc/io_surface_layer.cc diff --git a/cc/io_surface_layer.h b/cc/io_surface_layer.h index 638cbb270ce9b2..f9c4b5f08d4840 100644 --- a/cc/io_surface_layer.h +++ b/cc/io_surface_layer.h @@ -1,3 +1,38 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef IOSurfaceLayerChromium_h +#define IOSurfaceLayerChromium_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "LayerChromium.h" + +namespace cc { + +class IOSurfaceLayerChromium : public LayerChromium { +public: + static scoped_refptr create(); + + void setIOSurfaceProperties(uint32_t ioSurfaceId, const IntSize&); + + virtual scoped_ptr createCCLayerImpl() OVERRIDE; + virtual bool drawsContent() const OVERRIDE; + virtual void pushPropertiesTo(CCLayerImpl*) OVERRIDE; + +protected: + IOSurfaceLayerChromium(); + +private: + virtual ~IOSurfaceLayerChromium(); + + uint32_t m_ioSurfaceId; + IntSize m_ioSurfaceSize; +}; + +} +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCIOSurfaceLayerImpl.cpp b/cc/io_surface_layer_impl.cc similarity index 100% rename from cc/CCIOSurfaceLayerImpl.cpp rename to cc/io_surface_layer_impl.cc diff --git a/cc/io_surface_layer_impl.h b/cc/io_surface_layer_impl.h index 638cbb270ce9b2..238e27e4d28f3e 100644 --- a/cc/io_surface_layer_impl.h +++ b/cc/io_surface_layer_impl.h @@ -1,3 +1,43 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCIOSurfaceLayerImpl_h +#define CCIOSurfaceLayerImpl_h + +#include "CCLayerImpl.h" +#include "IntSize.h" + +namespace cc { + +class CCIOSurfaceLayerImpl : public CCLayerImpl { +public: + static scoped_ptr create(int id) + { + return make_scoped_ptr(new CCIOSurfaceLayerImpl(id)); + } + virtual ~CCIOSurfaceLayerImpl(); + + void setIOSurfaceProperties(unsigned ioSurfaceId, const IntSize&); + + virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; + + virtual void willDraw(CCResourceProvider*) OVERRIDE; + virtual void didLoseContext() OVERRIDE; + + virtual void dumpLayerProperties(std::string*, int indent) const OVERRIDE; + +private: + explicit CCIOSurfaceLayerImpl(int); + + virtual const char* layerTypeAsString() const OVERRIDE; + + unsigned m_ioSurfaceId; + IntSize m_ioSurfaceSize; + bool m_ioSurfaceChanged; + unsigned m_ioSurfaceTextureId; +}; + +} + +#endif // CCIOSurfaceLayerImpl_h diff --git a/cc/CCKeyframedAnimationCurve.cpp b/cc/keyframed_animation_curve.cc similarity index 100% rename from cc/CCKeyframedAnimationCurve.cpp rename to cc/keyframed_animation_curve.cc diff --git a/cc/keyframed_animation_curve.h b/cc/keyframed_animation_curve.h index 638cbb270ce9b2..066e5c64da4352 100644 --- a/cc/keyframed_animation_curve.h +++ b/cc/keyframed_animation_curve.h @@ -1,3 +1,109 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCKeyframedAnimationCurve_h +#define CCKeyframedAnimationCurve_h + +#include "CCAnimationCurve.h" +#include "CCTimingFunction.h" +#include "scoped_ptr_vector.h" +#include + +namespace cc { + +class CCKeyframe { +public: + double time() const; + const CCTimingFunction* timingFunction() const; + +protected: + CCKeyframe(double time, scoped_ptr); + virtual ~CCKeyframe(); + +private: + double m_time; + scoped_ptr m_timingFunction; +}; + +class CCFloatKeyframe : public CCKeyframe { +public: + static scoped_ptr create(double time, float value, scoped_ptr); + virtual ~CCFloatKeyframe(); + + float value() const; + + scoped_ptr clone() const; + +private: + CCFloatKeyframe(double time, float value, scoped_ptr); + + float m_value; +}; + +class CCTransformKeyframe : public CCKeyframe { +public: + static scoped_ptr create(double time, const WebKit::WebTransformOperations& value, scoped_ptr); + virtual ~CCTransformKeyframe(); + + const WebKit::WebTransformOperations& value() const; + + scoped_ptr clone() const; + +private: + CCTransformKeyframe(double time, const WebKit::WebTransformOperations& value, scoped_ptr); + + WebKit::WebTransformOperations m_value; +}; + +class CCKeyframedFloatAnimationCurve : public CCFloatAnimationCurve { +public: + // It is required that the keyframes be sorted by time. + static scoped_ptr create(); + + virtual ~CCKeyframedFloatAnimationCurve(); + + void addKeyframe(scoped_ptr); + + // CCAnimationCurve implementation + virtual double duration() const OVERRIDE; + virtual scoped_ptr clone() const OVERRIDE; + + // CCFloatAnimationCurve implementation + virtual float getValue(double t) const OVERRIDE; + +private: + CCKeyframedFloatAnimationCurve(); + + // Always sorted in order of increasing time. No two keyframes have the + // same time. + ScopedPtrVector m_keyframes; +}; + +class CCKeyframedTransformAnimationCurve : public CCTransformAnimationCurve { +public: + // It is required that the keyframes be sorted by time. + static scoped_ptr create(); + + virtual ~CCKeyframedTransformAnimationCurve(); + + void addKeyframe(scoped_ptr); + + // CCAnimationCurve implementation + virtual double duration() const OVERRIDE; + virtual scoped_ptr clone() const OVERRIDE; + + // CCTransformAnimationCurve implementation + virtual WebKit::WebTransformationMatrix getValue(double t) const OVERRIDE; + +private: + CCKeyframedTransformAnimationCurve(); + + // Always sorted in order of increasing time. No two keyframes have the + // same time. + ScopedPtrVector m_keyframes; +}; + +} // namespace cc + +#endif // CCKeyframedAnimationCurve_h diff --git a/cc/LayerChromium.cpp b/cc/layer.cc similarity index 100% rename from cc/LayerChromium.cpp rename to cc/layer.cc diff --git a/cc/layer.h b/cc/layer.h index 638cbb270ce9b2..a87caa0ca370de 100644 --- a/cc/layer.h +++ b/cc/layer.h @@ -1,3 +1,390 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2010 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef LayerChromium_h +#define LayerChromium_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "base/memory/ref_counted.h" +#include "CCLayerAnimationController.h" +#include "CCOcclusionTracker.h" +#include "FloatPoint.h" +#include "Region.h" +#include "RenderSurfaceChromium.h" +#include "SkColor.h" +#include +#include +#include +#include + +namespace WebKit { +class WebAnimationDelegate; +class WebLayerScrollClient; +} + +namespace cc { + +class CCActiveAnimation; +struct CCAnimationEvent; +class CCLayerAnimationDelegate; +class CCLayerImpl; +class CCLayerTreeHost; +class CCPriorityCalculator; +class CCTextureUpdateQueue; +class ScrollbarLayerChromium; +struct CCAnimationEvent; +struct CCRenderingStats; + +// Base class for composited layers. Special layer types are derived from +// this class. +class LayerChromium : public base::RefCounted, public CCLayerAnimationControllerClient { +public: + typedef std::vector > LayerList; + + static scoped_refptr create(); + + // CCLayerAnimationControllerClient implementation + virtual int id() const OVERRIDE; + virtual void setOpacityFromAnimation(float) OVERRIDE; + virtual float opacity() const OVERRIDE; + virtual void setTransformFromAnimation(const WebKit::WebTransformationMatrix&) OVERRIDE; + // A layer's transform operates layer space. That is, entirely in logical, + // non-page-scaled pixels (that is, they have page zoom baked in, but not page scale). + // The root layer is a special case -- it operates in physical pixels. + virtual const WebKit::WebTransformationMatrix& transform() const OVERRIDE; + + LayerChromium* rootLayer(); + LayerChromium* parent() const; + void addChild(scoped_refptr); + void insertChild(scoped_refptr, size_t index); + void replaceChild(LayerChromium* reference, scoped_refptr newLayer); + void removeFromParent(); + void removeAllChildren(); + void setChildren(const LayerList&); + + const LayerList& children() const { return m_children; } + + void setAnchorPoint(const FloatPoint&); + FloatPoint anchorPoint() const { return m_anchorPoint; } + + void setAnchorPointZ(float); + float anchorPointZ() const { return m_anchorPointZ; } + + void setBackgroundColor(SkColor); + SkColor backgroundColor() const { return m_backgroundColor; } + + // A layer's bounds are in logical, non-page-scaled pixels (however, the + // root layer's bounds are in physical pixels). + void setBounds(const IntSize&); + const IntSize& bounds() const { return m_bounds; } + virtual IntSize contentBounds() const; + + void setMasksToBounds(bool); + bool masksToBounds() const { return m_masksToBounds; } + + void setMaskLayer(LayerChromium*); + LayerChromium* maskLayer() const { return m_maskLayer.get(); } + + virtual void setNeedsDisplayRect(const FloatRect& dirtyRect); + void setNeedsDisplay() { setNeedsDisplayRect(FloatRect(FloatPoint(), bounds())); } + virtual bool needsDisplay() const; + + void setOpacity(float); + bool opacityIsAnimating() const; + + void setFilters(const WebKit::WebFilterOperations&); + const WebKit::WebFilterOperations& filters() const { return m_filters; } + + // Background filters are filters applied to what is behind this layer, when they are viewed through non-opaque + // regions in this layer. They are used through the WebLayer interface, and are not exposed to HTML. + void setBackgroundFilters(const WebKit::WebFilterOperations&); + const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; } + + virtual void setContentsOpaque(bool); + bool contentsOpaque() const { return m_contentsOpaque; } + + void setPosition(const FloatPoint&); + FloatPoint position() const { return m_position; } + + void setIsContainerForFixedPositionLayers(bool); + bool isContainerForFixedPositionLayers() const { return m_isContainerForFixedPositionLayers; } + + void setFixedToContainerLayer(bool); + bool fixedToContainerLayer() const { return m_fixedToContainerLayer; } + + void setSublayerTransform(const WebKit::WebTransformationMatrix&); + const WebKit::WebTransformationMatrix& sublayerTransform() const { return m_sublayerTransform; } + + void setTransform(const WebKit::WebTransformationMatrix&); + bool transformIsAnimating() const; + + const IntRect& visibleContentRect() const { return m_visibleContentRect; } + void setVisibleContentRect(const IntRect& visibleContentRect) { m_visibleContentRect = visibleContentRect; } + + void setScrollPosition(const IntPoint&); + const IntPoint& scrollPosition() const { return m_scrollPosition; } + + void setMaxScrollPosition(const IntSize&); + const IntSize& maxScrollPosition() const { return m_maxScrollPosition; } + + void setScrollable(bool); + bool scrollable() const { return m_scrollable; } + + void setShouldScrollOnMainThread(bool); + bool shouldScrollOnMainThread() const { return m_shouldScrollOnMainThread; } + + void setHaveWheelEventHandlers(bool); + bool haveWheelEventHandlers() const { return m_haveWheelEventHandlers; } + + void setNonFastScrollableRegion(const Region&); + void setNonFastScrollableRegionChanged() { m_nonFastScrollableRegionChanged = true; } + const Region& nonFastScrollableRegion() const { return m_nonFastScrollableRegion; } + + void setLayerScrollClient(WebKit::WebLayerScrollClient* layerScrollClient) { m_layerScrollClient = layerScrollClient; } + + void setDrawCheckerboardForMissingTiles(bool); + bool drawCheckerboardForMissingTiles() const { return m_drawCheckerboardForMissingTiles; } + + bool forceRenderSurface() const { return m_forceRenderSurface; } + void setForceRenderSurface(bool); + + IntSize scrollDelta() const { return IntSize(); } + + void setImplTransform(const WebKit::WebTransformationMatrix&); + const WebKit::WebTransformationMatrix& implTransform() const { return m_implTransform; } + + void setDoubleSided(bool); + bool doubleSided() const { return m_doubleSided; } + + void setPreserves3D(bool preserve3D) { m_preserves3D = preserve3D; } + bool preserves3D() const { return m_preserves3D; } + + void setUseParentBackfaceVisibility(bool useParentBackfaceVisibility) { m_useParentBackfaceVisibility = useParentBackfaceVisibility; } + bool useParentBackfaceVisibility() const { return m_useParentBackfaceVisibility; } + + virtual void setUseLCDText(bool); + bool useLCDText() const { return m_useLCDText; } + + virtual void setLayerTreeHost(CCLayerTreeHost*); + + bool hasContributingDelegatedRenderPasses() const { return false; } + + void setIsDrawable(bool); + + void setReplicaLayer(LayerChromium*); + LayerChromium* replicaLayer() const { return m_replicaLayer.get(); } + + bool hasMask() const { return m_maskLayer; } + bool hasReplica() const { return m_replicaLayer; } + bool replicaHasMask() const { return m_replicaLayer && (m_maskLayer || m_replicaLayer->m_maskLayer); } + + // These methods typically need to be overwritten by derived classes. + virtual bool drawsContent() const; + virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) { } + virtual bool needMoreUpdates(); + virtual void setIsMask(bool) { } + virtual void bindContentsTexture() { } + virtual bool needsContentsScale() const; + + void setDebugBorderColor(SkColor); + void setDebugBorderWidth(float); + void setDebugName(const std::string&); + + virtual void pushPropertiesTo(CCLayerImpl*); + + void clearRenderSurface() { m_renderSurface.reset(); } + RenderSurfaceChromium* renderSurface() const { return m_renderSurface.get(); } + void createRenderSurface(); + + float drawOpacity() const { return m_drawOpacity; } + void setDrawOpacity(float opacity) { m_drawOpacity = opacity; } + + bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; } + void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; } + + LayerChromium* renderTarget() const { ASSERT(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; } + void setRenderTarget(LayerChromium* target) { m_renderTarget = target; } + + bool drawTransformIsAnimating() const { return m_drawTransformIsAnimating; } + void setDrawTransformIsAnimating(bool animating) { m_drawTransformIsAnimating = animating; } + bool screenSpaceTransformIsAnimating() const { return m_screenSpaceTransformIsAnimating; } + void setScreenSpaceTransformIsAnimating(bool animating) { m_screenSpaceTransformIsAnimating = animating; } + + // This moves from layer space, with origin in the center to target space with origin in the top left. + // That is, it converts from logical, non-page-scaled, to target pixels (and if the target is the + // root render surface, then this converts to physical pixels). + const WebKit::WebTransformationMatrix& drawTransform() const { return m_drawTransform; } + void setDrawTransform(const WebKit::WebTransformationMatrix& matrix) { m_drawTransform = matrix; } + // This moves from content space, with origin the top left to screen space with origin in the top left. + // It converts logical, non-page-scaled pixels to physical pixels. + const WebKit::WebTransformationMatrix& screenSpaceTransform() const { return m_screenSpaceTransform; } + void setScreenSpaceTransform(const WebKit::WebTransformationMatrix& matrix) { m_screenSpaceTransform = matrix; } + const IntRect& drawableContentRect() const { return m_drawableContentRect; } + void setDrawableContentRect(const IntRect& rect) { m_drawableContentRect = rect; } + // The contentsScale converts from logical, non-page-scaled pixels to target pixels. + // The contentsScale is 1 for the root layer as it is already in physical pixels. + float contentsScale() const { return m_contentsScale; } + void setContentsScale(float); + + // When true, the layer's contents are not scaled by the current page scale factor. + // setBoundsContainPageScale recursively sets the value on all child layers. + void setBoundsContainPageScale(bool); + bool boundsContainPageScale() const { return m_boundsContainPageScale; } + + // Returns true if any of the layer's descendants has content to draw. + bool descendantDrawsContent(); + + CCLayerTreeHost* layerTreeHost() const { return m_layerTreeHost; } + + // Set the priority of all desired textures in this layer. + virtual void setTexturePriorities(const CCPriorityCalculator&) { } + + bool addAnimation(scoped_ptr); + void pauseAnimation(int animationId, double timeOffset); + void removeAnimation(int animationId); + + void suspendAnimations(double monotonicTime); + void resumeAnimations(double monotonicTime); + + CCLayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); } + void setLayerAnimationController(scoped_ptr); + scoped_ptr releaseLayerAnimationController(); + + void setLayerAnimationDelegate(WebKit::WebAnimationDelegate* layerAnimationDelegate) { m_layerAnimationDelegate = layerAnimationDelegate; } + + bool hasActiveAnimation() const; + + virtual void notifyAnimationStarted(const CCAnimationEvent&, double wallClockTime); + virtual void notifyAnimationFinished(double wallClockTime); + + virtual Region visibleContentOpaqueRegion() const; + + virtual ScrollbarLayerChromium* toScrollbarLayerChromium(); + +protected: + friend class CCLayerImpl; + friend class TreeSynchronizer; + virtual ~LayerChromium(); + + LayerChromium(); + + void setNeedsCommit(); + + IntRect layerRectToContentRect(const WebKit::WebRect& layerRect); + + // This flag is set when layer need repainting/updating. + bool m_needsDisplay; + + // Tracks whether this layer may have changed stacking order with its siblings. + bool m_stackingOrderChanged; + + // The update rect is the region of the compositor resource that was actually updated by the compositor. + // For layers that may do updating outside the compositor's control (i.e. plugin layers), this information + // is not available and the update rect will remain empty. + // Note this rect is in layer space (not content space). + FloatRect m_updateRect; + + scoped_refptr m_maskLayer; + + // Constructs a CCLayerImpl of the correct runtime type for this LayerChromium type. + virtual scoped_ptr createCCLayerImpl(); + int m_layerId; + +private: + friend class base::RefCounted; + + void setParent(LayerChromium*); + bool hasAncestor(LayerChromium*) const; + bool descendantIsFixedToContainerLayer() const; + + size_t numChildren() const { return m_children.size(); } + + // Returns the index of the child or -1 if not found. + int indexOfChild(const LayerChromium*); + + // This should only be called from removeFromParent. + void removeChild(LayerChromium*); + + LayerList m_children; + LayerChromium* m_parent; + + // LayerChromium instances have a weak pointer to their CCLayerTreeHost. + // This pointer value is nil when a LayerChromium is not in a tree and is + // updated via setLayerTreeHost() if a layer moves between trees. + CCLayerTreeHost* m_layerTreeHost; + + scoped_ptr m_layerAnimationController; + + // Layer properties. + IntSize m_bounds; + + // Uses layer's content space. + IntRect m_visibleContentRect; + + IntPoint m_scrollPosition; + IntSize m_maxScrollPosition; + bool m_scrollable; + bool m_shouldScrollOnMainThread; + bool m_haveWheelEventHandlers; + Region m_nonFastScrollableRegion; + bool m_nonFastScrollableRegionChanged; + FloatPoint m_position; + FloatPoint m_anchorPoint; + SkColor m_backgroundColor; + SkColor m_debugBorderColor; + float m_debugBorderWidth; + std::string m_debugName; + float m_opacity; + WebKit::WebFilterOperations m_filters; + WebKit::WebFilterOperations m_backgroundFilters; + float m_anchorPointZ; + bool m_isContainerForFixedPositionLayers; + bool m_fixedToContainerLayer; + bool m_isDrawable; + bool m_masksToBounds; + bool m_contentsOpaque; + bool m_doubleSided; + bool m_useLCDText; + bool m_preserves3D; + bool m_useParentBackfaceVisibility; + bool m_drawCheckerboardForMissingTiles; + bool m_forceRenderSurface; + + WebKit::WebTransformationMatrix m_transform; + WebKit::WebTransformationMatrix m_sublayerTransform; + + // Replica layer used for reflections. + scoped_refptr m_replicaLayer; + + // Transient properties. + scoped_ptr m_renderSurface; + float m_drawOpacity; + bool m_drawOpacityIsAnimating; + + LayerChromium* m_renderTarget; + + WebKit::WebTransformationMatrix m_drawTransform; + WebKit::WebTransformationMatrix m_screenSpaceTransform; + bool m_drawTransformIsAnimating; + bool m_screenSpaceTransformIsAnimating; + + // Uses target surface space. + IntRect m_drawableContentRect; + float m_contentsScale; + bool m_boundsContainPageScale; + + WebKit::WebTransformationMatrix m_implTransform; + + WebKit::WebAnimationDelegate* m_layerAnimationDelegate; + WebKit::WebLayerScrollClient* m_layerScrollClient; +}; + +void sortLayers(std::vector >::iterator, std::vector >::iterator, void*); + +} +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCLayerAnimationController.cpp b/cc/layer_animation_controller.cc similarity index 100% rename from cc/CCLayerAnimationController.cpp rename to cc/layer_animation_controller.cc diff --git a/cc/layer_animation_controller.h b/cc/layer_animation_controller.h index 638cbb270ce9b2..2fdb91c611aa3f 100644 --- a/cc/layer_animation_controller.h +++ b/cc/layer_animation_controller.h @@ -1,3 +1,112 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCLayerAnimationController_h +#define CCLayerAnimationController_h + +#include "CCAnimationEvents.h" + +#include "base/basictypes.h" +#include "base/hash_tables.h" +#include "base/memory/scoped_ptr.h" +#include "cc/scoped_ptr_vector.h" + +namespace WebKit { +class WebTransformationMatrix; +} + +namespace cc { + +class Animation; +class IntSize; +class KeyframeValueList; + +class CCLayerAnimationControllerClient { +public: + virtual ~CCLayerAnimationControllerClient() { } + + virtual int id() const = 0; + virtual void setOpacityFromAnimation(float) = 0; + virtual float opacity() const = 0; + virtual void setTransformFromAnimation(const WebKit::WebTransformationMatrix&) = 0; + virtual const WebKit::WebTransformationMatrix& transform() const = 0; +}; + +class CCLayerAnimationController { +public: + static scoped_ptr create(CCLayerAnimationControllerClient*); + + virtual ~CCLayerAnimationController(); + + // These methods are virtual for testing. + virtual void addAnimation(scoped_ptr); + virtual void pauseAnimation(int animationId, double timeOffset); + virtual void removeAnimation(int animationId); + virtual void removeAnimation(int animationId, CCActiveAnimation::TargetProperty); + virtual void suspendAnimations(double monotonicTime); + virtual void resumeAnimations(double monotonicTime); + + // Ensures that the list of active animations on the main thread and the impl thread + // are kept in sync. This function does not take ownership of the impl thread controller. + virtual void pushAnimationUpdatesTo(CCLayerAnimationController*); + + void animate(double monotonicTime, CCAnimationEventsVector*); + + // Returns the active animation in the given group, animating the given property, if such an + // animation exists. + CCActiveAnimation* getActiveAnimation(int groupId, CCActiveAnimation::TargetProperty) const; + + // Returns the active animation animating the given property that is either running, or is + // next to run, if such an animation exists. + CCActiveAnimation* getActiveAnimation(CCActiveAnimation::TargetProperty) const; + + // Returns true if there are any animations that have neither finished nor aborted. + bool hasActiveAnimation() const; + + // Returns true if there is an animation currently animating the given property, or + // if there is an animation scheduled to animate this property in the future. + bool isAnimatingProperty(CCActiveAnimation::TargetProperty) const; + + // This is called in response to an animation being started on the impl thread. This + // function updates the corresponding main thread animation's start time. + void notifyAnimationStarted(const CCAnimationEvent&); + + // If a sync is forced, then the next time animation updates are pushed to the impl + // thread, all animations will be transferred. + void setForceSync() { m_forceSync = true; } + + void setClient(CCLayerAnimationControllerClient*); + +protected: + explicit CCLayerAnimationController(CCLayerAnimationControllerClient*); + +private: + typedef base::hash_set TargetProperties; + + void pushNewAnimationsToImplThread(CCLayerAnimationController*) const; + void removeAnimationsCompletedOnMainThread(CCLayerAnimationController*) const; + void pushPropertiesToImplThread(CCLayerAnimationController*) const; + void replaceImplThreadAnimations(CCLayerAnimationController*) const; + + void startAnimationsWaitingForNextTick(double monotonicTime, CCAnimationEventsVector*); + void startAnimationsWaitingForStartTime(double monotonicTime, CCAnimationEventsVector*); + void startAnimationsWaitingForTargetAvailability(double monotonicTime, CCAnimationEventsVector*); + void resolveConflicts(double monotonicTime); + void markAnimationsForDeletion(double monotonicTime, CCAnimationEventsVector*); + void purgeAnimationsMarkedForDeletion(); + + void tickAnimations(double monotonicTime); + + // If this is true, we force a sync to the impl thread. + bool m_forceSync; + + CCLayerAnimationControllerClient* m_client; + ScopedPtrVector m_activeAnimations; + + DISALLOW_COPY_AND_ASSIGN(CCLayerAnimationController); +}; + +} // namespace cc + +#endif // CCLayerAnimationController_h diff --git a/cc/CCLayerImpl.cpp b/cc/layer_impl.cc similarity index 100% rename from cc/CCLayerImpl.cpp rename to cc/layer_impl.cc diff --git a/cc/layer_impl.h b/cc/layer_impl.h index 638cbb270ce9b2..e34ccc86a03735 100644 --- a/cc/layer_impl.h +++ b/cc/layer_impl.h @@ -1,3 +1,399 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCLayerImpl_h +#define CCLayerImpl_h + +#include "base/memory/scoped_ptr.h" +#include "cc/scoped_ptr_vector.h" +#include "CCInputHandler.h" +#include "CCLayerAnimationController.h" +#include "CCRenderPass.h" +#include "CCRenderSurface.h" +#include "CCResourceProvider.h" +#include "CCSharedQuadState.h" +#include "FloatRect.h" +#include "IntRect.h" +#include "Region.h" +#include "SkColor.h" +#include +#include +#include +#include + +namespace cc { + +class CCLayerSorter; +class CCLayerTreeHostImpl; +class CCQuadSink; +class CCRenderer; +class CCScrollbarAnimationController; +class CCScrollbarLayerImpl; +class LayerChromium; + +struct CCAppendQuadsData; + +class CCLayerImpl : public CCLayerAnimationControllerClient { +public: + static scoped_ptr create(int id) + { + return make_scoped_ptr(new CCLayerImpl(id)); + } + + virtual ~CCLayerImpl(); + + // CCLayerAnimationControllerClient implementation. + virtual int id() const OVERRIDE; + virtual void setOpacityFromAnimation(float) OVERRIDE; + virtual float opacity() const OVERRIDE; + virtual void setTransformFromAnimation(const WebKit::WebTransformationMatrix&) OVERRIDE; + virtual const WebKit::WebTransformationMatrix& transform() const OVERRIDE; + + // Tree structure. + CCLayerImpl* parent() const { return m_parent; } + const ScopedPtrVector& children() const { return m_children; } + void addChild(scoped_ptr); + void removeFromParent(); + void removeAllChildren(); + + void setMaskLayer(scoped_ptr); + CCLayerImpl* maskLayer() const { return m_maskLayer.get(); } + + void setReplicaLayer(scoped_ptr); + CCLayerImpl* replicaLayer() const { return m_replicaLayer.get(); } + + bool hasMask() const { return m_maskLayer; } + bool hasReplica() const { return m_replicaLayer; } + bool replicaHasMask() const { return m_replicaLayer && (m_maskLayer || m_replicaLayer->m_maskLayer); } + + CCLayerTreeHostImpl* layerTreeHostImpl() const { return m_layerTreeHostImpl; } + void setLayerTreeHostImpl(CCLayerTreeHostImpl* hostImpl) { m_layerTreeHostImpl = hostImpl; } + + scoped_ptr createSharedQuadState() const; + // willDraw must be called before appendQuads. If willDraw is called, + // didDraw is guaranteed to be called before another willDraw or before + // the layer is destroyed. To enforce this, any class that overrides + // willDraw/didDraw must call the base class version. + virtual void willDraw(CCResourceProvider*); + virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) { } + virtual void didDraw(CCResourceProvider*); + + virtual CCResourceProvider::ResourceId contentsResourceId() const; + + virtual bool hasContributingDelegatedRenderPasses() const; + virtual CCRenderPass::Id firstContributingRenderPassId() const; + virtual CCRenderPass::Id nextContributingRenderPassId(CCRenderPass::Id) const; + + // Returns true if this layer has content to draw. + void setDrawsContent(bool); + bool drawsContent() const { return m_drawsContent; } + + bool forceRenderSurface() const { return m_forceRenderSurface; } + void setForceRenderSurface(bool force) { m_forceRenderSurface = force; } + + // Returns true if any of the layer's descendants has content to draw. + virtual bool descendantDrawsContent(); + + void setAnchorPoint(const FloatPoint&); + const FloatPoint& anchorPoint() const { return m_anchorPoint; } + + void setAnchorPointZ(float); + float anchorPointZ() const { return m_anchorPointZ; } + + void setBackgroundColor(SkColor); + SkColor backgroundColor() const { return m_backgroundColor; } + + void setFilters(const WebKit::WebFilterOperations&); + const WebKit::WebFilterOperations& filters() const { return m_filters; } + + void setBackgroundFilters(const WebKit::WebFilterOperations&); + const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; } + + void setMasksToBounds(bool); + bool masksToBounds() const { return m_masksToBounds; } + + void setContentsOpaque(bool); + bool contentsOpaque() const { return m_contentsOpaque; } + + void setOpacity(float); + bool opacityIsAnimating() const; + + void setPosition(const FloatPoint&); + const FloatPoint& position() const { return m_position; } + + void setIsContainerForFixedPositionLayers(bool isContainerForFixedPositionLayers) { m_isContainerForFixedPositionLayers = isContainerForFixedPositionLayers; } + bool isContainerForFixedPositionLayers() const { return m_isContainerForFixedPositionLayers; } + + void setFixedToContainerLayer(bool fixedToContainerLayer = true) { m_fixedToContainerLayer = fixedToContainerLayer;} + bool fixedToContainerLayer() const { return m_fixedToContainerLayer; } + + void setPreserves3D(bool); + bool preserves3D() const { return m_preserves3D; } + + void setUseParentBackfaceVisibility(bool useParentBackfaceVisibility) { m_useParentBackfaceVisibility = useParentBackfaceVisibility; } + bool useParentBackfaceVisibility() const { return m_useParentBackfaceVisibility; } + + void setUseLCDText(bool useLCDText) { m_useLCDText = useLCDText; } + bool useLCDText() const { return m_useLCDText; } + + void setSublayerTransform(const WebKit::WebTransformationMatrix&); + const WebKit::WebTransformationMatrix& sublayerTransform() const { return m_sublayerTransform; } + + // Debug layer border - visual effect only, do not change geometry/clipping/etc. + void setDebugBorderColor(SkColor); + SkColor debugBorderColor() const { return m_debugBorderColor; } + void setDebugBorderWidth(float); + float debugBorderWidth() const { return m_debugBorderWidth; } + bool hasDebugBorders() const; + + // Debug layer name. + void setDebugName(const std::string& debugName) { m_debugName = debugName; } + std::string debugName() const { return m_debugName; } + + CCRenderSurface* renderSurface() const { return m_renderSurface.get(); } + void createRenderSurface(); + void clearRenderSurface() { m_renderSurface.clear(); } + + float drawOpacity() const { return m_drawOpacity; } + void setDrawOpacity(float opacity) { m_drawOpacity = opacity; } + + bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; } + void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; } + + CCLayerImpl* renderTarget() const { ASSERT(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; } + void setRenderTarget(CCLayerImpl* target) { m_renderTarget = target; } + + void setBounds(const IntSize&); + const IntSize& bounds() const { return m_bounds; } + + const IntSize& contentBounds() const { return m_contentBounds; } + void setContentBounds(const IntSize&); + + const IntPoint& scrollPosition() const { return m_scrollPosition; } + void setScrollPosition(const IntPoint&); + + const IntSize& maxScrollPosition() const {return m_maxScrollPosition; } + void setMaxScrollPosition(const IntSize&); + + const FloatSize& scrollDelta() const { return m_scrollDelta; } + void setScrollDelta(const FloatSize&); + + const WebKit::WebTransformationMatrix& implTransform() const { return m_implTransform; } + void setImplTransform(const WebKit::WebTransformationMatrix& transform); + + const IntSize& sentScrollDelta() const { return m_sentScrollDelta; } + void setSentScrollDelta(const IntSize& sentScrollDelta) { m_sentScrollDelta = sentScrollDelta; } + + // Returns the delta of the scroll that was outside of the bounds of the initial scroll + FloatSize scrollBy(const FloatSize& scroll); + + bool scrollable() const { return m_scrollable; } + void setScrollable(bool scrollable) { m_scrollable = scrollable; } + + bool shouldScrollOnMainThread() const { return m_shouldScrollOnMainThread; } + void setShouldScrollOnMainThread(bool shouldScrollOnMainThread) { m_shouldScrollOnMainThread = shouldScrollOnMainThread; } + + bool haveWheelEventHandlers() const { return m_haveWheelEventHandlers; } + void setHaveWheelEventHandlers(bool haveWheelEventHandlers) { m_haveWheelEventHandlers = haveWheelEventHandlers; } + + const Region& nonFastScrollableRegion() const { return m_nonFastScrollableRegion; } + void setNonFastScrollableRegion(const Region& region) { m_nonFastScrollableRegion = region; } + + void setDrawCheckerboardForMissingTiles(bool checkerboard) { m_drawCheckerboardForMissingTiles = checkerboard; } + bool drawCheckerboardForMissingTiles() const; + + CCInputHandlerClient::ScrollStatus tryScroll(const IntPoint& viewportPoint, CCInputHandlerClient::ScrollInputType) const; + + const IntRect& visibleContentRect() const { return m_visibleContentRect; } + void setVisibleContentRect(const IntRect& visibleContentRect) { m_visibleContentRect = visibleContentRect; } + + bool doubleSided() const { return m_doubleSided; } + void setDoubleSided(bool); + + void setTransform(const WebKit::WebTransformationMatrix&); + bool transformIsAnimating() const; + + const WebKit::WebTransformationMatrix& drawTransform() const { return m_drawTransform; } + void setDrawTransform(const WebKit::WebTransformationMatrix& matrix) { m_drawTransform = matrix; } + const WebKit::WebTransformationMatrix& screenSpaceTransform() const { return m_screenSpaceTransform; } + void setScreenSpaceTransform(const WebKit::WebTransformationMatrix& matrix) { m_screenSpaceTransform = matrix; } + + bool drawTransformIsAnimating() const { return m_drawTransformIsAnimating; } + void setDrawTransformIsAnimating(bool animating) { m_drawTransformIsAnimating = animating; } + bool screenSpaceTransformIsAnimating() const { return m_screenSpaceTransformIsAnimating; } + void setScreenSpaceTransformIsAnimating(bool animating) { m_screenSpaceTransformIsAnimating = animating; } + + const IntRect& drawableContentRect() const { return m_drawableContentRect; } + void setDrawableContentRect(const IntRect& rect) { m_drawableContentRect = rect; } + const FloatRect& updateRect() const { return m_updateRect; } + void setUpdateRect(const FloatRect& updateRect) { m_updateRect = updateRect; } + + std::string layerTreeAsText() const; + + void setStackingOrderChanged(bool); + + bool layerPropertyChanged() const { return m_layerPropertyChanged || layerIsAlwaysDamaged(); } + bool layerSurfacePropertyChanged() const; + + void resetAllChangeTrackingForSubtree(); + + virtual bool layerIsAlwaysDamaged() const; + + CCLayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); } + + virtual Region visibleContentOpaqueRegion() const; + + // Indicates that the context previously used to render this layer + // was lost and that a new one has been created. Won't be called + // until the new context has been created successfully. + virtual void didLoseContext(); + + CCScrollbarAnimationController* scrollbarAnimationController() const { return m_scrollbarAnimationController.get(); } + + CCScrollbarLayerImpl* horizontalScrollbarLayer() const; + void setHorizontalScrollbarLayer(CCScrollbarLayerImpl*); + + CCScrollbarLayerImpl* verticalScrollbarLayer() const; + void setVerticalScrollbarLayer(CCScrollbarLayerImpl*); + +protected: + explicit CCLayerImpl(int); + + void appendDebugBorderQuad(CCQuadSink&, const CCSharedQuadState*, CCAppendQuadsData&) const; + + IntRect layerRectToContentRect(const WebKit::WebRect& layerRect); + + virtual void dumpLayerProperties(std::string*, int indent) const; + static std::string indentString(int indent); + +private: + void setParent(CCLayerImpl* parent) { m_parent = parent; } + friend class TreeSynchronizer; + void clearChildList(); // Warning: This does not preserve tree structure invariants and so is only exposed to the tree synchronizer. + + void noteLayerPropertyChangedForSubtree(); + + // Note carefully this does not affect the current layer. + void noteLayerPropertyChangedForDescendants(); + + virtual const char* layerTypeAsString() const; + + void dumpLayer(std::string*, int indent) const; + + // Properties internal to CCLayerImpl + CCLayerImpl* m_parent; + ScopedPtrVector m_children; + // m_maskLayer can be temporarily stolen during tree sync, we need this ID to confirm newly assigned layer is still the previous one + int m_maskLayerId; + scoped_ptr m_maskLayer; + int m_replicaLayerId; // ditto + scoped_ptr m_replicaLayer; + int m_layerId; + CCLayerTreeHostImpl* m_layerTreeHostImpl; + + // Properties synchronized from the associated LayerChromium. + FloatPoint m_anchorPoint; + float m_anchorPointZ; + IntSize m_bounds; + IntSize m_contentBounds; + IntPoint m_scrollPosition; + bool m_scrollable; + bool m_shouldScrollOnMainThread; + bool m_haveWheelEventHandlers; + Region m_nonFastScrollableRegion; + SkColor m_backgroundColor; + + // Whether the "back" of this layer should draw. + bool m_doubleSided; + + // Tracks if drawing-related properties have changed since last redraw. + bool m_layerPropertyChanged; + + // Indicates that a property has changed on this layer that would not + // affect the pixels on its target surface, but would require redrawing + // but would require redrawing the targetSurface onto its ancestor targetSurface. + // For layers that do not own a surface this flag acts as m_layerPropertyChanged. + bool m_layerSurfacePropertyChanged; + + // Uses layer's content space. + IntRect m_visibleContentRect; + bool m_masksToBounds; + bool m_contentsOpaque; + float m_opacity; + FloatPoint m_position; + bool m_preserves3D; + bool m_useParentBackfaceVisibility; + bool m_drawCheckerboardForMissingTiles; + WebKit::WebTransformationMatrix m_sublayerTransform; + WebKit::WebTransformationMatrix m_transform; + bool m_useLCDText; + + bool m_drawsContent; + bool m_forceRenderSurface; + + // Set for the layer that other layers are fixed to. + bool m_isContainerForFixedPositionLayers; + // This is true if the layer should be fixed to the closest ancestor container. + bool m_fixedToContainerLayer; + + FloatSize m_scrollDelta; + IntSize m_sentScrollDelta; + IntSize m_maxScrollPosition; + WebKit::WebTransformationMatrix m_implTransform; + + // The layer whose coordinate space this layer draws into. This can be + // either the same layer (m_renderTarget == this) or an ancestor of this + // layer. + CCLayerImpl* m_renderTarget; + + // The global depth value of the center of the layer. This value is used + // to sort layers from back to front. + float m_drawDepth; + float m_drawOpacity; + bool m_drawOpacityIsAnimating; + + // Debug borders. + SkColor m_debugBorderColor; + float m_debugBorderWidth; + + // Debug layer name. + std::string m_debugName; + + WebKit::WebFilterOperations m_filters; + WebKit::WebFilterOperations m_backgroundFilters; + + WebKit::WebTransformationMatrix m_drawTransform; + WebKit::WebTransformationMatrix m_screenSpaceTransform; + bool m_drawTransformIsAnimating; + bool m_screenSpaceTransformIsAnimating; + +#ifndef NDEBUG + bool m_betweenWillDrawAndDidDraw; +#endif + + // Render surface associated with this layer. The layer and its descendants + // will render to this surface. + OwnPtr m_renderSurface; + + // Hierarchical bounding rect containing the layer and its descendants. + // Uses target surface's space. + IntRect m_drawableContentRect; + + // Rect indicating what was repainted/updated during update. + // Note that plugin layers bypass this and leave it empty. + // Uses layer's content space. + FloatRect m_updateRect; + + // Manages animations for this layer. + scoped_ptr m_layerAnimationController; + + // Manages scrollbars for this layer + OwnPtr m_scrollbarAnimationController; +}; + +void sortLayers(std::vector::iterator first, std::vector::iterator end, CCLayerSorter*); + +} + +#endif // CCLayerImpl_h diff --git a/cc/CCLayerIterator.cpp b/cc/layer_iterator.cc similarity index 100% rename from cc/CCLayerIterator.cpp rename to cc/layer_iterator.cc diff --git a/cc/layer_iterator.h b/cc/layer_iterator.h index 638cbb270ce9b2..4d36080d3060a3 100644 --- a/cc/layer_iterator.h +++ b/cc/layer_iterator.h @@ -1,3 +1,208 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCLayerIterator_h +#define CCLayerIterator_h + +#include "CCLayerTreeHostCommon.h" + +#include "base/memory/ref_counted.h" + +namespace cc { + +// These classes provide means to iterate over the RenderSurface-Layer tree. + +// Example code follows, for a tree of LayerChromium/RenderSurfaceChromium objects. See below for details. +// +// void doStuffOnLayers(const std::vector >& renderSurfaceLayerList) +// { +// typedef CCLayerIterator CCLayerIteratorType; +// +// CCLayerIteratorType end = CCLayerIteratorType::end(&renderSurfaceLayerList); +// for (CCLayerIteratorType it = CCLayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) { +// // Only one of these will be true +// if (it.representsTargetRenderSurface()) +// foo(*it); // *it is a layer representing a target RenderSurface +// if (it.representsContributingRenderSurface()) +// bar(*it); // *it is a layer representing a RenderSurface that contributes to the layer's target RenderSurface +// if (it.representsItself()) +// baz(*it); // *it is a layer representing itself, as it contributes to its own target RenderSurface +// } +// } + +// A RenderSurface R may be referred to in one of two different contexts. One RenderSurface is "current" at any time, for +// whatever operation is being performed. This current surface is referred to as a target surface. For example, when R is +// being painted it would be the target surface. Once R has been painted, its contents may be included into another +// surface S. While S is considered the target surface when it is being painted, R is called a contributing surface +// in this context as it contributes to the content of the target surface S. +// +// The iterator's current position in the tree always points to some layer. The state of the iterator indicates the role of the +// layer, and will be one of the following three states. A single layer L will appear in the iteration process in at least one, +// and possibly all, of these states. +// 1. Representing the target surface: The iterator in this state, pointing at layer L, indicates that the target RenderSurface +// is now the surface owned by L. This will occur exactly once for each RenderSurface in the tree. +// 2. Representing a contributing surface: The iterator in this state, pointing at layer L, refers to the RenderSurface owned +// by L as a contributing surface, without changing the current target RenderSurface. +// 3. Representing itself: The iterator in this state, pointing at layer L, refers to the layer itself, as a child of the +// current target RenderSurface. +// +// The BackToFront iterator will return a layer representing the target surface before returning layers representing themselves +// as children of the current target surface. Whereas the FrontToBack ordering will iterate over children layers of a surface +// before the layer representing the surface as a target surface. +// +// To use the iterators: +// +// Create a stepping iterator and end iterator by calling CCLayerIterator::begin() and CCLayerIterator::end() and passing in the +// list of layers owning target RenderSurfaces. Step through the tree by incrementing the stepping iterator while it is != to +// the end iterator. At each step the iterator knows what the layer is representing, and you can query the iterator to decide +// what actions to perform with the layer given what it represents. + +////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +// Non-templated constants +struct CCLayerIteratorValue { + static const int InvalidTargetRenderSurfaceLayerIndex = -1; + // This must be -1 since the iterator action code assumes that this value can be + // reached by subtracting one from the position of the first layer in the current + // target surface's child layer list, which is 0. + static const int LayerIndexRepresentingTargetRenderSurface = -1; +}; + +// The position of a layer iterator that is independent of its many template types. +template +struct CCLayerIteratorPosition { + bool representsTargetRenderSurface; + bool representsContributingRenderSurface; + bool representsItself; + LayerType* targetRenderSurfaceLayer; + LayerType* currentLayer; +}; + +// An iterator class for walking over layers in the RenderSurface-Layer tree. +template +class CCLayerIterator { + typedef CCLayerIterator CCLayerIteratorType; + +public: + CCLayerIterator() : m_renderSurfaceLayerList(0) { } + + static CCLayerIteratorType begin(const LayerList* renderSurfaceLayerList) { return CCLayerIteratorType(renderSurfaceLayerList, true); } + static CCLayerIteratorType end(const LayerList* renderSurfaceLayerList) { return CCLayerIteratorType(renderSurfaceLayerList, false); } + + CCLayerIteratorType& operator++() { m_actions.next(*this); return *this; } + bool operator==(const CCLayerIterator& other) const + { + return m_targetRenderSurfaceLayerIndex == other.m_targetRenderSurfaceLayerIndex + && m_currentLayerIndex == other.m_currentLayerIndex; + } + bool operator!=(const CCLayerIteratorType& other) const { return !(*this == other); } + + LayerType* operator->() const { return currentLayer(); } + LayerType* operator*() const { return currentLayer(); } + + bool representsTargetRenderSurface() const { return currentLayerRepresentsTargetRenderSurface(); } + bool representsContributingRenderSurface() const { return !representsTargetRenderSurface() && currentLayerRepresentsContributingRenderSurface(); } + bool representsItself() const { return !representsTargetRenderSurface() && !representsContributingRenderSurface(); } + + LayerType* targetRenderSurfaceLayer() const { return getRawPtr((*m_renderSurfaceLayerList)[m_targetRenderSurfaceLayerIndex]); } + + operator const CCLayerIteratorPosition() const + { + CCLayerIteratorPosition position; + position.representsTargetRenderSurface = representsTargetRenderSurface(); + position.representsContributingRenderSurface = representsContributingRenderSurface(); + position.representsItself = representsItself(); + position.targetRenderSurfaceLayer = targetRenderSurfaceLayer(); + position.currentLayer = currentLayer(); + return position; + } + +private: + CCLayerIterator(const LayerList* renderSurfaceLayerList, bool start) + : m_renderSurfaceLayerList(renderSurfaceLayerList) + , m_targetRenderSurfaceLayerIndex(0) + { + for (size_t i = 0; i < renderSurfaceLayerList->size(); ++i) { + if (!(*renderSurfaceLayerList)[i]->renderSurface()) { + ASSERT_NOT_REACHED(); + m_actions.end(*this); + return; + } + } + + if (start && !renderSurfaceLayerList->empty()) + m_actions.begin(*this); + else + m_actions.end(*this); + } + + inline static LayerChromium* getRawPtr(const scoped_refptr& ptr) { return ptr.get(); } + inline static CCLayerImpl* getRawPtr(CCLayerImpl* ptr) { return ptr; } + + inline LayerType* currentLayer() const { return currentLayerRepresentsTargetRenderSurface() ? targetRenderSurfaceLayer() : getRawPtr(targetRenderSurfaceChildren()[m_currentLayerIndex]); } + + inline bool currentLayerRepresentsContributingRenderSurface() const { return CCLayerTreeHostCommon::renderSurfaceContributesToTarget(currentLayer(), targetRenderSurfaceLayer()->id()); } + inline bool currentLayerRepresentsTargetRenderSurface() const { return m_currentLayerIndex == CCLayerIteratorValue::LayerIndexRepresentingTargetRenderSurface; } + + inline RenderSurfaceType* targetRenderSurface() const { return targetRenderSurfaceLayer()->renderSurface(); } + inline const LayerList& targetRenderSurfaceChildren() const { return targetRenderSurface()->layerList(); } + + IteratorActionType m_actions; + const LayerList* m_renderSurfaceLayerList; + + // The iterator's current position. + + // A position in the renderSurfaceLayerList. This points to a layer which owns the current target surface. + // This is a value from 0 to n-1 (n = size of renderSurfaceLayerList = number of surfaces). A value outside of + // this range (for example, CCLayerIteratorValue::InvalidTargetRenderSurfaceLayerIndex) is used to + // indicate a position outside the bounds of the tree. + int m_targetRenderSurfaceLayerIndex; + // A position in the list of layers that are children of the current target surface. When pointing to one of + // these layers, this is a value from 0 to n-1 (n = number of children). Since the iterator must also stop at + // the layers representing the target surface, this is done by setting the currentLayerIndex to a value of + // CCLayerIteratorValue::LayerRepresentingTargetRenderSurface. + int m_currentLayerIndex; + + friend struct CCLayerIteratorActions; +}; + +// Orderings for iterating over the RenderSurface-Layer tree. +struct CCLayerIteratorActions { + // Walks layers sorted by z-order from back to front. + class BackToFront { + public: + template + void begin(CCLayerIterator&); + + template + void end(CCLayerIterator&); + + template + void next(CCLayerIterator&); + + private: + int m_highestTargetRenderSurfaceLayer; + }; + + // Walks layers sorted by z-order from front to back + class FrontToBack { + public: + template + void begin(CCLayerIterator&); + + template + void end(CCLayerIterator&); + + template + void next(CCLayerIterator&); + + private: + template + void goToHighestInSubtree(CCLayerIterator&); + }; +}; + +} // namespace cc + +#endif diff --git a/cc/layer_painter.h b/cc/layer_painter.h index 638cbb270ce9b2..d552382d149af1 100644 --- a/cc/layer_painter.h +++ b/cc/layer_painter.h @@ -1,3 +1,26 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef LayerPainterChromium_h +#define LayerPainterChromium_h + +#if USE(ACCELERATED_COMPOSITING) + +class SkCanvas; + +namespace cc { + +class FloatRect; +class IntRect; + +class LayerPainterChromium { +public: + virtual ~LayerPainterChromium() { } + virtual void paint(SkCanvas*, const IntRect& contentRect, FloatRect& opaque) = 0; +}; + +} // namespace cc +#endif // USE(ACCELERATED_COMPOSITING) +#endif // LayerPainterChromium_h diff --git a/cc/CCLayerQuad.cpp b/cc/layer_quad.cc similarity index 100% rename from cc/CCLayerQuad.cpp rename to cc/layer_quad.cc diff --git a/cc/layer_quad.h b/cc/layer_quad.h index 638cbb270ce9b2..8be296fbf3c5a9 100644 --- a/cc/layer_quad.h +++ b/cc/layer_quad.h @@ -1,3 +1,106 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef CCLayerQuad_h +#define CCLayerQuad_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "FloatPoint3D.h" +#include "FloatQuad.h" + +static const float kAntiAliasingInflateDistance = 0.5f; + +namespace cc { + +class CCLayerQuad { +public: + class Edge { + public: + Edge() + : m_x(0) + , m_y(0) + , m_z(0) + { + } + Edge(const FloatPoint&, const FloatPoint&); + + float x() const { return m_x; } + float y() const { return m_y; } + float z() const { return m_z; } + + void setX(float x) { m_x = x; } + void setY(float y) { m_y = y; } + void setZ(float z) { m_z = z; } + void set(float x, float y, float z) + { + m_x = x; + m_y = y; + m_z = z; + } + + void moveX(float dx) { m_x += dx; } + void moveY(float dy) { m_y += dy; } + void moveZ(float dz) { m_z += dz; } + void move(float dx, float dy, float dz) + { + m_x += dx; + m_y += dy; + m_z += dz; + } + + void scaleX(float sx) { m_x *= sx; } + void scaleY(float sy) { m_y *= sy; } + void scaleZ(float sz) { m_z *= sz; } + void scale(float sx, float sy, float sz) + { + m_x *= sx; + m_y *= sy; + m_z *= sz; + } + void scale(float s) { scale(s, s, s); } + + FloatPoint intersect(const Edge& e) const + { + return FloatPoint( + (y() * e.z() - e.y() * z()) / (x() * e.y() - e.x() * y()), + (x() * e.z() - e.x() * z()) / (e.x() * y() - x() * e.y())); + } + + private: + float m_x; + float m_y; + float m_z; + }; + + CCLayerQuad(const Edge& left, const Edge& top, const Edge& right, const Edge& bottom); + CCLayerQuad(const FloatQuad&); + + Edge left() const { return m_left; } + Edge top() const { return m_top; } + Edge right() const { return m_right; } + Edge bottom() const { return m_bottom; } + + void inflateX(float dx) { m_left.moveZ(dx); m_right.moveZ(dx); } + void inflateY(float dy) { m_top.moveZ(dy); m_bottom.moveZ(dy); } + void inflate(float d) { inflateX(d); inflateY(d); } + void inflateAntiAliasingDistance() { inflate(kAntiAliasingInflateDistance); } + + FloatQuad floatQuad() const; + + void toFloatArray(float[12]) const; + +private: + Edge m_left; + Edge m_top; + Edge m_right; + Edge m_bottom; +}; + +} + +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCLayerSorter.cpp b/cc/layer_sorter.cc similarity index 100% rename from cc/CCLayerSorter.cpp rename to cc/layer_sorter.cc diff --git a/cc/layer_sorter.h b/cc/layer_sorter.h index 638cbb270ce9b2..d4ca664abbbbf3 100644 --- a/cc/layer_sorter.h +++ b/cc/layer_sorter.h @@ -1,3 +1,92 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCLayerSorter_h +#define CCLayerSorter_h + +#include "base/basictypes.h" +#include "CCLayerImpl.h" +#include "FloatPoint3D.h" +#include "FloatQuad.h" +#include "FloatRect.h" +#include +#include +#include + +namespace WebKit { +class WebTransformationMatrix; +} + +namespace cc { + +class CCLayerSorter { +public: + CCLayerSorter(); + ~CCLayerSorter(); + + typedef std::vector LayerList; + + void sort(LayerList::iterator first, LayerList::iterator last); + + // Holds various useful properties derived from a layer's 3D outline. + struct LayerShape { + LayerShape(); + LayerShape(float width, float height, const WebKit::WebTransformationMatrix& drawTransform); + + float layerZFromProjectedPoint(const FloatPoint&) const; + + FloatPoint3D layerNormal; + FloatPoint3D transformOrigin; + FloatQuad projectedQuad; + FloatRect projectedBounds; + }; + + enum ABCompareResult { + ABeforeB, + BBeforeA, + None + }; + + static ABCompareResult checkOverlap(LayerShape*, LayerShape*, float zThreshold, float& weight); + +private: + struct GraphEdge; + + struct GraphNode { + explicit GraphNode(CCLayerImpl* cclayer); + ~GraphNode(); + + CCLayerImpl* layer; + LayerShape shape; + Vector incoming; + Vector outgoing; + float incomingEdgeWeight; + }; + + struct GraphEdge { + GraphEdge(GraphNode* fromNode, GraphNode* toNode, float weight) : from(fromNode), to(toNode), weight(weight) { }; + + GraphNode* from; + GraphNode* to; + float weight; + }; + + typedef Vector NodeList; + typedef Vector EdgeList; + NodeList m_nodes; + EdgeList m_edges; + float m_zRange; + + typedef HashMap EdgeMap; + EdgeMap m_activeEdges; + + void createGraphNodes(LayerList::iterator first, LayerList::iterator last); + void createGraphEdges(); + void removeEdgeFromList(GraphEdge*, Vector&); + + DISALLOW_COPY_AND_ASSIGN(CCLayerSorter); +}; + +} +#endif diff --git a/cc/LayerTextureSubImage.cpp b/cc/layer_texture_sub_image.cc similarity index 100% rename from cc/LayerTextureSubImage.cpp rename to cc/layer_texture_sub_image.cc diff --git a/cc/layer_texture_sub_image.h b/cc/layer_texture_sub_image.h index 638cbb270ce9b2..2c6cc14744430b 100644 --- a/cc/layer_texture_sub_image.h +++ b/cc/layer_texture_sub_image.h @@ -1,3 +1,46 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef LayerTextureSubImage_h +#define LayerTextureSubImage_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "GraphicsTypes3D.h" +#include "IntRect.h" +#include "IntSize.h" +#include + +namespace WebKit { +class WebGraphicsContext3D; +} + +namespace cc { + +class LayerTextureSubImage { +public: + explicit LayerTextureSubImage(bool useMapSubForUpload); + ~LayerTextureSubImage(); + + void upload(const uint8_t* image, const IntRect& imageRect, + const IntRect& sourceRect, const IntSize& destOffset, + GC3Denum format, WebKit::WebGraphicsContext3D*); + +private: + void uploadWithTexSubImage(const uint8_t* image, const IntRect& imageRect, + const IntRect& sourceRect, const IntSize& destOffset, + GC3Denum format, WebKit::WebGraphicsContext3D*); + void uploadWithMapTexSubImage(const uint8_t* image, const IntRect& imageRect, + const IntRect& sourceRect, const IntSize& destOffset, + GC3Denum format, WebKit::WebGraphicsContext3D*); + + bool m_useMapTexSubImage; + size_t m_subImageSize; + OwnArrayPtr m_subImage; +}; + +} // namespace cc +#endif // USE(ACCELERATED_COMPOSITING) +#endif // LayerTextureSubImage_h diff --git a/cc/LayerTextureUpdater.cpp b/cc/layer_texture_updater.cc similarity index 100% rename from cc/LayerTextureUpdater.cpp rename to cc/layer_texture_updater.cc diff --git a/cc/layer_texture_updater.h b/cc/layer_texture_updater.h index 638cbb270ce9b2..89fc520475a64d 100644 --- a/cc/layer_texture_updater.h +++ b/cc/layer_texture_updater.h @@ -1,3 +1,69 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef LayerTextureUpdater_h +#define LayerTextureUpdater_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "CCPrioritizedTexture.h" +#include "GraphicsTypes3D.h" +#include + +namespace cc { + +class IntRect; +class IntSize; +class TextureManager; +struct CCRenderingStats; + +class LayerTextureUpdater : public RefCounted { +public: + // Allows texture uploaders to store per-tile resources. + class Texture { + public: + virtual ~Texture(); + + CCPrioritizedTexture* texture() { return m_texture.get(); } + void swapTextureWith(scoped_ptr& texture) { m_texture.swap(texture); } + virtual void prepareRect(const IntRect& /* sourceRect */, CCRenderingStats&) { } + virtual void updateRect(CCResourceProvider*, const IntRect& sourceRect, const IntSize& destOffset) = 0; + virtual bool backingResourceWasEvicted() const; + protected: + explicit Texture(scoped_ptr texture); + + private: + scoped_ptr m_texture; + }; + + LayerTextureUpdater() + { + turnOffVerifier(); // In the component build we don't have WTF threading initialized in this DLL so the thread verifier explodes. + } + + virtual ~LayerTextureUpdater() { } + + enum SampledTexelFormat { + SampledTexelFormatRGBA, + SampledTexelFormatBGRA, + SampledTexelFormatInvalid, + }; + virtual PassOwnPtr createTexture(CCPrioritizedTextureManager*) = 0; + // Returns the format of the texel uploaded by this interface. + // This format should not be confused by texture internal format. + // This format specifies the component order in the sampled texel. + // If the format is TexelFormatBGRA, vec4.x is blue and vec4.z is red. + virtual SampledTexelFormat sampledTexelFormat(GC3Denum textureFormat) = 0; + // The |resultingOpaqueRect| gives back a region of the layer that was painted opaque. If the layer is marked opaque in the updater, + // then this region should be ignored in preference for the entire layer's area. + virtual void prepareToUpdate(const IntRect& contentRect, const IntSize& tileSize, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, CCRenderingStats&) { } + + // Set true by the layer when it is known that the entire output is going to be opaque. + virtual void setOpaque(bool) { } +}; + +} // namespace cc +#endif // USE(ACCELERATED_COMPOSITING) +#endif // LayerTextureUpdater_h diff --git a/cc/CCLayerTilingData.cpp b/cc/layer_tiling_data.cc similarity index 100% rename from cc/CCLayerTilingData.cpp rename to cc/layer_tiling_data.cc diff --git a/cc/layer_tiling_data.h b/cc/layer_tiling_data.h index 638cbb270ce9b2..c73f0570c72f23 100644 --- a/cc/layer_tiling_data.h +++ b/cc/layer_tiling_data.h @@ -1,3 +1,101 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef CCLayerTilingData_h +#define CCLayerTilingData_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "base/basictypes.h" +#include "IntRect.h" +#include "Region.h" +#include "TilingData.h" +#include +#include +#include + +namespace cc { + +class CCLayerTilingData { +public: + enum BorderTexelOption { HasBorderTexels, NoBorderTexels }; + + ~CCLayerTilingData(); + + static PassOwnPtr create(const IntSize& tileSize, BorderTexelOption); + + bool hasEmptyBounds() const { return m_tilingData.hasEmptyBounds(); } + int numTilesX() const { return m_tilingData.numTilesX(); } + int numTilesY() const { return m_tilingData.numTilesY(); } + IntRect tileBounds(int i, int j) const { return m_tilingData.tileBounds(i, j); } + IntPoint textureOffset(int xIndex, int yIndex) const { return m_tilingData.textureOffset(xIndex, yIndex); } + + // Change the tile size. This may invalidate all the existing tiles. + void setTileSize(const IntSize&); + IntSize tileSize() const; + // Change the border texel setting. This may invalidate all existing tiles. + void setBorderTexelOption(BorderTexelOption); + bool hasBorderTexels() const { return m_tilingData.borderTexels(); } + + bool isEmpty() const { return hasEmptyBounds() || !tiles().size(); } + + const CCLayerTilingData& operator=(const CCLayerTilingData&); + + class Tile { + public: + Tile() : m_i(-1), m_j(-1) { } + virtual ~Tile() { } + + int i() const { return m_i; } + int j() const { return m_j; } + void moveTo(int i, int j) { m_i = i; m_j = j; } + + const IntRect& opaqueRect() const { return m_opaqueRect; } + void setOpaqueRect(const IntRect& opaqueRect) { m_opaqueRect = opaqueRect; } + private: + int m_i; + int m_j; + IntRect m_opaqueRect; + DISALLOW_COPY_AND_ASSIGN(Tile); + }; + // Default hash key traits for integers disallow 0 and -1 as a key, so + // use a custom hash trait which disallows -1 and -2 instead. + typedef std::pair TileMapKey; + struct TileMapKeyTraits : HashTraits { + static const bool emptyValueIsZero = false; + static const bool needsDestruction = false; + static TileMapKey emptyValue() { return std::make_pair(-1, -1); } + static void constructDeletedValue(TileMapKey& slot) { slot = std::make_pair(-2, -2); } + static bool isDeletedValue(TileMapKey value) { return value.first == -2 && value.second == -2; } + }; + typedef HashMap, DefaultHash::Hash, TileMapKeyTraits> TileMap; + + void addTile(PassOwnPtr, int, int); + PassOwnPtr takeTile(int, int); + Tile* tileAt(int, int) const; + const TileMap& tiles() const { return m_tiles; } + + void setBounds(const IntSize&); + IntSize bounds() const; + + void contentRectToTileIndices(const IntRect&, int &left, int &top, int &right, int &bottom) const; + IntRect tileRect(const Tile*) const; + + Region opaqueRegionInContentRect(const IntRect&) const; + + void reset(); + +protected: + CCLayerTilingData(const IntSize& tileSize, BorderTexelOption); + + TileMap m_tiles; + TilingData m_tilingData; +}; + +} + +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCLayerTreeHost.cpp b/cc/layer_tree_host.cc similarity index 100% rename from cc/CCLayerTreeHost.cpp rename to cc/layer_tree_host.cc diff --git a/cc/layer_tree_host.h b/cc/layer_tree_host.h index 638cbb270ce9b2..277b1f06352ce6 100644 --- a/cc/layer_tree_host.h +++ b/cc/layer_tree_host.h @@ -1,3 +1,297 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCLayerTreeHost_h +#define CCLayerTreeHost_h + +#include "base/basictypes.h" +#include "base/hash_tables.h" +#include "base/memory/ref_counted.h" +#include "base/memory/scoped_ptr.h" +#include "CCAnimationEvents.h" +#include "CCGraphicsContext.h" +#include "CCLayerTreeHostClient.h" +#include "CCLayerTreeHostCommon.h" +#include "CCOcclusionTracker.h" +#include "CCPrioritizedTextureManager.h" +#include "CCProxy.h" +#include "CCRenderingStats.h" +#include "IntRect.h" +#include "RateLimiter.h" +#include "scoped_ptr_vector.h" +#include "SkColor.h" +#include + +#if defined(COMPILER_GCC) +namespace BASE_HASH_NAMESPACE { +template<> +struct hash { + size_t operator()(WebKit::WebGraphicsContext3D* ptr) const { + return hash()(reinterpret_cast(ptr)); + } +}; +} // namespace BASE_HASH_NAMESPACE +#endif // COMPILER + +namespace cc { + +class CCFontAtlas; +class CCLayerChromium; +class CCLayerTreeHostImpl; +class CCLayerTreeHostImplClient; +class CCPrioritizedTextureManager; +class CCTextureUpdateQueue; +class HeadsUpDisplayLayerChromium; +class Region; +struct CCScrollAndScaleSet; + +struct CCLayerTreeSettings { + CCLayerTreeSettings(); + ~CCLayerTreeSettings(); + + bool acceleratePainting; + bool showFPSCounter; + bool showPlatformLayerTree; + bool showPaintRects; + bool showPropertyChangedRects; + bool showSurfaceDamageRects; + bool showScreenSpaceRects; + bool showReplicaScreenSpaceRects; + bool showOccludingRects; + bool renderVSyncEnabled; + double refreshRate; + size_t maxPartialTextureUpdates; + IntSize defaultTileSize; + IntSize maxUntiledLayerSize; + IntSize minimumOcclusionTrackingSize; + + bool showDebugInfo() const { return showPlatformLayerTree || showFPSCounter || showDebugRects(); } + bool showDebugRects() const { return showPaintRects || showPropertyChangedRects || showSurfaceDamageRects || showScreenSpaceRects || showReplicaScreenSpaceRects || showOccludingRects; } +}; + +// Provides information on an Impl's rendering capabilities back to the CCLayerTreeHost +struct RendererCapabilities { + RendererCapabilities(); + ~RendererCapabilities(); + + GC3Denum bestTextureFormat; + bool contextHasCachedFrontBuffer; + bool usingPartialSwap; + bool usingAcceleratedPainting; + bool usingSetVisibility; + bool usingSwapCompleteCallback; + bool usingGpuMemoryManager; + bool usingDiscardFramebuffer; + bool usingEglImage; + int maxTextureSize; +}; + +class CCLayerTreeHost : public RateLimiterClient { +public: + static scoped_ptr create(CCLayerTreeHostClient*, const CCLayerTreeSettings&); + virtual ~CCLayerTreeHost(); + + void setSurfaceReady(); + + // Returns true if any CCLayerTreeHost is alive. + static bool anyLayerTreeHostInstanceExists(); + + static bool needsFilterContext() { return s_needsFilterContext; } + static void setNeedsFilterContext(bool needsFilterContext) { s_needsFilterContext = needsFilterContext; } + bool needsSharedContext() const { return needsFilterContext() || settings().acceleratePainting; } + + // CCLayerTreeHost interface to CCProxy. + void willBeginFrame() { m_client->willBeginFrame(); } + void didBeginFrame() { m_client->didBeginFrame(); } + void updateAnimations(double monotonicFrameBeginTime); + void layout(); + void beginCommitOnImplThread(CCLayerTreeHostImpl*); + void finishCommitOnImplThread(CCLayerTreeHostImpl*); + void willCommit(); + void commitComplete(); + scoped_ptr createContext(); + scoped_ptr createInputHandler(); + virtual scoped_ptr createLayerTreeHostImpl(CCLayerTreeHostImplClient*); + void didLoseContext(); + enum RecreateResult { + RecreateSucceeded, + RecreateFailedButTryAgain, + RecreateFailedAndGaveUp, + }; + RecreateResult recreateContext(); + void didCommitAndDrawFrame() { m_client->didCommitAndDrawFrame(); } + void didCompleteSwapBuffers() { m_client->didCompleteSwapBuffers(); } + void deleteContentsTexturesOnImplThread(CCResourceProvider*); + virtual void acquireLayerTextures(); + // Returns false if we should abort this frame due to initialization failure. + bool initializeRendererIfNeeded(); + void updateLayers(CCTextureUpdateQueue&, size_t contentsMemoryLimitBytes); + + CCLayerTreeHostClient* client() { return m_client; } + + // Only used when compositing on the main thread. + void composite(); + void scheduleComposite(); + + // Composites and attempts to read back the result into the provided + // buffer. If it wasn't possible, e.g. due to context lost, will return + // false. + bool compositeAndReadback(void *pixels, const IntRect&); + + void finishAllRendering(); + + int commitNumber() const { return m_commitNumber; } + + void renderingStats(CCRenderingStats*) const; + + const RendererCapabilities& rendererCapabilities() const; + + // Test only hook + void loseContext(int numTimes); + + void setNeedsAnimate(); + // virtual for testing + virtual void setNeedsCommit(); + void setNeedsRedraw(); + bool commitRequested() const; + + void setAnimationEvents(scoped_ptr, double wallClockTime); + virtual void didAddAnimation(); + + LayerChromium* rootLayer() { return m_rootLayer.get(); } + const LayerChromium* rootLayer() const { return m_rootLayer.get(); } + void setRootLayer(scoped_refptr); + + const CCLayerTreeSettings& settings() const { return m_settings; } + + void setViewportSize(const IntSize& layoutViewportSize, const IntSize& deviceViewportSize); + + const IntSize& layoutViewportSize() const { return m_layoutViewportSize; } + const IntSize& deviceViewportSize() const { return m_deviceViewportSize; } + + void setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor); + + void setBackgroundColor(SkColor color) { m_backgroundColor = color; } + + void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; } + + CCPrioritizedTextureManager* contentsTextureManager() const; + + // Delete contents textures' backing resources until they use only bytesLimit bytes. This may + // be called on the impl thread while the main thread is running. + void reduceContentsTexturesMemoryOnImplThread(size_t bytesLimit, CCResourceProvider*); + // Returns true if there any evicted backing textures that have not been deleted. + bool evictedContentsTexturesBackingsExist() const; + // Retrieve the list of all contents textures' backings that have been evicted, to pass to the + // main thread to unlink them from their owning textures. + void getEvictedContentTexturesBackings(CCPrioritizedTextureManager::BackingVector&); + // Unlink the list of contents textures' backings from their owning textures on the main thread + // before updating layers. + void unlinkEvictedContentTexturesBackings(const CCPrioritizedTextureManager::BackingVector&); + // Deletes all evicted backings, unlinking them from their owning textures if needed. + // Returns true if this function had to unlink any backings from their owning texture when + // destroying them. If this was the case, the impl layer tree may contain invalid resources. + bool deleteEvictedContentTexturesBackings(); + + bool visible() const { return m_visible; } + void setVisible(bool); + + void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double durationSec); + + void applyScrollAndScale(const CCScrollAndScaleSet&); + void setImplTransform(const WebKit::WebTransformationMatrix&); + + void startRateLimiter(WebKit::WebGraphicsContext3D*); + void stopRateLimiter(WebKit::WebGraphicsContext3D*); + + // RateLimitClient implementation + virtual void rateLimit() OVERRIDE; + + bool bufferedUpdates(); + bool requestPartialTextureUpdate(); + void deleteTextureAfterCommit(scoped_ptr); + + void setDeviceScaleFactor(float); + float deviceScaleFactor() const { return m_deviceScaleFactor; } + + void setFontAtlas(scoped_ptr); + + HeadsUpDisplayLayerChromium* hudLayer() const { return m_hudLayer.get(); } + +protected: + CCLayerTreeHost(CCLayerTreeHostClient*, const CCLayerTreeSettings&); + bool initialize(); + +private: + typedef std::vector > LayerList; + + void initializeRenderer(); + + void update(LayerChromium*, CCTextureUpdateQueue&, const CCOcclusionTracker*); + bool paintLayerContents(const LayerList&, CCTextureUpdateQueue&); + bool paintMasksForRenderSurface(LayerChromium*, CCTextureUpdateQueue&); + + void updateLayers(LayerChromium*, CCTextureUpdateQueue&); + + void prioritizeTextures(const LayerList&, CCOverdrawMetrics&); + void setPrioritiesForSurfaces(size_t surfaceMemoryBytes); + void setPrioritiesForLayers(const LayerList&); + size_t calculateMemoryForRenderSurfaces(const LayerList& updateList); + + void animateLayers(double monotonicTime); + bool animateLayersRecursive(LayerChromium* current, double monotonicTime); + void setAnimationEventsRecursive(const CCAnimationEventsVector&, LayerChromium*, double wallClockTime); + + bool m_animating; + bool m_needsAnimateLayers; + + CCLayerTreeHostClient* m_client; + + int m_commitNumber; + CCRenderingStats m_renderingStats; + + scoped_ptr m_proxy; + bool m_rendererInitialized; + bool m_contextLost; + int m_numTimesRecreateShouldFail; + int m_numFailedRecreateAttempts; + + scoped_refptr m_rootLayer; + scoped_refptr m_hudLayer; + scoped_ptr m_fontAtlas; + + scoped_ptr m_contentsTextureManager; + scoped_ptr m_surfaceMemoryPlaceholder; + + CCLayerTreeSettings m_settings; + + IntSize m_layoutViewportSize; + IntSize m_deviceViewportSize; + float m_deviceScaleFactor; + + bool m_visible; + + typedef base::hash_map > RateLimiterMap; + RateLimiterMap m_rateLimiters; + + float m_pageScaleFactor; + float m_minPageScaleFactor, m_maxPageScaleFactor; + WebKit::WebTransformationMatrix m_implTransform; + bool m_triggerIdleUpdates; + + SkColor m_backgroundColor; + bool m_hasTransparentBackground; + + typedef ScopedPtrVector TextureList; + TextureList m_deleteTextureAfterCommitList; + size_t m_partialTextureUpdateRequests; + + static bool s_needsFilterContext; + + DISALLOW_COPY_AND_ASSIGN(CCLayerTreeHost); +}; + +} // namespace cc + +#endif diff --git a/cc/layer_tree_host_client.h b/cc/layer_tree_host_client.h index 638cbb270ce9b2..1c88a7542363c8 100644 --- a/cc/layer_tree_host_client.h +++ b/cc/layer_tree_host_client.h @@ -1,3 +1,43 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCLayerTreeHostClient_h +#define CCLayerTreeHostClient_h + +#include "base/memory/scoped_ptr.h" + +namespace WebKit { +class WebCompositorOutputSurface; +} + +namespace cc { +class CCInputHandler; +class IntSize; + +class CCLayerTreeHostClient { +public: + virtual void willBeginFrame() = 0; + // Marks finishing compositing-related tasks on the main thread. In threaded mode, this corresponds to didCommit(). + virtual void didBeginFrame() = 0; + virtual void animate(double frameBeginTime) = 0; + virtual void layout() = 0; + virtual void applyScrollAndScale(const IntSize& scrollDelta, float pageScale) = 0; + virtual scoped_ptr createOutputSurface() = 0; + virtual void didRecreateOutputSurface(bool success) = 0; + virtual scoped_ptr createInputHandler() = 0; + virtual void willCommit() = 0; + virtual void didCommit() = 0; + virtual void didCommitAndDrawFrame() = 0; + virtual void didCompleteSwapBuffers() = 0; + + // Used only in the single-threaded path. + virtual void scheduleComposite() = 0; + +protected: + virtual ~CCLayerTreeHostClient() { } +}; + +} + +#endif // CCLayerTreeHostClient_h diff --git a/cc/CCLayerTreeHostCommon.cpp b/cc/layer_tree_host_common.cc similarity index 100% rename from cc/CCLayerTreeHostCommon.cpp rename to cc/layer_tree_host_common.cc diff --git a/cc/layer_tree_host_common.h b/cc/layer_tree_host_common.h index 638cbb270ce9b2..01dc41e40dc332 100644 --- a/cc/layer_tree_host_common.h +++ b/cc/layer_tree_host_common.h @@ -1,3 +1,96 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCLayerTreeHostCommon_h +#define CCLayerTreeHostCommon_h + +#include "base/memory/ref_counted.h" +#include "cc/scoped_ptr_vector.h" +#include "IntRect.h" +#include "IntSize.h" +#include +#include + +namespace cc { + +class CCLayerImpl; +class CCLayerSorter; +class LayerChromium; + +class CCLayerTreeHostCommon { +public: + static IntRect calculateVisibleRect(const IntRect& targetSurfaceRect, const IntRect& layerBoundRect, const WebKit::WebTransformationMatrix&); + + static void calculateDrawTransforms(LayerChromium* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, int maxTextureSize, std::vector >& renderSurfaceLayerList); + static void calculateDrawTransforms(CCLayerImpl* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, CCLayerSorter*, int maxTextureSize, std::vector& renderSurfaceLayerList); + + // Performs hit testing for a given renderSurfaceLayerList. + static CCLayerImpl* findLayerThatIsHitByPoint(const IntPoint& viewportPoint, std::vector& renderSurfaceLayerList); + + template static bool renderSurfaceContributesToTarget(LayerType*, int targetSurfaceLayerID); + + // Returns a layer with the given id if one exists in the subtree starting + // from the given root layer (including mask and replica layers). + template static LayerType* findLayerInSubtree(LayerType* rootLayer, int layerId); + + static LayerChromium* getChildAsRawPtr(const std::vector >& children, size_t index) + { + return children[index].get(); + } + + static CCLayerImpl* getChildAsRawPtr(const ScopedPtrVector& children, size_t index) + { + return children[index]; + } + + struct ScrollUpdateInfo { + int layerId; + IntSize scrollDelta; + }; +}; + +struct CCScrollAndScaleSet { + CCScrollAndScaleSet(); + ~CCScrollAndScaleSet(); + + Vector scrolls; + float pageScaleDelta; +}; + +template +bool CCLayerTreeHostCommon::renderSurfaceContributesToTarget(LayerType* layer, int targetSurfaceLayerID) +{ + // A layer will either contribute its own content, or its render surface's content, to + // the target surface. The layer contributes its surface's content when both the + // following are true: + // (1) The layer actually has a renderSurface, and + // (2) The layer's renderSurface is not the same as the targetSurface. + // + // Otherwise, the layer just contributes itself to the target surface. + + return layer->renderSurface() && layer->id() != targetSurfaceLayerID; +} + +template +LayerType* CCLayerTreeHostCommon::findLayerInSubtree(LayerType* rootLayer, int layerId) +{ + if (rootLayer->id() == layerId) + return rootLayer; + + if (rootLayer->maskLayer() && rootLayer->maskLayer()->id() == layerId) + return rootLayer->maskLayer(); + + if (rootLayer->replicaLayer() && rootLayer->replicaLayer()->id() == layerId) + return rootLayer->replicaLayer(); + + for (size_t i = 0; i < rootLayer->children().size(); ++i) { + if (LayerType* found = findLayerInSubtree(getChildAsRawPtr(rootLayer->children(), i), layerId)) + return found; + } + return 0; +} + +} // namespace cc + +#endif diff --git a/cc/CCLayerTreeHostImpl.cpp b/cc/layer_tree_host_impl.cc similarity index 100% rename from cc/CCLayerTreeHostImpl.cpp rename to cc/layer_tree_host_impl.cc diff --git a/cc/layer_tree_host_impl.h b/cc/layer_tree_host_impl.h index 638cbb270ce9b2..297f619d00f992 100644 --- a/cc/layer_tree_host_impl.h +++ b/cc/layer_tree_host_impl.h @@ -1,3 +1,356 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCLayerTreeHostImpl_h +#define CCLayerTreeHostImpl_h + +#include "base/basictypes.h" +#include "base/time.h" +#include "CCAnimationEvents.h" +#include "CCInputHandler.h" +#include "CCLayerSorter.h" +#include "CCRenderPass.h" +#include "CCRenderPassSink.h" +#include "CCRenderer.h" +#include "SkColor.h" +#include +#include +#include + +namespace cc { + +class CCCompletionEvent; +class CCDebugRectHistory; +class CCFrameRateCounter; +class CCHeadsUpDisplayLayerImpl; +class CCLayerImpl; +class CCLayerTreeHostImplTimeSourceAdapter; +class CCPageScaleAnimation; +class CCRenderPassDrawQuad; +class CCResourceProvider; +struct RendererCapabilities; +struct CCRenderingStats; + +// CCLayerTreeHost->CCProxy callback interface. +class CCLayerTreeHostImplClient { +public: + virtual void didLoseContextOnImplThread() = 0; + virtual void onSwapBuffersCompleteOnImplThread() = 0; + virtual void onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds) = 0; + virtual void onCanDrawStateChanged(bool canDraw) = 0; + virtual void setNeedsRedrawOnImplThread() = 0; + virtual void setNeedsCommitOnImplThread() = 0; + virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr, double wallClockTime) = 0; + virtual void releaseContentsTexturesOnImplThread() = 0; +}; + +// CCPinchZoomViewport models the bounds and offset of the viewport that is used during a pinch-zoom operation. +// It tracks the layout-space dimensions of the viewport before any applied scale, and then tracks the layout-space +// coordinates of the viewport respecting the pinch settings. +class CCPinchZoomViewport { +public: + CCPinchZoomViewport(); + + float totalPageScaleFactor() const; + + void setPageScaleFactor(float factor) { m_pageScaleFactor = factor; } + float pageScaleFactor() const { return m_pageScaleFactor; } + + void setPageScaleDelta(float delta); + float pageScaleDelta() const { return m_pageScaleDelta; } + + float minPageScaleFactor() const { return m_minPageScaleFactor; } + float maxPageScaleFactor() const { return m_maxPageScaleFactor; } + + void setSentPageScaleDelta(float delta) { m_sentPageScaleDelta = delta; } + float sentPageScaleDelta() const { return m_sentPageScaleDelta; } + + // Returns true if the passed parameters were different from those previously + // cached. + bool setPageScaleFactorAndLimits(float pageScaleFactor, + float minPageScaleFactor, + float maxPageScaleFactor); + + // Returns the bounds and offset of the scaled and translated viewport to use for pinch-zoom. + FloatRect bounds() const; + const FloatPoint& scrollDelta() const { return m_pinchViewportScrollDelta; } + + void setLayoutViewportSize(const FloatSize& size) { m_layoutViewportSize = size; } + + // Apply the scroll offset in layout space to the offset of the pinch-zoom viewport. The viewport cannot be + // scrolled outside of the layout viewport bounds. Returns the component of the scroll that is un-applied due to + // this constraint. + FloatSize applyScroll(FloatSize&); + + WebKit::WebTransformationMatrix implTransform() const; + +private: + float m_pageScaleFactor; + float m_pageScaleDelta; + float m_sentPageScaleDelta; + float m_maxPageScaleFactor; + float m_minPageScaleFactor; + + FloatPoint m_pinchViewportScrollDelta; + FloatSize m_layoutViewportSize; +}; + +// CCLayerTreeHostImpl owns the CCLayerImpl tree as well as associated rendering state +class CCLayerTreeHostImpl : public CCInputHandlerClient, + public CCRendererClient, + public WebKit::WebCompositorOutputSurfaceClient { + typedef std::vector CCLayerList; + +public: + static scoped_ptr create(const CCLayerTreeSettings&, CCLayerTreeHostImplClient*); + virtual ~CCLayerTreeHostImpl(); + + // CCInputHandlerClient implementation + virtual CCInputHandlerClient::ScrollStatus scrollBegin(const IntPoint&, CCInputHandlerClient::ScrollInputType) OVERRIDE; + virtual void scrollBy(const IntPoint&, const IntSize&) OVERRIDE; + virtual void scrollEnd() OVERRIDE; + virtual void pinchGestureBegin() OVERRIDE; + virtual void pinchGestureUpdate(float, const IntPoint&) OVERRIDE; + virtual void pinchGestureEnd() OVERRIDE; + virtual void startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTime, double duration) OVERRIDE; + virtual void scheduleAnimation() OVERRIDE; + + struct FrameData : public CCRenderPassSink { + FrameData(); + ~FrameData(); + + Vector occludingScreenSpaceRects; + CCRenderPassList renderPasses; + CCRenderPassIdHashMap renderPassesById; + CCLayerList* renderSurfaceLayerList; + CCLayerList willDrawLayers; + + // CCRenderPassSink implementation. + virtual void appendRenderPass(scoped_ptr) OVERRIDE; + }; + + // Virtual for testing. + virtual void beginCommit(); + virtual void commitComplete(); + virtual void animate(double monotonicTime, double wallClockTime); + + // Returns false if problems occured preparing the frame, and we should try + // to avoid displaying the frame. If prepareToDraw is called, + // didDrawAllLayers must also be called, regardless of whether drawLayers is + // called between the two. + virtual bool prepareToDraw(FrameData&); + virtual void drawLayers(const FrameData&); + // Must be called if and only if prepareToDraw was called. + void didDrawAllLayers(const FrameData&); + + // CCRendererClient implementation + virtual const IntSize& deviceViewportSize() const OVERRIDE; + virtual const CCLayerTreeSettings& settings() const OVERRIDE; + virtual void didLoseContext() OVERRIDE; + virtual void onSwapBuffersComplete() OVERRIDE; + virtual void setFullRootLayerDamage() OVERRIDE; + virtual void releaseContentsTextures() OVERRIDE; + virtual void setMemoryAllocationLimitBytes(size_t) OVERRIDE; + + // WebCompositorOutputSurfaceClient implementation. + virtual void onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds) OVERRIDE; + + // Implementation + bool canDraw(); + CCGraphicsContext* context() const; + + std::string layerTreeAsText() const; + + void finishAllRendering(); + int sourceAnimationFrameNumber() const; + + bool initializeRenderer(scoped_ptr); + bool isContextLost(); + CCRenderer* renderer() { return m_renderer.get(); } + const RendererCapabilities& rendererCapabilities() const; + + bool swapBuffers(); + + void readback(void* pixels, const IntRect&); + + void setRootLayer(scoped_ptr); + CCLayerImpl* rootLayer() { return m_rootLayerImpl.get(); } + + void setHudLayer(CCHeadsUpDisplayLayerImpl* layerImpl) { m_hudLayerImpl = layerImpl; } + CCHeadsUpDisplayLayerImpl* hudLayer() { return m_hudLayerImpl; } + + // Release ownership of the current layer tree and replace it with an empty + // tree. Returns the root layer of the detached tree. + scoped_ptr detachLayerTree(); + + CCLayerImpl* rootScrollLayer() const { return m_rootScrollLayerImpl; } + + bool visible() const { return m_visible; } + void setVisible(bool); + + int sourceFrameNumber() const { return m_sourceFrameNumber; } + void setSourceFrameNumber(int frameNumber) { m_sourceFrameNumber = frameNumber; } + + bool contentsTexturesPurged() const { return m_contentsTexturesPurged; } + void setContentsTexturesPurged(); + void resetContentsTexturesPurged(); + size_t memoryAllocationLimitBytes() const { return m_memoryAllocationLimitBytes; } + + void setViewportSize(const IntSize& layoutViewportSize, const IntSize& deviceViewportSize); + const IntSize& layoutViewportSize() const { return m_layoutViewportSize; } + + float deviceScaleFactor() const { return m_deviceScaleFactor; } + void setDeviceScaleFactor(float); + + float pageScaleFactor() const; + void setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor); + + scoped_ptr processScrollDeltas(); + WebKit::WebTransformationMatrix implTransform() const; + + void startPageScaleAnimation(const IntSize& tragetPosition, bool useAnchor, float scale, double durationSec); + + SkColor backgroundColor() const { return m_backgroundColor; } + void setBackgroundColor(SkColor color) { m_backgroundColor = color; } + + bool hasTransparentBackground() const { return m_hasTransparentBackground; } + void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; } + + bool needsAnimateLayers() const { return m_needsAnimateLayers; } + void setNeedsAnimateLayers() { m_needsAnimateLayers = true; } + + void setNeedsRedraw(); + + void renderingStats(CCRenderingStats*) const; + + void updateRootScrollLayerImplTransform(); + + CCFrameRateCounter* fpsCounter() const { return m_fpsCounter.get(); } + CCDebugRectHistory* debugRectHistory() const { return m_debugRectHistory.get(); } + CCResourceProvider* resourceProvider() const { return m_resourceProvider.get(); } + + class CullRenderPassesWithCachedTextures { + public: + bool shouldRemoveRenderPass(const CCRenderPassDrawQuad&, const FrameData&) const; + + // Iterates from the root first, in order to remove the surfaces closest + // to the root with cached textures, and all surfaces that draw into + // them. + size_t renderPassListBegin(const CCRenderPassList& list) const { return list.size() - 1; } + size_t renderPassListEnd(const CCRenderPassList&) const { return 0 - 1; } + size_t renderPassListNext(size_t it) const { return it - 1; } + + CullRenderPassesWithCachedTextures(CCRenderer& renderer) : m_renderer(renderer) { } + private: + CCRenderer& m_renderer; + }; + + class CullRenderPassesWithNoQuads { + public: + bool shouldRemoveRenderPass(const CCRenderPassDrawQuad&, const FrameData&) const; + + // Iterates in draw order, so that when a surface is removed, and its + // target becomes empty, then its target can be removed also. + size_t renderPassListBegin(const CCRenderPassList&) const { return 0; } + size_t renderPassListEnd(const CCRenderPassList& list) const { return list.size(); } + size_t renderPassListNext(size_t it) const { return it + 1; } + }; + + template + static void removeRenderPasses(RenderPassCuller, FrameData&); + +protected: + CCLayerTreeHostImpl(const CCLayerTreeSettings&, CCLayerTreeHostImplClient*); + + void animatePageScale(double monotonicTime); + void animateScrollbars(double monotonicTime); + + // Exposed for testing. + void calculateRenderSurfaceLayerList(CCLayerList&); + + // Virtual for testing. + virtual void animateLayers(double monotonicTime, double wallClockTime); + + // Virtual for testing. + virtual base::TimeDelta lowFrequencyAnimationInterval() const; + + CCLayerTreeHostImplClient* m_client; + int m_sourceFrameNumber; + +private: + void computeDoubleTapZoomDeltas(CCScrollAndScaleSet* scrollInfo); + void computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo); + void makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale); + + void setPageScaleDelta(float); + void updateMaxScrollPosition(); + void trackDamageForAllSurfaces(CCLayerImpl* rootDrawLayer, const CCLayerList& renderSurfaceLayerList); + + // Returns false if the frame should not be displayed. This function should + // only be called from prepareToDraw, as didDrawAllLayers must be called + // if this helper function is called. + bool calculateRenderPasses(FrameData&); + void animateLayersRecursive(CCLayerImpl*, double monotonicTime, double wallClockTime, CCAnimationEventsVector*, bool& didAnimate, bool& needsAnimateLayers); + void setBackgroundTickingEnabled(bool); + IntSize contentSize() const; + + void sendDidLoseContextRecursive(CCLayerImpl*); + void clearRenderSurfaces(); + bool ensureRenderSurfaceLayerList(); + void clearCurrentlyScrollingLayer(); + + void animateScrollbarsRecursive(CCLayerImpl*, double monotonicTime); + + void dumpRenderSurfaces(std::string*, int indent, const CCLayerImpl*) const; + + scoped_ptr m_context; + OwnPtr m_resourceProvider; + OwnPtr m_renderer; + scoped_ptr m_rootLayerImpl; + CCLayerImpl* m_rootScrollLayerImpl; + CCLayerImpl* m_currentlyScrollingLayerImpl; + CCHeadsUpDisplayLayerImpl* m_hudLayerImpl; + int m_scrollingLayerIdFromPreviousTree; + bool m_scrollDeltaIsInScreenSpace; + CCLayerTreeSettings m_settings; + IntSize m_layoutViewportSize; + IntSize m_deviceViewportSize; + float m_deviceScaleFactor; + bool m_visible; + bool m_contentsTexturesPurged; + size_t m_memoryAllocationLimitBytes; + + SkColor m_backgroundColor; + bool m_hasTransparentBackground; + + // If this is true, it is necessary to traverse the layer tree ticking the animators. + bool m_needsAnimateLayers; + bool m_pinchGestureActive; + IntPoint m_previousPinchAnchor; + + OwnPtr m_pageScaleAnimation; + + // This is used for ticking animations slowly when hidden. + OwnPtr m_timeSourceClientAdapter; + + CCLayerSorter m_layerSorter; + + // List of visible layers for the most recently prepared frame. Used for + // rendering and input event hit testing. + CCLayerList m_renderSurfaceLayerList; + + CCPinchZoomViewport m_pinchZoomViewport; + + OwnPtr m_fpsCounter; + OwnPtr m_debugRectHistory; + + size_t m_numImplThreadScrolls; + size_t m_numMainThreadScrolls; + + DISALLOW_COPY_AND_ASSIGN(CCLayerTreeHostImpl); +}; + +}; + +#endif diff --git a/cc/CCMathUtil.cpp b/cc/math_util.cc similarity index 100% rename from cc/CCMathUtil.cpp rename to cc/math_util.cc diff --git a/cc/math_util.h b/cc/math_util.h index 638cbb270ce9b2..ed3848e6f4b7fb 100644 --- a/cc/math_util.h +++ b/cc/math_util.h @@ -1,3 +1,107 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCMathUtil_h +#define CCMathUtil_h + +#include "FloatPoint.h" +#include "FloatPoint3D.h" + +namespace WebKit { +class WebTransformationMatrix; +} + +namespace cc { + +class IntRect; +class FloatRect; +class FloatQuad; + +struct HomogeneousCoordinate { + HomogeneousCoordinate(double newX, double newY, double newZ, double newW) + : x(newX) + , y(newY) + , z(newZ) + , w(newW) + { + } + + bool shouldBeClipped() const + { + return w <= 0; + } + + FloatPoint cartesianPoint2d() const + { + if (w == 1) + return FloatPoint(x, y); + + // For now, because this code is used privately only by CCMathUtil, it should never be called when w == 0, and we do not yet need to handle that case. + ASSERT(w); + double invW = 1.0 / w; + return FloatPoint(x * invW, y * invW); + } + + FloatPoint3D cartesianPoint3d() const + { + if (w == 1) + return FloatPoint3D(x, y, z); + + // For now, because this code is used privately only by CCMathUtil, it should never be called when w == 0, and we do not yet need to handle that case. + ASSERT(w); + double invW = 1.0 / w; + return FloatPoint3D(x * invW, y * invW, z * invW); + } + + double x; + double y; + double z; + double w; +}; + +class CCMathUtil { +public: + + // Background: WebTransformationMatrix code in WebCore does not do the right thing in + // mapRect / mapQuad / projectQuad when there is a perspective projection that causes + // one of the transformed vertices to go to w < 0. In those cases, it is necessary to + // perform clipping in homogeneous coordinates, after applying the transform, before + // dividing-by-w to convert to cartesian coordinates. + // + // These functions return the axis-aligned rect that encloses the correctly clipped, + // transformed polygon. + static IntRect mapClippedRect(const WebKit::WebTransformationMatrix&, const IntRect&); + static FloatRect mapClippedRect(const WebKit::WebTransformationMatrix&, const FloatRect&); + static FloatRect projectClippedRect(const WebKit::WebTransformationMatrix&, const FloatRect&); + + // Returns an array of vertices that represent the clipped polygon. After returning, indexes from + // 0 to numVerticesInClippedQuad are valid in the clippedQuad array. Note that + // numVerticesInClippedQuad may be zero, which means the entire quad was clipped, and + // none of the vertices in the array are valid. + static void mapClippedQuad(const WebKit::WebTransformationMatrix&, const FloatQuad& srcQuad, FloatPoint clippedQuad[8], int& numVerticesInClippedQuad); + + static FloatRect computeEnclosingRectOfVertices(FloatPoint vertices[], int numVertices); + static FloatRect computeEnclosingClippedRect(const HomogeneousCoordinate& h1, const HomogeneousCoordinate& h2, const HomogeneousCoordinate& h3, const HomogeneousCoordinate& h4); + + // NOTE: These functions do not do correct clipping against w = 0 plane, but they + // correctly detect the clipped condition via the boolean clipped. + static FloatQuad mapQuad(const WebKit::WebTransformationMatrix&, const FloatQuad&, bool& clipped); + static FloatPoint mapPoint(const WebKit::WebTransformationMatrix&, const FloatPoint&, bool& clipped); + static FloatPoint3D mapPoint(const WebKit::WebTransformationMatrix&, const FloatPoint3D&, bool& clipped); + static FloatQuad projectQuad(const WebKit::WebTransformationMatrix&, const FloatQuad&, bool& clipped); + static FloatPoint projectPoint(const WebKit::WebTransformationMatrix&, const FloatPoint&, bool& clipped); + + static void flattenTransformTo2d(WebKit::WebTransformationMatrix&); + + // Returns the smallest angle between the given two vectors in degrees. Neither vector is + // assumed to be normalized. + static float smallestAngleBetweenVectors(const FloatSize&, const FloatSize&); + + // Projects the |source| vector onto |destination|. Neither vector is assumed to be normalized. + static FloatSize projectVector(const FloatSize& source, const FloatSize& destination); +}; + +} // namespace cc + +#endif // #define CCMathUtil_h diff --git a/cc/CCOcclusionTracker.cpp b/cc/occlusion_tracker.cc similarity index 100% rename from cc/CCOcclusionTracker.cpp rename to cc/occlusion_tracker.cc diff --git a/cc/occlusion_tracker.h b/cc/occlusion_tracker.h index 638cbb270ce9b2..c2526cdc38eb04 100644 --- a/cc/occlusion_tracker.h +++ b/cc/occlusion_tracker.h @@ -1,3 +1,105 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCOcclusionTracker_h +#define CCOcclusionTracker_h + +#include "base/basictypes.h" +#include "CCLayerIterator.h" +#include "FloatQuad.h" +#include "Region.h" + +namespace cc { +class CCOverdrawMetrics; +class CCLayerImpl; +class CCRenderSurface; +class LayerChromium; +class RenderSurfaceChromium; + +// This class is used to track occlusion of layers while traversing them in a front-to-back order. As each layer is visited, one of the +// methods in this class is called to notify it about the current target surface. +// Then, occlusion in the content space of the current layer may be queried, via methods such as occluded() and unoccludedContentRect(). +// If the current layer owns a RenderSurface, then occlusion on that RenderSurface may also be queried via surfaceOccluded() and surfaceUnoccludedContentRect(). +// Finally, once finished with the layer, occlusion behind the layer should be marked by calling markOccludedBehindLayer(). +template +class CCOcclusionTrackerBase { +public: + CCOcclusionTrackerBase(IntRect rootTargetRect, bool recordMetricsForFrame); + + // Called at the beginning of each step in the CCLayerIterator's front-to-back traversal. + void enterLayer(const CCLayerIteratorPosition&); + // Called at the end of each step in the CCLayerIterator's front-to-back traversal. + void leaveLayer(const CCLayerIteratorPosition&); + + // Returns true if the given rect in content space for the layer is fully occluded in either screen space or the layer's target surface. + bool occluded(const LayerType*, const IntRect& contentRect, bool* hasOcclusionFromOutsideTargetSurface = 0) const; + // Gives an unoccluded sub-rect of |contentRect| in the content space of the layer. Used when considering occlusion for a layer that paints/draws something. + IntRect unoccludedContentRect(const LayerType*, const IntRect& contentRect, bool* hasOcclusionFromOutsideTargetSurface = 0) const; + + // Gives an unoccluded sub-rect of |contentRect| in the content space of the renderTarget owned by the layer. + // Used when considering occlusion for a contributing surface that is rendering into another target. + IntRect unoccludedContributingSurfaceContentRect(const LayerType*, bool forReplica, const IntRect& contentRect, bool* hasOcclusionFromOutsideTargetSurface = 0) const; + + // Report operations for recording overdraw metrics. + CCOverdrawMetrics& overdrawMetrics() const { return *m_overdrawMetrics.get(); } + + // Gives the region of the screen that is not occluded by something opaque. + Region computeVisibleRegionInScreen() const { return subtract(Region(m_rootTargetRect), m_stack.last().occlusionInScreen); } + + void setMinimumTrackingSize(const IntSize& size) { m_minimumTrackingSize = size; } + + // The following is used for visualization purposes. + void setOccludingScreenSpaceRectsContainer(Vector* rects) { m_occludingScreenSpaceRects = rects; } + +protected: + struct StackObject { + StackObject() : target(0) { } + StackObject(const LayerType* target) : target(target) { } + const LayerType* target; + Region occlusionInScreen; + Region occlusionInTarget; + }; + + // The stack holds occluded regions for subtrees in the RenderSurface-Layer tree, so that when we leave a subtree we may + // apply a mask to it, but not to the parts outside the subtree. + // - The first time we see a new subtree under a target, we add that target to the top of the stack. This can happen as a layer representing itself, or as a target surface. + // - When we visit a target surface, we apply its mask to its subtree, which is at the top of the stack. + // - When we visit a layer representing itself, we add its occlusion to the current subtree, which is at the top of the stack. + // - When we visit a layer representing a contributing surface, the current target will never be the top of the stack since we just came from the contributing surface. + // We merge the occlusion at the top of the stack with the new current subtree. This new target is pushed onto the stack if not already there. + Vector m_stack; + + // Allow tests to override this. + virtual IntRect layerClipRectInTarget(const LayerType*) const; + +private: + // Called when visiting a layer representing itself. If the target was not already current, then this indicates we have entered a new surface subtree. + void enterRenderTarget(const LayerType* newTarget); + + // Called when visiting a layer representing a target surface. This indicates we have visited all the layers within the surface, and we may + // perform any surface-wide operations. + void finishedRenderTarget(const LayerType* finishedTarget); + + // Called when visiting a layer representing a contributing surface. This indicates that we are leaving our current surface, and + // entering the new one. We then perform any operations required for merging results from the child subtree into its parent. + void leaveToRenderTarget(const LayerType* newTarget); + + // Add the layer's occlusion to the tracked state. + void markOccludedBehindLayer(const LayerType*); + + IntRect m_rootTargetRect; + OwnPtr m_overdrawMetrics; + IntSize m_minimumTrackingSize; + + // This is used for visualizing the occlusion tracking process. + Vector* m_occludingScreenSpaceRects; + + DISALLOW_COPY_AND_ASSIGN(CCOcclusionTrackerBase); +}; + +typedef CCOcclusionTrackerBase CCOcclusionTracker; +typedef CCOcclusionTrackerBase CCOcclusionTrackerImpl; + +} +#endif // CCOcclusionTracker_h diff --git a/cc/CCOverdrawMetrics.cpp b/cc/overdraw_metrics.cc similarity index 100% rename from cc/CCOverdrawMetrics.cpp rename to cc/overdraw_metrics.cc diff --git a/cc/overdraw_metrics.h b/cc/overdraw_metrics.h index 638cbb270ce9b2..b907a64b4c2cca 100644 --- a/cc/overdraw_metrics.h +++ b/cc/overdraw_metrics.h @@ -1,3 +1,97 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCOverdrawMetrics_h +#define CCOverdrawMetrics_h + +#include + +namespace WebKit { +class WebTransformationMatrix; +} + +namespace cc { +class IntRect; +class CCLayerTreeHost; +class CCLayerTreeHostImpl; + +// FIXME: compute overdraw metrics only occasionally, not every frame. +class CCOverdrawMetrics { +public: + static PassOwnPtr create(bool recordMetricsForFrame) { return adoptPtr(new CCOverdrawMetrics(recordMetricsForFrame)); } + + // These methods are used for saving metrics during update/commit. + + // Record pixels painted by WebKit into the texture updater, but does not mean the pixels were rasterized in main memory. + void didPaint(const IntRect& paintedRect); + // Records that an invalid tile was culled and did not need to be painted/uploaded, and did not contribute to other tiles needing to be painted. + void didCullTileForUpload(); + // Records pixels that were uploaded to texture memory. + void didUpload(const WebKit::WebTransformationMatrix& transformToTarget, const IntRect& uploadRect, const IntRect& opaqueRect); + // Record contents texture(s) behind present using the given number of bytes. + void didUseContentsTextureMemoryBytes(size_t contentsTextureUseBytes); + // Record RenderSurface texture(s) being present using the given number of bytes. + void didUseRenderSurfaceTextureMemoryBytes(size_t renderSurfaceUseBytes); + + // These methods are used for saving metrics during draw. + + // Record pixels that were not drawn to screen. + void didCullForDrawing(const WebKit::WebTransformationMatrix& transformToTarget, const IntRect& beforeCullRect, const IntRect& afterCullRect); + // Record pixels that were drawn to screen. + void didDraw(const WebKit::WebTransformationMatrix& transformToTarget, const IntRect& afterCullRect, const IntRect& opaqueRect); + + void recordMetrics(const CCLayerTreeHost*) const; + void recordMetrics(const CCLayerTreeHostImpl*) const; + + // Accessors for tests. + float pixelsDrawnOpaque() const { return m_pixelsDrawnOpaque; } + float pixelsDrawnTranslucent() const { return m_pixelsDrawnTranslucent; } + float pixelsCulledForDrawing() const { return m_pixelsCulledForDrawing; } + float pixelsPainted() const { return m_pixelsPainted; } + float pixelsUploadedOpaque() const { return m_pixelsUploadedOpaque; } + float pixelsUploadedTranslucent() const { return m_pixelsUploadedTranslucent; } + int tilesCulledForUpload() const { return m_tilesCulledForUpload; } + +private: + enum MetricsType { + UpdateAndCommit, + DrawingToScreen + }; + + explicit CCOverdrawMetrics(bool recordMetricsForFrame); + + template + void recordMetricsInternal(MetricsType, const LayerTreeHostType*) const; + + // When false this class is a giant no-op. + bool m_recordMetricsForFrame; + + // These values are used for saving metrics during update/commit. + + // Count of pixels that were painted due to invalidation. + float m_pixelsPainted; + // Count of pixels uploaded to textures and known to be opaque. + float m_pixelsUploadedOpaque; + // Count of pixels uploaded to textures and not known to be opaque. + float m_pixelsUploadedTranslucent; + // Count of tiles that were invalidated but not uploaded. + int m_tilesCulledForUpload; + // Count the number of bytes in contents textures. + unsigned long long m_contentsTextureUseBytes; + // Count the number of bytes in RenderSurface textures. + unsigned long long m_renderSurfaceTextureUseBytes; + + // These values are used for saving metrics during draw. + + // Count of pixels that are opaque (and thus occlude). Ideally this is no more than wiewport width x height. + float m_pixelsDrawnOpaque; + // Count of pixels that are possibly translucent, and cannot occlude. + float m_pixelsDrawnTranslucent; + // Count of pixels not drawn as they are occluded by somthing opaque. + float m_pixelsCulledForDrawing; +}; + +} // namespace cc + +#endif diff --git a/cc/CCPageScaleAnimation.cpp b/cc/page_scale_animation.cc similarity index 100% rename from cc/CCPageScaleAnimation.cpp rename to cc/page_scale_animation.cc diff --git a/cc/page_scale_animation.h b/cc/page_scale_animation.h index 638cbb270ce9b2..f597026f90e786 100644 --- a/cc/page_scale_animation.h +++ b/cc/page_scale_animation.h @@ -1,3 +1,74 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCPageScaleAnimation_h +#define CCPageScaleAnimation_h + +#include "IntSize.h" +#include + +namespace cc { + +// A small helper class that does the math for zoom animations, primarily for +// double-tap zoom. Initialize it with starting and ending scroll/page scale +// positions and an animation length time, then call ...AtTime() at every frame +// to obtain the current interpolated position. +class CCPageScaleAnimation { +public: + // Construct with the starting page scale and scroll offset (which is in + // pageScaleStart space). The window size is the user-viewable area + // in pixels. + static PassOwnPtr create(const IntSize& scrollStart, float pageScaleStart, const IntSize& windowSize, const IntSize& contentSize, double startTime); + + // The following methods initialize the animation. Call one of them + // immediately after construction to set the final scroll and page scale. + + // Zoom while explicitly specifying the top-left scroll position. The + // scroll offset is in finalPageScale coordinates. + void zoomTo(const IntSize& finalScroll, float finalPageScale, double duration); + + // Zoom based on a specified onscreen anchor, which will remain at the same + // position on the screen throughout the animation. The anchor is in local + // space relative to scrollStart. + void zoomWithAnchor(const IntSize& anchor, float finalPageScale, double duration); + + // Call these functions while the animation is in progress to output the + // current state. + IntSize scrollOffsetAtTime(double time) const; + float pageScaleAtTime(double time) const; + bool isAnimationCompleteAtTime(double time) const; + + // The following methods return state which is invariant throughout the + // course of the animation. + double startTime() const { return m_startTime; } + double duration() const { return m_duration; } + double endTime() const { return m_startTime + m_duration; } + const IntSize& finalScrollOffset() const { return m_scrollEnd; } + float finalPageScale() const { return m_pageScaleEnd; } + +protected: + CCPageScaleAnimation(const IntSize& scrollStart, float pageScaleStart, const IntSize& windowSize, const IntSize& contentSize, double startTime); + +private: + float progressRatioForTime(double time) const; + IntSize scrollOffsetAtRatio(float ratio) const; + float pageScaleAtRatio(float ratio) const; + + IntSize m_scrollStart; + float m_pageScaleStart; + IntSize m_windowSize; + IntSize m_contentSize; + + bool m_anchorMode; + IntSize m_anchor; + IntSize m_scrollEnd; + float m_pageScaleEnd; + + double m_startTime; + double m_duration; +}; + +} // namespace cc + +#endif diff --git a/cc/platform_color.h b/cc/platform_color.h index 638cbb270ce9b2..61ffd31bd49c71 100644 --- a/cc/platform_color.h +++ b/cc/platform_color.h @@ -1,3 +1,58 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef PlatformColor_h +#define PlatformColor_h + +#include "Extensions3D.h" +#include "GraphicsContext3D.h" +#include "SkTypes.h" +#include + +namespace cc { + +class PlatformColor { +public: + static GraphicsContext3D::SourceDataFormat format() + { + return SK_B32_SHIFT ? GraphicsContext3D::SourceFormatRGBA8 : GraphicsContext3D::SourceFormatBGRA8; + } + + // Returns the most efficient texture format for this platform. + static GC3Denum bestTextureFormat(WebKit::WebGraphicsContext3D* context, bool supportsBGRA8888) + { + GC3Denum textureFormat = GraphicsContext3D::RGBA; + switch (format()) { + case GraphicsContext3D::SourceFormatRGBA8: + break; + case GraphicsContext3D::SourceFormatBGRA8: + if (supportsBGRA8888) + textureFormat = Extensions3D::BGRA_EXT; + break; + default: + ASSERT_NOT_REACHED(); + break; + } + return textureFormat; + } + + // Return true if the given texture format has the same component order + // as the color on this platform. + static bool sameComponentOrder(GC3Denum textureFormat) + { + switch (format()) { + case GraphicsContext3D::SourceFormatRGBA8: + return textureFormat == GraphicsContext3D::RGBA; + case GraphicsContext3D::SourceFormatBGRA8: + return textureFormat == Extensions3D::BGRA_EXT; + default: + ASSERT_NOT_REACHED(); + return false; + } + } +}; + +} // namespace cc + +#endif diff --git a/cc/CCPrioritizedTexture.cpp b/cc/prioritized_texture.cc similarity index 100% rename from cc/CCPrioritizedTexture.cpp rename to cc/prioritized_texture.cc diff --git a/cc/prioritized_texture.h b/cc/prioritized_texture.h index 638cbb270ce9b2..3196867064abce 100644 --- a/cc/prioritized_texture.h +++ b/cc/prioritized_texture.h @@ -1,3 +1,142 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCPrioritizedTexture_h +#define CCPrioritizedTexture_h + +#include "base/basictypes.h" +#include "base/memory/scoped_ptr.h" +#include "CCPriorityCalculator.h" +#include "CCResourceProvider.h" +#include "CCTexture.h" +#include "GraphicsContext3D.h" +#include "IntRect.h" +#include "IntSize.h" + +namespace cc { + +class CCPrioritizedTextureManager; + +class CCPrioritizedTexture { +public: + static scoped_ptr create(CCPrioritizedTextureManager* manager, IntSize size, GC3Denum format) + { + return make_scoped_ptr(new CCPrioritizedTexture(manager, size, format)); + } + static scoped_ptr create(CCPrioritizedTextureManager* manager) + { + return make_scoped_ptr(new CCPrioritizedTexture(manager, IntSize(), 0)); + } + ~CCPrioritizedTexture(); + + // Texture properties. Changing these causes the backing texture to be lost. + // Setting these to the same value is a no-op. + void setTextureManager(CCPrioritizedTextureManager*); + CCPrioritizedTextureManager* textureManager() { return m_manager; } + void setDimensions(IntSize, GC3Denum format); + GC3Denum format() const { return m_format; } + IntSize size() const { return m_size; } + size_t bytes() const { return m_bytes; } + + // Set priority for the requested texture. + void setRequestPriority(int priority) { m_priority = priority; } + int requestPriority() const { return m_priority; } + + // After CCPrioritizedTexture::prioritizeTextures() is called, this returns + // if the the request succeeded and this texture can be acquired for use. + bool canAcquireBackingTexture() const { return m_isAbovePriorityCutoff; } + + // This returns whether we still have a backing texture. This can continue + // to be true even after canAcquireBackingTexture() becomes false. In this + // case the texture can be used but shouldn't be updated since it will get + // taken away "soon". + bool haveBackingTexture() const { return !!backing(); } + + bool backingResourceWasEvicted() const; + + // If canAcquireBackingTexture() is true acquireBackingTexture() will acquire + // a backing texture for use. Call this whenever the texture is actually needed. + void acquireBackingTexture(CCResourceProvider*); + + // FIXME: Request late is really a hack for when we are totally out of memory + // (all textures are visible) but we can still squeeze into the limit + // by not painting occluded textures. In this case the manager + // refuses all visible textures and requestLate() will enable + // canAcquireBackingTexture() on a call-order basis. We might want to + // just remove this in the future (carefully) and just make sure we don't + // regress OOMs situations. + bool requestLate(); + + // Uploads pixels into the backing resource. This functions will aquire the backing if needed. + void upload(CCResourceProvider*, const uint8_t* image, const IntRect& imageRect, const IntRect& sourceRect, const IntSize& destOffset); + + CCResourceProvider::ResourceId resourceId() const; + + // Self-managed textures are accounted for when prioritizing other textures, + // but they are not allocated/recycled/deleted, so this needs to be done + // externally. canAcquireBackingTexture() indicates if the texture would have + // been allowed given its priority. + void setIsSelfManaged(bool isSelfManaged) { m_isSelfManaged = isSelfManaged; } + bool isSelfManaged() { return m_isSelfManaged; } + void setToSelfManagedMemoryPlaceholder(size_t bytes); + +private: + friend class CCPrioritizedTextureManager; + friend class CCPrioritizedTextureTest; + + class Backing : public CCTexture { + public: + Backing(unsigned id, CCResourceProvider*, IntSize, GC3Denum format); + ~Backing(); + void updatePriority(); + + CCPrioritizedTexture* owner() { return m_owner; } + bool hadOwnerAtLastPriorityUpdate() const { return m_ownerExistedAtLastPriorityUpdate; } + int requestPriorityAtLastPriorityUpdate() const { return m_priorityAtLastPriorityUpdate; } + bool wasAbovePriorityCutoffAtLastPriorityUpdate() const { return m_wasAbovePriorityCutoffAtLastPriorityUpdate; } + + void deleteResource(CCResourceProvider*); + bool resourceHasBeenDeleted() const; + + private: + friend class CCPrioritizedTexture; + CCPrioritizedTexture* m_owner; + int m_priorityAtLastPriorityUpdate; + bool m_ownerExistedAtLastPriorityUpdate; + bool m_wasAbovePriorityCutoffAtLastPriorityUpdate; + bool m_resourceHasBeenDeleted; +#ifndef NDEBUG + CCResourceProvider* m_resourceProvider; +#endif + + DISALLOW_COPY_AND_ASSIGN(Backing); + }; + + CCPrioritizedTexture(CCPrioritizedTextureManager*, IntSize, GC3Denum format); + + bool isAbovePriorityCutoff() { return m_isAbovePriorityCutoff; } + void setAbovePriorityCutoff(bool isAbovePriorityCutoff) { m_isAbovePriorityCutoff = isAbovePriorityCutoff; } + void setManagerInternal(CCPrioritizedTextureManager* manager) { m_manager = manager; } + + Backing* backing() const { return m_backing; } + void link(Backing*); + void unlink(); + + IntSize m_size; + GC3Denum m_format; + size_t m_bytes; + + int m_priority; + bool m_isAbovePriorityCutoff; + bool m_isSelfManaged; + + Backing* m_backing; + CCPrioritizedTextureManager* m_manager; + + DISALLOW_COPY_AND_ASSIGN(CCPrioritizedTexture); +}; + +} // namespace cc + +#endif diff --git a/cc/CCPrioritizedTextureManager.cpp b/cc/prioritized_texture_manager.cc similarity index 100% rename from cc/CCPrioritizedTextureManager.cpp rename to cc/prioritized_texture_manager.cc diff --git a/cc/prioritized_texture_manager.h b/cc/prioritized_texture_manager.h index 638cbb270ce9b2..1b3b1edbdfbf58 100644 --- a/cc/prioritized_texture_manager.h +++ b/cc/prioritized_texture_manager.h @@ -1,3 +1,159 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCPrioritizedTextureManager_h +#define CCPrioritizedTextureManager_h + +#include "base/basictypes.h" +#include "base/hash_tables.h" +#include "base/memory/scoped_ptr.h" +#include "CCPrioritizedTexture.h" +#include "CCPriorityCalculator.h" +#include "CCTexture.h" +#include "GraphicsContext3D.h" +#include "IntRect.h" +#include "IntSize.h" +#include +#include + +#if defined(COMPILER_GCC) +namespace BASE_HASH_NAMESPACE { +template<> +struct hash { + size_t operator()(cc::CCPrioritizedTexture* ptr) const { + return hash()(reinterpret_cast(ptr)); + } +}; +} // namespace BASE_HASH_NAMESPACE +#endif // COMPILER + +namespace cc { + +class CCPriorityCalculator; + +class CCPrioritizedTextureManager { +public: + static scoped_ptr create(size_t maxMemoryLimitBytes, int maxTextureSize, int pool) + { + return make_scoped_ptr(new CCPrioritizedTextureManager(maxMemoryLimitBytes, maxTextureSize, pool)); + } + scoped_ptr createTexture(IntSize size, GC3Denum format) + { + return make_scoped_ptr(new CCPrioritizedTexture(this, size, format)); + } + ~CCPrioritizedTextureManager(); + + typedef Vector BackingVector; + + // FIXME (http://crbug.com/137094): This 64MB default is a straggler from the + // old texture manager and is just to give us a default memory allocation before + // we get a callback from the GPU memory manager. We should probaby either: + // - wait for the callback before rendering anything instead + // - push this into the GPU memory manager somehow. + static size_t defaultMemoryAllocationLimit() { return 64 * 1024 * 1024; } + + // memoryUseBytes() describes the number of bytes used by existing allocated textures. + // memoryAboveCutoffBytes() describes the number of bytes that would be used if all + // textures that are above the cutoff were allocated. + // memoryUseBytes() <= memoryAboveCutoffBytes() should always be true. + size_t memoryUseBytes() const { return m_memoryUseBytes; } + size_t memoryAboveCutoffBytes() const { return m_memoryAboveCutoffBytes; } + size_t memoryForSelfManagedTextures() const { return m_maxMemoryLimitBytes - m_memoryAvailableBytes; } + + void setMaxMemoryLimitBytes(size_t bytes) { m_maxMemoryLimitBytes = bytes; } + size_t maxMemoryLimitBytes() const { return m_maxMemoryLimitBytes; } + + void prioritizeTextures(); + void clearPriorities(); + + void reduceMemoryOnImplThread(size_t limitBytes, CCResourceProvider*); + bool evictedBackingsExist() const { return !m_evictedBackings.isEmpty(); } + void getEvictedBackings(BackingVector& evictedBackings); + void unlinkEvictedBackings(const BackingVector& evictedBackings); + // Deletes all evicted backings, unlinking them from their owning textures if needed. + // Returns true if this function unlinked any backings from their owning texture while + // destroying them. + bool deleteEvictedBackings(); + + bool requestLate(CCPrioritizedTexture*); + + void reduceMemory(CCResourceProvider*); + void clearAllMemory(CCResourceProvider*); + + void acquireBackingTextureIfNeeded(CCPrioritizedTexture*, CCResourceProvider*); + + void registerTexture(CCPrioritizedTexture*); + void unregisterTexture(CCPrioritizedTexture*); + void returnBackingTexture(CCPrioritizedTexture*); + +private: + friend class CCPrioritizedTextureTest; + + enum EvictionPriorityPolicy { + RespectManagerPriorityCutoff, + DoNotRespectManagerPriorityCutoff, + }; + + // Compare textures. Highest priority first. + static inline bool compareTextures(CCPrioritizedTexture* a, CCPrioritizedTexture* b) + { + if (a->requestPriority() == b->requestPriority()) + return a < b; + return CCPriorityCalculator::priorityIsHigher(a->requestPriority(), b->requestPriority()); + } + // Compare backings. Lowest priority first. + static inline bool compareBackings(CCPrioritizedTexture::Backing* a, CCPrioritizedTexture::Backing* b) + { + int priorityA = a->requestPriorityAtLastPriorityUpdate(); + int priorityB = b->requestPriorityAtLastPriorityUpdate(); + if (priorityA != priorityB) + return CCPriorityCalculator::priorityIsLower(priorityA, priorityB); + bool aboveCutoffA = a->wasAbovePriorityCutoffAtLastPriorityUpdate(); + bool aboveCutoffB = b->wasAbovePriorityCutoffAtLastPriorityUpdate(); + if (!aboveCutoffA && aboveCutoffB) + return true; + if (aboveCutoffA && !aboveCutoffB) + return false; + return a < b; + } + + CCPrioritizedTextureManager(size_t maxMemoryLimitBytes, int maxTextureSize, int pool); + + void updateBackingsPriorities(); + void evictBackingsToReduceMemory(size_t limitBytes, EvictionPriorityPolicy, CCResourceProvider*); + CCPrioritizedTexture::Backing* createBacking(IntSize, GC3Denum format, CCResourceProvider*); + void evictBackingResource(CCPrioritizedTexture::Backing*, CCResourceProvider*); + +#if !ASSERT_DISABLED + void assertInvariants(); +#endif + + size_t m_maxMemoryLimitBytes; + unsigned m_priorityCutoff; + size_t m_memoryUseBytes; + size_t m_memoryAboveCutoffBytes; + size_t m_memoryAvailableBytes; + int m_pool; + + typedef base::hash_set TextureSet; + typedef ListHashSet BackingSet; + typedef Vector TextureVector; + + TextureSet m_textures; + BackingSet m_backings; + BackingVector m_evictedBackings; + + TextureVector m_tempTextureVector; + BackingVector m_tempBackingVector; + + // Set by the main thread when it adjust priorities in such a way that + // the m_backings array's view of priorities is now out of date. + bool m_needsUpdateBackingsPrioritites; + + DISALLOW_COPY_AND_ASSIGN(CCPrioritizedTextureManager); +}; + +} // namespace cc + +#endif diff --git a/cc/CCPriorityCalculator.cpp b/cc/priority_calculator.cc similarity index 100% rename from cc/CCPriorityCalculator.cpp rename to cc/priority_calculator.cc diff --git a/cc/priority_calculator.h b/cc/priority_calculator.h index 638cbb270ce9b2..45f2e64a649bd0 100644 --- a/cc/priority_calculator.h +++ b/cc/priority_calculator.h @@ -1,3 +1,32 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2010 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCPriorityCalculator_h +#define CCPriorityCalculator_h + +#include "GraphicsContext3D.h" +#include "IntRect.h" +#include "IntSize.h" + +namespace cc { + +class CCPriorityCalculator { +public: + static int uiPriority(bool drawsToRootSurface); + static int visiblePriority(bool drawsToRootSurface); + static int renderSurfacePriority(); + static int lingeringPriority(int previousPriority); + static int priorityFromDistance(const IntRect& visibleRect, const IntRect& textureRect, bool drawsToRootSurface); + static int smallAnimatedLayerMinPriority(); + + static inline int highestPriority() { return std::numeric_limits::min(); } + static inline int lowestPriority() { return std::numeric_limits::max(); } + static inline bool priorityIsLower(int a, int b) { return a > b; } + static inline bool priorityIsHigher(int a, int b) { return a < b; } + static inline bool maxPriority(int a, int b) { return priorityIsHigher(a, b) ? a : b; } +}; + +} + +#endif diff --git a/cc/ProgramBinding.cpp b/cc/program_binding.cc similarity index 100% rename from cc/ProgramBinding.cpp rename to cc/program_binding.cc diff --git a/cc/program_binding.h b/cc/program_binding.h index 638cbb270ce9b2..9f0d0673c2a384 100644 --- a/cc/program_binding.h +++ b/cc/program_binding.h @@ -1,3 +1,84 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef ProgramBinding_h +#define ProgramBinding_h + +#if USE(ACCELERATED_COMPOSITING) + +#include + +namespace WebKit { +class WebGraphicsContext3D; +} + +namespace cc { + +class ProgramBindingBase { +public: + ProgramBindingBase(); + ~ProgramBindingBase(); + + void init(WebKit::WebGraphicsContext3D*, const std::string& vertexShader, const std::string& fragmentShader); + void link(WebKit::WebGraphicsContext3D*); + void cleanup(WebKit::WebGraphicsContext3D*); + + unsigned program() const { ASSERT(m_initialized); return m_program; } + bool initialized() const { return m_initialized; } + +protected: + + unsigned loadShader(WebKit::WebGraphicsContext3D*, unsigned type, const std::string& shaderSource); + unsigned createShaderProgram(WebKit::WebGraphicsContext3D*, unsigned vertexShader, unsigned fragmentShader); + void cleanupShaders(WebKit::WebGraphicsContext3D*); + + unsigned m_program; + unsigned m_vertexShaderId; + unsigned m_fragmentShaderId; + bool m_initialized; +}; + +template +class ProgramBinding : public ProgramBindingBase { +public: + explicit ProgramBinding(WebKit::WebGraphicsContext3D* context) + { + ProgramBindingBase::init(context, m_vertexShader.getShaderString(), m_fragmentShader.getShaderString()); + } + + void initialize(WebKit::WebGraphicsContext3D* context, bool usingBindUniform) + { + ASSERT(context); + ASSERT(m_program); + ASSERT(!m_initialized); + + // Need to bind uniforms before linking + if (!usingBindUniform) + link(context); + + int baseUniformIndex = 0; + m_vertexShader.init(context, m_program, usingBindUniform, &baseUniformIndex); + m_fragmentShader.init(context, m_program, usingBindUniform, &baseUniformIndex); + + // Link after binding uniforms + if (usingBindUniform) + link(context); + + m_initialized = true; + } + + const VertexShader& vertexShader() const { return m_vertexShader; } + const FragmentShader& fragmentShader() const { return m_fragmentShader; } + +private: + + VertexShader m_vertexShader; + FragmentShader m_fragmentShader; +}; + +} // namespace cc + +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCProxy.cpp b/cc/proxy.cc similarity index 100% rename from cc/CCProxy.cpp rename to cc/proxy.cc diff --git a/cc/proxy.h b/cc/proxy.h index 638cbb270ce9b2..30a62cc55cc9a4 100644 --- a/cc/proxy.h +++ b/cc/proxy.h @@ -1,3 +1,129 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCProxy_h +#define CCProxy_h + +#include "base/basictypes.h" +#include +#include +#include + +namespace cc { + +class CCThread; +class IntRect; +class IntSize; +struct CCRenderingStats; +struct RendererCapabilities; + +// Abstract class responsible for proxying commands from the main-thread side of +// the compositor over to the compositor implementation. +class CCProxy { +public: + static void setMainThread(CCThread*); + static CCThread* mainThread(); + + static bool hasImplThread(); + static void setImplThread(CCThread*); + static CCThread* implThread(); + + // Returns 0 if the current thread is neither the main thread nor the impl thread. + static CCThread* currentThread(); + + virtual ~CCProxy(); + + virtual bool compositeAndReadback(void *pixels, const IntRect&) = 0; + + virtual void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double durationSec) = 0; + + virtual void finishAllRendering() = 0; + + virtual bool isStarted() const = 0; + + // Attempts to initialize a context to use for rendering. Returns false if the context could not be created. + // The context will not be used and no frames may be produced until initializeRenderer() is called. + virtual bool initializeContext() = 0; + + // Indicates that the compositing surface associated with our context is ready to use. + virtual void setSurfaceReady() = 0; + + virtual void setVisible(bool) = 0; + + // Attempts to initialize the layer renderer. Returns false if the context isn't usable for compositing. + virtual bool initializeRenderer() = 0; + + // Attempts to recreate the context and layer renderer after a context lost. Returns false if the renderer couldn't be + // reinitialized. + virtual bool recreateContext() = 0; + + virtual void renderingStats(CCRenderingStats*) = 0; + + virtual const RendererCapabilities& rendererCapabilities() const = 0; + + virtual void setNeedsAnimate() = 0; + virtual void setNeedsCommit() = 0; + virtual void setNeedsRedraw() = 0; + + virtual void didAddAnimation() = 0; + + virtual bool commitRequested() const = 0; + + virtual void start() = 0; // Must be called before using the proxy. + virtual void stop() = 0; // Must be called before deleting the proxy. + + // Forces 3D commands on all contexts to wait for all previous SwapBuffers to finish before executing in the GPU + // process. + virtual void forceSerializeOnSwapBuffers() = 0; + + // Maximum number of sub-region texture updates supported for each commit. + virtual size_t maxPartialTextureUpdates() const = 0; + + virtual void acquireLayerTextures() = 0; + + // Debug hooks +#ifndef NDEBUG + static bool isMainThread(); + static bool isImplThread(); + static bool isMainThreadBlocked(); + static void setMainThreadBlocked(bool); +#endif + + // Testing hooks + virtual void loseContext() = 0; + +#ifndef NDEBUG + static void setCurrentThreadIsImplThread(bool); +#endif + +protected: + CCProxy(); + friend class DebugScopedSetImplThread; + friend class DebugScopedSetMainThreadBlocked; + +private: + DISALLOW_COPY_AND_ASSIGN(CCProxy); +}; + +class DebugScopedSetMainThreadBlocked { +public: + DebugScopedSetMainThreadBlocked() + { +#if !ASSERT_DISABLED + ASSERT(!CCProxy::isMainThreadBlocked()); + CCProxy::setMainThreadBlocked(true); +#endif + } + ~DebugScopedSetMainThreadBlocked() + { +#if !ASSERT_DISABLED + ASSERT(CCProxy::isMainThreadBlocked()); + CCProxy::setMainThreadBlocked(false); +#endif + } +}; + +} + +#endif diff --git a/cc/CCQuadCuller.cpp b/cc/quad_culler.cc similarity index 100% rename from cc/CCQuadCuller.cpp rename to cc/quad_culler.cc diff --git a/cc/quad_culler.h b/cc/quad_culler.h index 638cbb270ce9b2..b3927cc6466315 100644 --- a/cc/quad_culler.h +++ b/cc/quad_culler.h @@ -1,3 +1,37 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCQuadCuller_h +#define CCQuadCuller_h + +#include "CCQuadSink.h" +#include "CCRenderPass.h" + +namespace cc { +class CCLayerImpl; +class CCRenderSurface; +template +class CCOcclusionTrackerBase; + +class CCQuadCuller : public CCQuadSink { +public: + CCQuadCuller(CCQuadList&, CCSharedQuadStateList&, CCLayerImpl*, const CCOcclusionTrackerBase*, bool showCullingWithDebugBorderQuads, bool forSurface); + virtual ~CCQuadCuller() { } + + // CCQuadSink implementation. + virtual CCSharedQuadState* useSharedQuadState(scoped_ptr) OVERRIDE; + virtual bool append(scoped_ptr, CCAppendQuadsData&) OVERRIDE; + +private: + CCQuadList& m_quadList; + CCSharedQuadStateList& m_sharedQuadStateList; + CCSharedQuadState* m_currentSharedQuadState; + CCLayerImpl* m_layer; + const CCOcclusionTrackerBase* m_occlusionTracker; + bool m_showCullingWithDebugBorderQuads; + bool m_forSurface; +}; + +} +#endif // CCQuadCuller_h diff --git a/cc/quad_sink.h b/cc/quad_sink.h index 638cbb270ce9b2..06d31b0473c460 100644 --- a/cc/quad_sink.h +++ b/cc/quad_sink.h @@ -1,3 +1,30 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCQuadSink_h +#define CCQuadSink_h + +#include "base/memory/scoped_ptr.h" + +namespace cc { + +class CCDrawQuad; + +struct CCAppendQuadsData; +struct CCSharedQuadState; + +class CCQuadSink { +public: + virtual ~CCQuadSink() { } + + // Call this to add a SharedQuadState before appending quads that refer to it. Returns a pointer + // to the given SharedQuadState for convenience, that can be set on the quads to append. + virtual CCSharedQuadState* useSharedQuadState(scoped_ptr) = 0; + + // Returns true if the quad is added to the list, and false if the quad is entirely culled. + virtual bool append(scoped_ptr passDrawQuad, CCAppendQuadsData&) = 0; +}; + +} +#endif // CCQuadCuller_h diff --git a/cc/RateLimiter.cpp b/cc/rate_limiter.cc similarity index 100% rename from cc/RateLimiter.cpp rename to cc/rate_limiter.cc diff --git a/cc/rate_limiter.h b/cc/rate_limiter.h index 638cbb270ce9b2..7b48d742b7df08 100644 --- a/cc/rate_limiter.h +++ b/cc/rate_limiter.h @@ -1,3 +1,53 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef RateLimiter_h +#define RateLimiter_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "base/memory/ref_counted.h" + +namespace WebKit { +class WebGraphicsContext3D; +} + +namespace cc { + +class RateLimiterClient { +public: + virtual void rateLimit() = 0; +}; + +// A RateLimiter can be used to make sure that a single context does not dominate all execution time. +// To use, construct a RateLimiter class around the context and call start() whenever calls are made on the +// context outside of normal flow control. RateLimiter will block if the context is too far ahead of the +// compositor. +class RateLimiter : public base::RefCounted { +public: + static scoped_refptr create(WebKit::WebGraphicsContext3D*, RateLimiterClient*); + + void start(); + + // Context and client will not be accessed after stop(). + void stop(); + +private: + RateLimiter(WebKit::WebGraphicsContext3D*, RateLimiterClient*); + ~RateLimiter(); + friend class base::RefCounted; + + class Task; + friend class Task; + void rateLimitContext(); + + WebKit::WebGraphicsContext3D* m_context; + bool m_active; + RateLimiterClient *m_client; +}; + +} +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCRenderPass.cpp b/cc/render_pass.cc similarity index 100% rename from cc/CCRenderPass.cpp rename to cc/render_pass.cc diff --git a/cc/render_pass.h b/cc/render_pass.h index 638cbb270ce9b2..cdfa958dd27ea0 100644 --- a/cc/render_pass.h +++ b/cc/render_pass.h @@ -1,3 +1,140 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCRenderPass_h +#define CCRenderPass_h + +#include "base/basictypes.h" +#include "cc/hash_pair.h" +#include "cc/scoped_ptr_hash_map.h" +#include "cc/scoped_ptr_vector.h" +#include "CCDrawQuad.h" +#include "CCSharedQuadState.h" +#include "FloatRect.h" +#include "SkColor.h" +#include +#include +#include + +namespace cc { + +class CCLayerImpl; +template +class CCOcclusionTrackerBase; +class CCRenderSurface; + +struct CCAppendQuadsData; + +typedef CCOcclusionTrackerBase CCOcclusionTrackerImpl; + +// A list of CCDrawQuad objects, sorted internally in front-to-back order. +class CCQuadList : public ScopedPtrVector { +public: + typedef reverse_iterator backToFrontIterator; + typedef const_reverse_iterator constBackToFrontIterator; + + inline backToFrontIterator backToFrontBegin() { return rbegin(); } + inline backToFrontIterator backToFrontEnd() { return rend(); } + inline constBackToFrontIterator backToFrontBegin() const { return rbegin(); } + inline constBackToFrontIterator backToFrontEnd() const { return rend(); } +}; + +typedef ScopedPtrVector CCSharedQuadStateList; + +class CCRenderPass { +public: + ~CCRenderPass(); + + struct Id { + int layerId; + int index; + + Id(int layerId, int index) + : layerId(layerId) + , index(index) + { + } + + bool operator==(const Id& other) const { return layerId == other.layerId && index == other.index; } + bool operator!=(const Id& other) const { return !(*this == other); } + bool operator<(const Id& other) const { return layerId < other.layerId || (layerId == other.layerId && index < other.index); } + }; + + static scoped_ptr create(Id, IntRect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget); + + // A shallow copy of the render pass, which does not include its quads. + scoped_ptr copy(Id newId) const; + + void appendQuadsForLayer(CCLayerImpl*, CCOcclusionTrackerImpl*, CCAppendQuadsData&); + void appendQuadsForRenderSurfaceLayer(CCLayerImpl*, const CCRenderPass* contributingRenderPass, CCOcclusionTrackerImpl*, CCAppendQuadsData&); + void appendQuadsToFillScreen(CCLayerImpl* rootLayer, SkColor screenBackgroundColor, const CCOcclusionTrackerImpl&); + + const CCQuadList& quadList() const { return m_quadList; } + + Id id() const { return m_id; } + + // FIXME: Modify this transform when merging the RenderPass into a parent compositor. + // Transforms from quad's original content space to the root target's content space. + const WebKit::WebTransformationMatrix& transformToRootTarget() const { return m_transformToRootTarget; } + + // This denotes the bounds in physical pixels of the output generated by this RenderPass. + const IntRect& outputRect() const { return m_outputRect; } + + FloatRect damageRect() const { return m_damageRect; } + void setDamageRect(FloatRect rect) { m_damageRect = rect; } + + const WebKit::WebFilterOperations& filters() const { return m_filters; } + void setFilters(const WebKit::WebFilterOperations& filters) { m_filters = filters; } + + const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; } + void setBackgroundFilters(const WebKit::WebFilterOperations& filters) { m_backgroundFilters = filters; } + + bool hasTransparentBackground() const { return m_hasTransparentBackground; } + void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; } + + bool hasOcclusionFromOutsideTargetSurface() const { return m_hasOcclusionFromOutsideTargetSurface; } + void setHasOcclusionFromOutsideTargetSurface(bool hasOcclusionFromOutsideTargetSurface) { m_hasOcclusionFromOutsideTargetSurface = hasOcclusionFromOutsideTargetSurface; } +protected: + CCRenderPass(Id, IntRect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget); + + Id m_id; + CCQuadList m_quadList; + CCSharedQuadStateList m_sharedQuadStateList; + WebKit::WebTransformationMatrix m_transformToRootTarget; + IntRect m_outputRect; + FloatRect m_damageRect; + bool m_hasTransparentBackground; + bool m_hasOcclusionFromOutsideTargetSurface; + WebKit::WebFilterOperations m_filters; + WebKit::WebFilterOperations m_backgroundFilters; + + DISALLOW_COPY_AND_ASSIGN(CCRenderPass); +}; + +} // namespace cc + +namespace BASE_HASH_NAMESPACE { +#if defined(COMPILER_MSVC) +template<> +inline size_t hash_value(const cc::CCRenderPass::Id& key) { + return hash_value >(std::pair(key.layerId, key.index)); +} +#elif defined(COMPILER_GCC) +template<> +struct hash { + size_t operator()(cc::CCRenderPass::Id key) const { + return hash >()(std::pair(key.layerId, key.index)); + } +}; +#else +#error define a hash function for your compiler +#endif // COMPILER +} + +namespace cc { +typedef std::vector CCRenderPassList; +typedef ScopedPtrHashMap CCRenderPassIdHashMap; +} // namespace cc + +#endif diff --git a/cc/CCRenderPassDrawQuad.cpp b/cc/render_pass_draw_quad.cc similarity index 100% rename from cc/CCRenderPassDrawQuad.cpp rename to cc/render_pass_draw_quad.cc diff --git a/cc/render_pass_draw_quad.h b/cc/render_pass_draw_quad.h index 638cbb270ce9b2..99222d9edb83c4 100644 --- a/cc/render_pass_draw_quad.h +++ b/cc/render_pass_draw_quad.h @@ -1,3 +1,51 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCRenderPassDrawQuad_h +#define CCRenderPassDrawQuad_h + +#include "base/basictypes.h" +#include "base/memory/scoped_ptr.h" +#include "CCDrawQuad.h" +#include "CCRenderPass.h" +#include "CCResourceProvider.h" +#include "IntRect.h" + +namespace cc { + +class CCRenderPassDrawQuad : public CCDrawQuad { +public: + static scoped_ptr create(const CCSharedQuadState*, const IntRect&, CCRenderPass::Id renderPassId, bool isReplica, CCResourceProvider::ResourceId maskResourceId, const IntRect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY); + + CCRenderPass::Id renderPassId() const { return m_renderPassId; } + bool isReplica() const { return m_isReplica; } + CCResourceProvider::ResourceId maskResourceId() const { return m_maskResourceId; } + const IntRect& contentsChangedSinceLastFrame() const { return m_contentsChangedSinceLastFrame; } + + static const CCRenderPassDrawQuad* materialCast(const CCDrawQuad*); + float maskTexCoordScaleX() const { return m_maskTexCoordScaleX; } + float maskTexCoordScaleY() const { return m_maskTexCoordScaleY; } + float maskTexCoordOffsetX() const { return m_maskTexCoordOffsetX; } + float maskTexCoordOffsetY() const { return m_maskTexCoordOffsetY; } + + scoped_ptr copy(const CCSharedQuadState* copiedSharedQuadState, CCRenderPass::Id copiedRenderPassId) const; + +private: + CCRenderPassDrawQuad(const CCSharedQuadState*, const IntRect&, CCRenderPass::Id renderPassId, bool isReplica, CCResourceProvider::ResourceId maskResourceId, const IntRect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY); + + CCRenderPass::Id m_renderPassId; + bool m_isReplica; + CCResourceProvider::ResourceId m_maskResourceId; + IntRect m_contentsChangedSinceLastFrame; + float m_maskTexCoordScaleX; + float m_maskTexCoordScaleY; + float m_maskTexCoordOffsetX; + float m_maskTexCoordOffsetY; + + DISALLOW_COPY_AND_ASSIGN(CCRenderPassDrawQuad); +}; + +} + +#endif diff --git a/cc/render_pass_sink.h b/cc/render_pass_sink.h index 638cbb270ce9b2..f3bac1d01e85da 100644 --- a/cc/render_pass_sink.h +++ b/cc/render_pass_sink.h @@ -1,3 +1,20 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCRenderPassSink_h +#define CCRenderPassSink_h + +#include "base/memory/scoped_ptr.h" + +namespace cc { + +class CCRenderPass; + +class CCRenderPassSink { +public: + virtual void appendRenderPass(scoped_ptr) = 0; +}; + +} +#endif // CCRenderPassSink_h diff --git a/cc/RenderSurfaceChromium.cpp b/cc/render_surface.cc similarity index 100% rename from cc/RenderSurfaceChromium.cpp rename to cc/render_surface.cc diff --git a/cc/render_surface.h b/cc/render_surface.h index 638cbb270ce9b2..67ed62666dbb40 100644 --- a/cc/render_surface.h +++ b/cc/render_surface.h @@ -1,3 +1,107 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2010 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef RenderSurfaceChromium_h +#define RenderSurfaceChromium_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "base/basictypes.h" +#include "base/memory/ref_counted.h" +#include "FloatRect.h" +#include "IntRect.h" +#include +#include + +namespace cc { + +class LayerChromium; + +class RenderSurfaceChromium { +public: + explicit RenderSurfaceChromium(LayerChromium*); + ~RenderSurfaceChromium(); + + // Returns the rect that encloses the RenderSurface including any reflection. + FloatRect drawableContentRect() const; + + const IntRect& contentRect() const { return m_contentRect; } + void setContentRect(const IntRect& contentRect) { m_contentRect = contentRect; } + + float drawOpacity() const { return m_drawOpacity; } + void setDrawOpacity(float drawOpacity) { m_drawOpacity = drawOpacity; } + + bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; } + void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; } + + // This goes from content space with the origin in the center of the rect being transformed to the target space with the origin in the top left of the + // rect being transformed. Position the rect so that the origin is in the center of it before applying this transform. + const WebKit::WebTransformationMatrix& drawTransform() const { return m_drawTransform; } + void setDrawTransform(const WebKit::WebTransformationMatrix& drawTransform) { m_drawTransform = drawTransform; } + + const WebKit::WebTransformationMatrix& screenSpaceTransform() const { return m_screenSpaceTransform; } + void setScreenSpaceTransform(const WebKit::WebTransformationMatrix& screenSpaceTransform) { m_screenSpaceTransform = screenSpaceTransform; } + + const WebKit::WebTransformationMatrix& replicaDrawTransform() const { return m_replicaDrawTransform; } + void setReplicaDrawTransform(const WebKit::WebTransformationMatrix& replicaDrawTransform) { m_replicaDrawTransform = replicaDrawTransform; } + + const WebKit::WebTransformationMatrix& replicaScreenSpaceTransform() const { return m_replicaScreenSpaceTransform; } + void setReplicaScreenSpaceTransform(const WebKit::WebTransformationMatrix& replicaScreenSpaceTransform) { m_replicaScreenSpaceTransform = replicaScreenSpaceTransform; } + + bool targetSurfaceTransformsAreAnimating() const { return m_targetSurfaceTransformsAreAnimating; } + void setTargetSurfaceTransformsAreAnimating(bool animating) { m_targetSurfaceTransformsAreAnimating = animating; } + bool screenSpaceTransformsAreAnimating() const { return m_screenSpaceTransformsAreAnimating; } + void setScreenSpaceTransformsAreAnimating(bool animating) { m_screenSpaceTransformsAreAnimating = animating; } + + const IntRect& clipRect() const { return m_clipRect; } + void setClipRect(const IntRect& clipRect) { m_clipRect = clipRect; } + + typedef std::vector > LayerList; + LayerList& layerList() { return m_layerList; } + // A no-op since DelegatedRendererLayers on the main thread don't have any + // RenderPasses so they can't contribute to a surface. + void addContributingDelegatedRenderPassLayer(LayerChromium*) { } + void clearLayerLists() { m_layerList.clear(); } + + void setNearestAncestorThatMovesPixels(RenderSurfaceChromium* surface) { m_nearestAncestorThatMovesPixels = surface; } + const RenderSurfaceChromium* nearestAncestorThatMovesPixels() const { return m_nearestAncestorThatMovesPixels; } + +private: + friend struct CCLayerIteratorActions; + + LayerChromium* m_owningLayer; + + // Uses this surface's space. + IntRect m_contentRect; + + float m_drawOpacity; + bool m_drawOpacityIsAnimating; + WebKit::WebTransformationMatrix m_drawTransform; + WebKit::WebTransformationMatrix m_screenSpaceTransform; + WebKit::WebTransformationMatrix m_replicaDrawTransform; + WebKit::WebTransformationMatrix m_replicaScreenSpaceTransform; + bool m_targetSurfaceTransformsAreAnimating; + bool m_screenSpaceTransformsAreAnimating; + + // Uses the space of the surface's target surface. + IntRect m_clipRect; + + LayerList m_layerList; + + // The nearest ancestor target surface that will contain the contents of this surface, and that is going + // to move pixels within the surface (such as with a blur). This can point to itself. + RenderSurfaceChromium* m_nearestAncestorThatMovesPixels; + + // For CCLayerIteratorActions + int m_targetRenderSurfaceLayerIndexHistory; + int m_currentLayerIndexHistory; + + DISALLOW_COPY_AND_ASSIGN(RenderSurfaceChromium); +}; + +} +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCRenderSurfaceFilters.cpp b/cc/render_surface_filters.cc similarity index 100% rename from cc/CCRenderSurfaceFilters.cpp rename to cc/render_surface_filters.cc diff --git a/cc/render_surface_filters.h b/cc/render_surface_filters.h index 638cbb270ce9b2..cd199b5679a69d 100644 --- a/cc/render_surface_filters.h +++ b/cc/render_surface_filters.h @@ -1,3 +1,34 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef CCRenderSurfaceFilters_h +#define CCRenderSurfaceFilters_h + +#if USE(ACCELERATED_COMPOSITING) + +class GrContext; +class SkBitmap; + +namespace WebKit { +class WebFilterOperations; +class WebGraphicsContext3D; +} + +namespace cc { +class FloatSize; + +class CCRenderSurfaceFilters { +public: + static SkBitmap apply(const WebKit::WebFilterOperations& filters, unsigned textureId, const FloatSize&, WebKit::WebGraphicsContext3D*, GrContext*); + static WebKit::WebFilterOperations optimize(const WebKit::WebFilterOperations& filters); + +private: + CCRenderSurfaceFilters(); +}; + +} +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCRenderSurface.cpp b/cc/render_surface_impl.cc similarity index 100% rename from cc/CCRenderSurface.cpp rename to cc/render_surface_impl.cc diff --git a/cc/render_surface_impl.h b/cc/render_surface_impl.h index 638cbb270ce9b2..afdf062de998b1 100644 --- a/cc/render_surface_impl.h +++ b/cc/render_surface_impl.h @@ -1,3 +1,132 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCRenderSurface_h +#define CCRenderSurface_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "base/basictypes.h" +#include "base/memory/scoped_ptr.h" +#include "CCRenderPass.h" +#include "CCSharedQuadState.h" +#include "FloatRect.h" +#include "IntRect.h" +#include + +namespace cc { + +class CCDamageTracker; +class CCDelegatedRendererLayerImpl; +class CCQuadSink; +class CCRenderPassSink; +class CCLayerImpl; + +struct CCAppendQuadsData; + +class CCRenderSurface { +public: + explicit CCRenderSurface(CCLayerImpl*); + virtual ~CCRenderSurface(); + + std::string name() const; + void dumpSurface(std::string*, int indent) const; + + FloatPoint contentRectCenter() const { return FloatRect(m_contentRect).center(); } + + // Returns the rect that encloses the RenderSurface including any reflection. + FloatRect drawableContentRect() const; + + float drawOpacity() const { return m_drawOpacity; } + void setDrawOpacity(float opacity) { m_drawOpacity = opacity; } + + void setNearestAncestorThatMovesPixels(CCRenderSurface* surface) { m_nearestAncestorThatMovesPixels = surface; } + const CCRenderSurface* nearestAncestorThatMovesPixels() const { return m_nearestAncestorThatMovesPixels; } + + bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; } + void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; } + + void setDrawTransform(const WebKit::WebTransformationMatrix& drawTransform) { m_drawTransform = drawTransform; } + const WebKit::WebTransformationMatrix& drawTransform() const { return m_drawTransform; } + + void setScreenSpaceTransform(const WebKit::WebTransformationMatrix& screenSpaceTransform) { m_screenSpaceTransform = screenSpaceTransform; } + const WebKit::WebTransformationMatrix& screenSpaceTransform() const { return m_screenSpaceTransform; } + + void setReplicaDrawTransform(const WebKit::WebTransformationMatrix& replicaDrawTransform) { m_replicaDrawTransform = replicaDrawTransform; } + const WebKit::WebTransformationMatrix& replicaDrawTransform() const { return m_replicaDrawTransform; } + + void setReplicaScreenSpaceTransform(const WebKit::WebTransformationMatrix& replicaScreenSpaceTransform) { m_replicaScreenSpaceTransform = replicaScreenSpaceTransform; } + const WebKit::WebTransformationMatrix& replicaScreenSpaceTransform() const { return m_replicaScreenSpaceTransform; } + + bool targetSurfaceTransformsAreAnimating() const { return m_targetSurfaceTransformsAreAnimating; } + void setTargetSurfaceTransformsAreAnimating(bool animating) { m_targetSurfaceTransformsAreAnimating = animating; } + bool screenSpaceTransformsAreAnimating() const { return m_screenSpaceTransformsAreAnimating; } + void setScreenSpaceTransformsAreAnimating(bool animating) { m_screenSpaceTransformsAreAnimating = animating; } + + void setClipRect(const IntRect&); + const IntRect& clipRect() const { return m_clipRect; } + + bool contentsChanged() const; + + void setContentRect(const IntRect&); + const IntRect& contentRect() const { return m_contentRect; } + + std::vector& layerList() { return m_layerList; } + void addContributingDelegatedRenderPassLayer(CCLayerImpl*); + void clearLayerLists(); + + int owningLayerId() const; + + void resetPropertyChangedFlag() { m_surfacePropertyChanged = false; } + bool surfacePropertyChanged() const; + bool surfacePropertyChangedOnlyFromDescendant() const; + + CCDamageTracker* damageTracker() const { return m_damageTracker.get(); } + + CCRenderPass::Id renderPassId(); + + void appendRenderPasses(CCRenderPassSink&); + void appendQuads(CCQuadSink&, CCAppendQuadsData&, bool forReplica, CCRenderPass::Id renderPassId); + +private: + CCLayerImpl* m_owningLayer; + + // Uses this surface's space. + IntRect m_contentRect; + bool m_surfacePropertyChanged; + + float m_drawOpacity; + bool m_drawOpacityIsAnimating; + WebKit::WebTransformationMatrix m_drawTransform; + WebKit::WebTransformationMatrix m_screenSpaceTransform; + WebKit::WebTransformationMatrix m_replicaDrawTransform; + WebKit::WebTransformationMatrix m_replicaScreenSpaceTransform; + bool m_targetSurfaceTransformsAreAnimating; + bool m_screenSpaceTransformsAreAnimating; + + // Uses the space of the surface's target surface. + IntRect m_clipRect; + + std::vector m_layerList; + std::vector m_contributingDelegatedRenderPassLayerList; + + // The nearest ancestor target surface that will contain the contents of this surface, and that is going + // to move pixels within the surface (such as with a blur). This can point to itself. + CCRenderSurface* m_nearestAncestorThatMovesPixels; + + scoped_ptr m_damageTracker; + + // For CCLayerIteratorActions + int m_targetRenderSurfaceLayerIndexHistory; + int m_currentLayerIndexHistory; + + friend struct CCLayerIteratorActions; + + DISALLOW_COPY_AND_ASSIGN(CCRenderSurface); +}; + +} +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCRenderer.cpp b/cc/renderer.cc similarity index 100% rename from cc/CCRenderer.cpp rename to cc/renderer.cc diff --git a/cc/renderer.h b/cc/renderer.h index 638cbb270ce9b2..740ba0b293e758 100644 --- a/cc/renderer.h +++ b/cc/renderer.h @@ -1,3 +1,84 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCRenderer_h +#define CCRenderer_h + +#include "base/basictypes.h" +#include "CCLayerTreeHost.h" +#include "CCRenderPass.h" +#include "FloatQuad.h" +#include "IntRect.h" +#include + +namespace cc { + +class CCScopedTexture; + +class CCRendererClient { +public: + virtual const IntSize& deviceViewportSize() const = 0; + virtual const CCLayerTreeSettings& settings() const = 0; + virtual void didLoseContext() = 0; + virtual void onSwapBuffersComplete() = 0; + virtual void releaseContentsTextures() = 0; + virtual void setFullRootLayerDamage() = 0; + virtual void setMemoryAllocationLimitBytes(size_t) = 0; +protected: + virtual ~CCRendererClient() { } +}; + +class CCRenderer { +public: + // This enum defines the various resource pools for the CCResourceProvider + // where textures get allocated. + enum ResourcePool { + ImplPool = 1, // This pool is for textures that get allocated on the impl thread (e.g. RenderSurfaces). + ContentPool // This pool is for textures that get allocated on the main thread (e.g. tiles). + }; + + virtual ~CCRenderer() { } + + virtual const RendererCapabilities& capabilities() const = 0; + + const CCLayerTreeSettings& settings() const { return m_client->settings(); } + + const IntSize& viewportSize() { return m_client->deviceViewportSize(); } + int viewportWidth() { return viewportSize().width(); } + int viewportHeight() { return viewportSize().height(); } + + virtual void viewportChanged() { } + + virtual void decideRenderPassAllocationsForFrame(const CCRenderPassList&) { } + virtual bool haveCachedResourcesForRenderPassId(CCRenderPass::Id) const; + + virtual void drawFrame(const CCRenderPassList&, const CCRenderPassIdHashMap&) = 0; + + // waits for rendering to finish + virtual void finish() = 0; + + virtual void doNoOp() { } + // puts backbuffer onscreen + virtual bool swapBuffers() = 0; + + virtual void getFramebufferPixels(void *pixels, const IntRect&) = 0; + + virtual bool isContextLost(); + + virtual void setVisible(bool) = 0; + +protected: + explicit CCRenderer(CCRendererClient* client) + : m_client(client) + { + } + + CCRendererClient* m_client; + + DISALLOW_COPY_AND_ASSIGN(CCRenderer); +}; + +} + +#endif // CCRenderer_h diff --git a/cc/rendering_stats.h b/cc/rendering_stats.h index 638cbb270ce9b2..fb178a89722fe3 100644 --- a/cc/rendering_stats.h +++ b/cc/rendering_stats.h @@ -1,3 +1,38 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCRenderingStats_h +#define CCRenderingStats_h + +namespace cc { + +struct CCRenderingStats { + // FIXME: Rename these to animationFrameCount and screenFrameCount, crbug.com/138641. + int numAnimationFrames; + int numFramesSentToScreen; + int droppedFrameCount; + double totalPaintTimeInSeconds; + double totalRasterizeTimeInSeconds; + double totalCommitTimeInSeconds; + size_t totalCommitCount; + size_t numImplThreadScrolls; + size_t numMainThreadScrolls; + + CCRenderingStats() + : numAnimationFrames(0) + , numFramesSentToScreen(0) + , droppedFrameCount(0) + , totalPaintTimeInSeconds(0) + , totalRasterizeTimeInSeconds(0) + , totalCommitTimeInSeconds(0) + , totalCommitCount(0) + , numImplThreadScrolls(0) + , numMainThreadScrolls(0) + { + } +}; + +} + +#endif diff --git a/cc/CCResourceProvider.cpp b/cc/resource_provider.cc similarity index 100% rename from cc/CCResourceProvider.cpp rename to cc/resource_provider.cc diff --git a/cc/resource_provider.h b/cc/resource_provider.h index 638cbb270ce9b2..f515c112daf733 100644 --- a/cc/resource_provider.h +++ b/cc/resource_provider.h @@ -1,3 +1,275 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCResourceProvider_h +#define CCResourceProvider_h + +#include "base/basictypes.h" +#include "CCGraphicsContext.h" +#include "GraphicsContext3D.h" +#include "IntSize.h" +#include "SkBitmap.h" +#include "SkCanvas.h" +#include "TextureCopier.h" +#include +#include +#include +#include +#include +#include +#include + +namespace WebKit { +class WebGraphicsContext3D; +} + +namespace cc { + +class IntRect; +class LayerTextureSubImage; +class TextureCopier; +class TextureUploader; + +// Thread-safety notes: this class is not thread-safe and can only be called +// from the thread it was created on (in practice, the compositor thread). +class CCResourceProvider { +public: + typedef unsigned ResourceId; + typedef Vector ResourceIdArray; + typedef HashMap ResourceIdMap; + enum TextureUsageHint { TextureUsageAny, TextureUsageFramebuffer }; + enum ResourceType { + GLTexture = 1, + Bitmap, + }; + struct Mailbox { + GC3Dbyte name[64]; + }; + struct TransferableResource { + unsigned id; + GC3Denum format; + IntSize size; + Mailbox mailbox; + }; + typedef Vector TransferableResourceArray; + struct TransferableResourceList { + TransferableResourceList(); + ~TransferableResourceList(); + + TransferableResourceArray resources; + unsigned syncPoint; + }; + + static PassOwnPtr create(CCGraphicsContext*); + + virtual ~CCResourceProvider(); + + WebKit::WebGraphicsContext3D* graphicsContext3D(); + TextureUploader* textureUploader() const { return m_textureUploader.get(); } + TextureCopier* textureCopier() const { return m_textureCopier.get(); } + int maxTextureSize() const { return m_maxTextureSize; } + unsigned numResources() const { return m_resources.size(); } + + // Checks whether a resource is in use by a consumer. + bool inUseByConsumer(ResourceId); + + + // Producer interface. + + void setDefaultResourceType(ResourceType type) { m_defaultResourceType = type; } + ResourceType defaultResourceType() const { return m_defaultResourceType; } + ResourceType resourceType(ResourceId); + + // Creates a resource of the default resource type. + ResourceId createResource(int pool, const IntSize&, GC3Denum format, TextureUsageHint); + + // You can also explicitly create a specific resource type. + ResourceId createGLTexture(int pool, const IntSize&, GC3Denum format, TextureUsageHint); + ResourceId createBitmap(int pool, const IntSize&); + // Wraps an external texture into a GL resource. + ResourceId createResourceFromExternalTexture(unsigned textureId); + + void deleteResource(ResourceId); + + // Deletes all resources owned by a given pool. + void deleteOwnedResources(int pool); + + // Upload data from image, copying sourceRect (in image) into destRect (in the resource). + void upload(ResourceId, const uint8_t* image, const IntRect& imageRect, const IntRect& sourceRect, const IntSize& destOffset); + + // Flush all context operations, kicking uploads and ensuring ordering with + // respect to other contexts. + void flush(); + + // Only flush the command buffer if supported. + // Returns true if the shallow flush occurred, false otherwise. + bool shallowFlushIfSupported(); + + // Creates accounting for a child, and associate it with a pool. Resources + // transfered from that child will go to that pool. Returns a child ID. + int createChild(int pool); + + // Destroys accounting for the child, deleting all resources from that pool. + void destroyChild(int child); + + // Gets the child->parent resource ID map. + const ResourceIdMap& getChildToParentMap(int child) const; + + // Prepares resources to be transfered to the parent, moving them to + // mailboxes and serializing meta-data into TransferableResources. + // Resources are not removed from the CCResourceProvider, but are markes as + // "in use". + TransferableResourceList prepareSendToParent(const ResourceIdArray&); + + // Prepares resources to be transfered back to the child, moving them to + // mailboxes and serializing meta-data into TransferableResources. + // Resources are removed from the CCResourceProvider. Note: the resource IDs + // passed are in the parent namespace and will be translated to the child + // namespace when returned. + TransferableResourceList prepareSendToChild(int child, const ResourceIdArray&); + + // Receives resources from a child, moving them from mailboxes. Resource IDs + // passed are in the child namespace, and will be translated to the parent + // namespace, added to the child->parent map. + // NOTE: if the syncPoint filed in TransferableResourceList is set, this + // will wait on it. + void receiveFromChild(int child, const TransferableResourceList&); + + // Receives resources from the parent, moving them from mailboxes. Resource IDs + // passed are in the child namespace. + // NOTE: if the syncPoint filed in TransferableResourceList is set, this + // will wait on it. + void receiveFromParent(const TransferableResourceList&); + + // Only for testing + size_t mailboxCount() const { return m_mailboxes.size(); } + + // The following lock classes are part of the CCResourceProvider API and are + // needed to read and write the resource contents. The user must ensure + // that they only use GL locks on GL resources, etc, and this is enforced + // by assertions. + class ScopedReadLockGL { + public: + ScopedReadLockGL(CCResourceProvider*, CCResourceProvider::ResourceId); + ~ScopedReadLockGL(); + + unsigned textureId() const { return m_textureId; } + + private: + CCResourceProvider* m_resourceProvider; + CCResourceProvider::ResourceId m_resourceId; + unsigned m_textureId; + + DISALLOW_COPY_AND_ASSIGN(ScopedReadLockGL); + }; + + class ScopedWriteLockGL { + public: + ScopedWriteLockGL(CCResourceProvider*, CCResourceProvider::ResourceId); + ~ScopedWriteLockGL(); + + unsigned textureId() const { return m_textureId; } + + private: + CCResourceProvider* m_resourceProvider; + CCResourceProvider::ResourceId m_resourceId; + unsigned m_textureId; + + DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGL); + }; + + class ScopedReadLockSoftware { + public: + ScopedReadLockSoftware(CCResourceProvider*, CCResourceProvider::ResourceId); + ~ScopedReadLockSoftware(); + + const SkBitmap* skBitmap() const { return &m_skBitmap; } + + private: + CCResourceProvider* m_resourceProvider; + CCResourceProvider::ResourceId m_resourceId; + SkBitmap m_skBitmap; + + DISALLOW_COPY_AND_ASSIGN(ScopedReadLockSoftware); + }; + + class ScopedWriteLockSoftware { + public: + ScopedWriteLockSoftware(CCResourceProvider*, CCResourceProvider::ResourceId); + ~ScopedWriteLockSoftware(); + + SkCanvas* skCanvas() { return m_skCanvas.get(); } + + private: + CCResourceProvider* m_resourceProvider; + CCResourceProvider::ResourceId m_resourceId; + SkBitmap m_skBitmap; + OwnPtr m_skCanvas; + + DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockSoftware); + }; + +private: + struct Resource { + Resource(); + Resource(unsigned textureId, int pool, const IntSize& size, GC3Denum format); + Resource(uint8_t* pixels, int pool, const IntSize& size, GC3Denum format); + + unsigned glId; + uint8_t* pixels; + int pool; + int lockForReadCount; + bool lockedForWrite; + bool external; + bool exported; + IntSize size; + GC3Denum format; + ResourceType type; + }; + typedef HashMap ResourceMap; + struct Child { + Child(); + ~Child(); + + int pool; + ResourceIdMap childToParentMap; + ResourceIdMap parentToChildMap; + }; + typedef HashMap ChildMap; + + explicit CCResourceProvider(CCGraphicsContext*); + bool initialize(); + + const Resource* lockForRead(ResourceId); + void unlockForRead(ResourceId); + const Resource* lockForWrite(ResourceId); + void unlockForWrite(ResourceId); + static void populateSkBitmapWithResource(SkBitmap*, const Resource*); + + bool transferResource(WebKit::WebGraphicsContext3D*, ResourceId, TransferableResource*); + void trimMailboxDeque(); + + CCGraphicsContext* m_context; + ResourceId m_nextId; + ResourceMap m_resources; + int m_nextChild; + ChildMap m_children; + + Deque m_mailboxes; + + ResourceType m_defaultResourceType; + bool m_useTextureStorageExt; + bool m_useTextureUsageHint; + bool m_useShallowFlush; + OwnPtr m_texSubImage; + OwnPtr m_textureUploader; + OwnPtr m_textureCopier; + int m_maxTextureSize; + + DISALLOW_COPY_AND_ASSIGN(CCResourceProvider); +}; + +} + +#endif diff --git a/cc/CCScheduler.cpp b/cc/scheduler.cc similarity index 100% rename from cc/CCScheduler.cpp rename to cc/scheduler.cc diff --git a/cc/scheduler.h b/cc/scheduler.h index 638cbb270ce9b2..1b483074b7cbd2 100644 --- a/cc/scheduler.h +++ b/cc/scheduler.h @@ -1,3 +1,109 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCScheduler_h +#define CCScheduler_h + +#include "base/basictypes.h" +#include "base/memory/scoped_ptr.h" +#include "base/time.h" +#include "CCFrameRateController.h" +#include "CCSchedulerStateMachine.h" +#include + +namespace cc { + +class CCThread; + +struct CCScheduledActionDrawAndSwapResult { + CCScheduledActionDrawAndSwapResult() + : didDraw(false) + , didSwap(false) + { + } + CCScheduledActionDrawAndSwapResult(bool didDraw, bool didSwap) + : didDraw(didDraw) + , didSwap(didSwap) + { + } + bool didDraw; + bool didSwap; +}; + +class CCSchedulerClient { +public: + virtual void scheduledActionBeginFrame() = 0; + virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible() = 0; + virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced() = 0; + virtual void scheduledActionCommit() = 0; + virtual void scheduledActionBeginContextRecreation() = 0; + virtual void scheduledActionAcquireLayerTexturesForMainThread() = 0; + virtual void didAnticipatedDrawTimeChange(base::TimeTicks) = 0; + +protected: + virtual ~CCSchedulerClient() { } +}; + +class CCScheduler : CCFrameRateControllerClient { +public: + static PassOwnPtr create(CCSchedulerClient* client, scoped_ptr frameRateController) + { + return adoptPtr(new CCScheduler(client, frameRateController.Pass())); + } + + virtual ~CCScheduler(); + + void setCanBeginFrame(bool); + + void setVisible(bool); + void setCanDraw(bool); + + void setNeedsCommit(); + + // Like setNeedsCommit(), but ensures a commit will definitely happen even if we are not visible. + void setNeedsForcedCommit(); + + void setNeedsRedraw(); + + void setMainThreadNeedsLayerTextures(); + + // Like setNeedsRedraw(), but ensures the draw will definitely happen even if we are not visible. + void setNeedsForcedRedraw(); + + void beginFrameComplete(); + void beginFrameAborted(); + + void setMaxFramesPending(int); + void setSwapBuffersCompleteSupported(bool); + void didSwapBuffersComplete(); + + void didLoseContext(); + void didRecreateContext(); + + bool commitPending() const { return m_stateMachine.commitPending(); } + bool redrawPending() const { return m_stateMachine.redrawPending(); } + + void setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval); + + base::TimeTicks anticipatedDrawTime(); + + // CCFrameRateControllerClient implementation + virtual void vsyncTick(bool throttled) OVERRIDE; + +private: + CCScheduler(CCSchedulerClient*, scoped_ptr); + + void processScheduledActions(); + + CCSchedulerClient* m_client; + scoped_ptr m_frameRateController; + CCSchedulerStateMachine m_stateMachine; + bool m_insideProcessScheduledActions; + + DISALLOW_COPY_AND_ASSIGN(CCScheduler); +}; + +} // namespace cc + +#endif // CCScheduler_h diff --git a/cc/CCSchedulerStateMachine.cpp b/cc/scheduler_state_machine.cc similarity index 100% rename from cc/CCSchedulerStateMachine.cpp rename to cc/scheduler_state_machine.cc diff --git a/cc/scheduler_state_machine.h b/cc/scheduler_state_machine.h index 638cbb270ce9b2..092231f59c345d 100644 --- a/cc/scheduler_state_machine.h +++ b/cc/scheduler_state_machine.h @@ -1,3 +1,161 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCSchedulerStateMachine_h +#define CCSchedulerStateMachine_h + +#include + +#include "base/basictypes.h" + +namespace cc { + +// The CCSchedulerStateMachine decides how to coordinate main thread activites +// like painting/running javascript with rendering and input activities on the +// impl thread. +// +// The state machine tracks internal state but is also influenced by external state. +// Internal state includes things like whether a frame has been requested, while +// external state includes things like the current time being near to the vblank time. +// +// The scheduler seperates "what to do next" from the updating of its internal state to +// make testing cleaner. +class CCSchedulerStateMachine { +public: + CCSchedulerStateMachine(); + + enum CommitState { + COMMIT_STATE_IDLE, + COMMIT_STATE_FRAME_IN_PROGRESS, + COMMIT_STATE_READY_TO_COMMIT, + COMMIT_STATE_WAITING_FOR_FIRST_DRAW, + }; + + enum TextureState { + LAYER_TEXTURE_STATE_UNLOCKED, + LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD, + LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD, + }; + + enum ContextState { + CONTEXT_ACTIVE, + CONTEXT_LOST, + CONTEXT_RECREATING, + }; + + bool commitPending() const + { + return m_commitState != COMMIT_STATE_IDLE; + } + + bool redrawPending() const { return m_needsRedraw; } + + enum Action { + ACTION_NONE, + ACTION_BEGIN_FRAME, + ACTION_COMMIT, + ACTION_DRAW_IF_POSSIBLE, + ACTION_DRAW_FORCED, + ACTION_BEGIN_CONTEXT_RECREATION, + ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD, + }; + Action nextAction() const; + void updateState(Action); + + // Indicates whether the scheduler needs a vsync callback in order to make + // progress. + bool vsyncCallbackNeeded() const; + + // Indicates that the system has entered and left a vsync callback. + // The scheduler will not draw more than once in a given vsync callback. + void didEnterVSync(); + void didLeaveVSync(); + + // Indicates whether the LayerTreeHostImpl is visible. + void setVisible(bool); + + // Indicates that a redraw is required, either due to the impl tree changing + // or the screen being damaged and simply needing redisplay. + void setNeedsRedraw(); + + // As setNeedsRedraw(), but ensures the draw will definitely happen even if + // we are not visible. + void setNeedsForcedRedraw(); + + // Indicates whether ACTION_DRAW_IF_POSSIBLE drew to the screen or not. + void didDrawIfPossibleCompleted(bool success); + + // Indicates that a new commit flow needs to be performed, either to pull + // updates from the main thread to the impl, or to push deltas from the impl + // thread to main. + void setNeedsCommit(); + + // As setNeedsCommit(), but ensures the beginFrame will definitely happen even if + // we are not visible. + void setNeedsForcedCommit(); + + // Call this only in response to receiving an ACTION_BEGIN_FRAME + // from nextState. Indicates that all painting is complete. + void beginFrameComplete(); + + // Call this only in response to receiving an ACTION_BEGIN_FRAME + // from nextState if the client rejects the beginFrame message. + void beginFrameAborted(); + + // Request exclusive access to the textures that back single buffered + // layers on behalf of the main thread. Upon acqusition, + // ACTION_DRAW_IF_POSSIBLE will not draw until the main thread releases the + // textures to the impl thread by committing the layers. + void setMainThreadNeedsLayerTextures(); + + // Indicates whether we can successfully begin a frame at this time. + void setCanBeginFrame(bool can) { m_canBeginFrame = can; } + + // Indicates whether drawing would, at this time, make sense. + // canDraw can be used to supress flashes or checkerboarding + // when such behavior would be undesirable. + void setCanDraw(bool can) { m_canDraw = can; } + + void didLoseContext(); + void didRecreateContext(); + + // Exposed for testing purposes. + void setMaximumNumberOfFailedDrawsBeforeDrawIsForced(int); + + std::string toString(); + +protected: + bool shouldDrawForced() const; + bool drawSuspendedUntilCommit() const; + bool scheduledToDraw() const; + bool shouldDraw() const; + bool shouldAcquireLayerTexturesForMainThread() const; + bool hasDrawnThisFrame() const; + + CommitState m_commitState; + + int m_currentFrameNumber; + int m_lastFrameNumberWhereDrawWasCalled; + int m_consecutiveFailedDraws; + int m_maximumNumberOfFailedDrawsBeforeDrawIsForced; + bool m_needsRedraw; + bool m_needsForcedRedraw; + bool m_needsForcedRedrawAfterNextCommit; + bool m_needsCommit; + bool m_needsForcedCommit; + bool m_mainThreadNeedsLayerTextures; + bool m_insideVSync; + bool m_visible; + bool m_canBeginFrame; + bool m_canDraw; + bool m_drawIfPossibleFailed; + TextureState m_textureState; + ContextState m_contextState; + + DISALLOW_COPY_AND_ASSIGN(CCSchedulerStateMachine); +}; + +} + +#endif // CCSchedulerStateMachine_h diff --git a/cc/CCScopedTexture.cpp b/cc/scoped_texture.cc similarity index 100% rename from cc/CCScopedTexture.cpp rename to cc/scoped_texture.cc diff --git a/cc/scoped_texture.h b/cc/scoped_texture.h index 638cbb270ce9b2..a5b615c6e7c08a 100644 --- a/cc/scoped_texture.h +++ b/cc/scoped_texture.h @@ -1,3 +1,46 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCScopedTexture_h +#define CCScopedTexture_h + +#include "base/basictypes.h" +#include "CCTexture.h" + +#if !ASSERT_DISABLED +#include "base/threading/platform_thread.h" +#endif + +namespace cc { + +class CCScopedTexture : protected CCTexture { +public: + static PassOwnPtr create(CCResourceProvider* resourceProvider) { return adoptPtr(new CCScopedTexture(resourceProvider)); } + virtual ~CCScopedTexture(); + + using CCTexture::id; + using CCTexture::size; + using CCTexture::format; + using CCTexture::bytes; + + bool allocate(int pool, const IntSize&, GC3Denum format, CCResourceProvider::TextureUsageHint); + void free(); + void leak(); + +protected: + explicit CCScopedTexture(CCResourceProvider*); + +private: + CCResourceProvider* m_resourceProvider; + +#if !ASSERT_DISABLED + base::PlatformThreadId m_allocateThreadIdentifier; +#endif + + DISALLOW_COPY_AND_ASSIGN(CCScopedTexture); +}; + +} + +#endif diff --git a/cc/CCScopedThreadProxy.cpp b/cc/scoped_thread_proxy.cc similarity index 100% rename from cc/CCScopedThreadProxy.cpp rename to cc/scoped_thread_proxy.cc diff --git a/cc/scoped_thread_proxy.h b/cc/scoped_thread_proxy.h index 638cbb270ce9b2..802046dcfa858a 100644 --- a/cc/scoped_thread_proxy.h +++ b/cc/scoped_thread_proxy.h @@ -1,3 +1,74 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCScopedThreadProxy_h +#define CCScopedThreadProxy_h + +#include "CCThreadTask.h" +#include "base/threading/platform_thread.h" +#include +#include +#include + +namespace cc { + +// This class is a proxy used to post tasks to an target thread from any other thread. The proxy may be shut down at +// any point from the target thread after which no more tasks posted to the proxy will run. In other words, all +// tasks posted via a proxy are scoped to the lifecycle of the proxy. Use this when posting tasks to an object that +// might die with tasks in flight. +// +// The proxy must be created and shut down from the target thread, tasks may be posted from any thread. +// +// Implementation note: Unlike ScopedRunnableMethodFactory in Chromium, pending tasks are not cancelled by actually +// destroying the proxy. Instead each pending task holds a reference to the proxy to avoid maintaining an explicit +// list of outstanding tasks. +class CCScopedThreadProxy : public ThreadSafeRefCounted { +public: + static PassRefPtr create(CCThread* targetThread) + { + ASSERT(base::PlatformThread::CurrentId() == targetThread->threadID()); + return adoptRef(new CCScopedThreadProxy(targetThread)); + } + + ~CCScopedThreadProxy(); + + // Can be called from any thread. Posts a task to the target thread that runs unless + // shutdown() is called before it runs. + void postTask(PassOwnPtr task) + { + ref(); + m_targetThread->postTask(createCCThreadTask(this, &CCScopedThreadProxy::runTaskIfNotShutdown, task)); + } + + void shutdown() + { + ASSERT(base::PlatformThread::CurrentId() == m_targetThread->threadID()); + ASSERT(!m_shutdown); + m_shutdown = true; + } + +private: + explicit CCScopedThreadProxy(CCThread* targetThread); + + void runTaskIfNotShutdown(PassOwnPtr popTask) + { + OwnPtr task = popTask; + // If our shutdown flag is set, it's possible that m_targetThread has already been destroyed so don't + // touch it. + if (m_shutdown) { + deref(); + return; + } + ASSERT(base::PlatformThread::CurrentId() == m_targetThread->threadID()); + task->performTask(); + deref(); + } + + CCThread* m_targetThread; + bool m_shutdown; // Only accessed on the target thread +}; + +} + +#endif diff --git a/cc/CCScrollbarAnimationController.cpp b/cc/scrollbar_animation_controller.cc similarity index 100% rename from cc/CCScrollbarAnimationController.cpp rename to cc/scrollbar_animation_controller.cc diff --git a/cc/scrollbar_animation_controller.h b/cc/scrollbar_animation_controller.h index 638cbb270ce9b2..bb387d7bf1c767 100644 --- a/cc/scrollbar_animation_controller.h +++ b/cc/scrollbar_animation_controller.h @@ -1,3 +1,64 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCScrollbarAnimationController_h +#define CCScrollbarAnimationController_h + +#include "FloatPoint.h" +#include "IntSize.h" +#include + +namespace cc { + +class CCLayerImpl; +class CCScrollbarLayerImpl; + +// This abstract class represents the compositor-side analogy of ScrollbarAnimator. +// Individual platforms should subclass it to provide specialized implementation. +class CCScrollbarAnimationController { +public: + // Implemented by subclass. + static PassOwnPtr create(CCLayerImpl* scrollLayer); + + virtual ~CCScrollbarAnimationController(); + + virtual bool animate(double monotonicTime); + void didPinchGestureBegin(); + void didPinchGestureUpdate(); + void didPinchGestureEnd(); + void updateScrollOffset(CCLayerImpl* scrollLayer); + + void setHorizontalScrollbarLayer(CCScrollbarLayerImpl* layer) { m_horizontalScrollbarLayer = layer; } + CCScrollbarLayerImpl* horizontalScrollbarLayer() const { return m_horizontalScrollbarLayer; } + + void setVerticalScrollbarLayer(CCScrollbarLayerImpl* layer) { m_verticalScrollbarLayer = layer; } + CCScrollbarLayerImpl* verticalScrollbarLayer() const { return m_verticalScrollbarLayer; } + + FloatPoint currentPos() const { return m_currentPos; } + IntSize totalSize() const { return m_totalSize; } + IntSize maximum() const { return m_maximum; } + + virtual void didPinchGestureBeginAtTime(double monotonicTime) { } + virtual void didPinchGestureUpdateAtTime(double monotonicTime) { } + virtual void didPinchGestureEndAtTime(double monotonicTime) { } + virtual void updateScrollOffsetAtTime(CCLayerImpl* scrollLayer, double monotonicTime); + +protected: + explicit CCScrollbarAnimationController(CCLayerImpl* scrollLayer); + +private: + static IntSize getScrollLayerBounds(const CCLayerImpl*); + + // Beware of dangling pointer. Always update these during tree synchronization. + CCScrollbarLayerImpl* m_horizontalScrollbarLayer; + CCScrollbarLayerImpl* m_verticalScrollbarLayer; + + FloatPoint m_currentPos; + IntSize m_totalSize; + IntSize m_maximum; +}; + +} // namespace cc + +#endif // CCScrollbarAnimationController_h diff --git a/cc/CCScrollbarAnimationControllerLinearFade.cpp b/cc/scrollbar_animation_controller_linear_fade.cc similarity index 100% rename from cc/CCScrollbarAnimationControllerLinearFade.cpp rename to cc/scrollbar_animation_controller_linear_fade.cc diff --git a/cc/scrollbar_animation_controller_linear_fade.h b/cc/scrollbar_animation_controller_linear_fade.h index 638cbb270ce9b2..749dca5e3f3493 100644 --- a/cc/scrollbar_animation_controller_linear_fade.h +++ b/cc/scrollbar_animation_controller_linear_fade.h @@ -1,3 +1,39 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCScrollbarAnimationControllerLinearFade_h +#define CCScrollbarAnimationControllerLinearFade_h + +#include "CCScrollbarAnimationController.h" + +namespace cc { + +class CCScrollbarAnimationControllerLinearFade : public CCScrollbarAnimationController { +public: + static PassOwnPtr create(CCLayerImpl* scrollLayer, double fadeoutDelay, double fadeoutLength); + + virtual ~CCScrollbarAnimationControllerLinearFade(); + + virtual bool animate(double monotonicTime) OVERRIDE; + + virtual void didPinchGestureUpdateAtTime(double monotonicTime) OVERRIDE; + virtual void didPinchGestureEndAtTime(double monotonicTime) OVERRIDE; + virtual void updateScrollOffsetAtTime(CCLayerImpl* scrollLayer, double monotonicTime) OVERRIDE; + +protected: + CCScrollbarAnimationControllerLinearFade(CCLayerImpl* scrollLayer, double fadeoutDelay, double fadeoutLength); + +private: + float opacityAtTime(double monotonicTime); + + double m_lastAwakenTime; + bool m_pinchGestureInEffect; + + double m_fadeoutDelay; + double m_fadeoutLength; +}; + +} // namespace cc + +#endif // CCScrollbarAnimationControllerLinearFade_h diff --git a/cc/CCScrollbarGeometryFixedThumb.cpp b/cc/scrollbar_geometry_fixed_thumb.cc similarity index 100% rename from cc/CCScrollbarGeometryFixedThumb.cpp rename to cc/scrollbar_geometry_fixed_thumb.cc diff --git a/cc/scrollbar_geometry_fixed_thumb.h b/cc/scrollbar_geometry_fixed_thumb.h index 638cbb270ce9b2..fe0db12f263604 100644 --- a/cc/scrollbar_geometry_fixed_thumb.h +++ b/cc/scrollbar_geometry_fixed_thumb.h @@ -1,3 +1,39 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCScrollbarGeometryFixedThumb_h +#define CCScrollbarGeometryFixedThumb_h + +#include "CCScrollbarGeometryStub.h" +#include "IntSize.h" + +namespace cc { + +// This scrollbar geometry class behaves exactly like a normal geometry except +// it always returns a fixed thumb length. This allows a page to zoom (changing +// the total size of the scrollable area, changing the thumb length) while not +// requiring the thumb resource to be repainted. +class CCScrollbarGeometryFixedThumb : public CCScrollbarGeometryStub { +public: + static PassOwnPtr create(PassOwnPtr); + virtual ~CCScrollbarGeometryFixedThumb(); + + // Update thumb length from scrollbar + void update(WebKit::WebScrollbar*); + + // WebScrollbarThemeGeometry interface + virtual WebKit::WebScrollbarThemeGeometry* clone() const OVERRIDE; + virtual int thumbLength(WebKit::WebScrollbar*) OVERRIDE; + virtual int thumbPosition(WebKit::WebScrollbar*) OVERRIDE; + virtual void splitTrack(WebKit::WebScrollbar*, const WebKit::WebRect& track, WebKit::WebRect& startTrack, WebKit::WebRect& thumb, WebKit::WebRect& endTrack) OVERRIDE; + +private: + explicit CCScrollbarGeometryFixedThumb(PassOwnPtr); + + IntSize m_thumbSize; +}; + +} + +#endif diff --git a/cc/CCScrollbarGeometryStub.cpp b/cc/scrollbar_geometry_stub.cc similarity index 100% rename from cc/CCScrollbarGeometryStub.cpp rename to cc/scrollbar_geometry_stub.cc diff --git a/cc/scrollbar_geometry_stub.h b/cc/scrollbar_geometry_stub.h index 638cbb270ce9b2..0d23a4e78bd8d5 100644 --- a/cc/scrollbar_geometry_stub.h +++ b/cc/scrollbar_geometry_stub.h @@ -1,3 +1,52 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCScrollbarGeometryStub_h +#define CCScrollbarGeometryStub_h + +#include +#include +#include + +namespace cc { + +// This subclass wraps an existing scrollbar geometry class so that +// another class can derive from it and override specific functions, while +// passing through the remaining ones. +class CCScrollbarGeometryStub : public WebKit::WebScrollbarThemeGeometry { +public: + virtual ~CCScrollbarGeometryStub(); + + // Allow derived classes to update themselves from a scrollbar. + void update(WebKit::WebScrollbar*) { } + + // WebScrollbarThemeGeometry interface + virtual WebKit::WebScrollbarThemeGeometry* clone() const OVERRIDE; + virtual int thumbPosition(WebKit::WebScrollbar*) OVERRIDE; + virtual int thumbLength(WebKit::WebScrollbar*) OVERRIDE; + virtual int trackPosition(WebKit::WebScrollbar*) OVERRIDE; + virtual int trackLength(WebKit::WebScrollbar*) OVERRIDE; + virtual bool hasButtons(WebKit::WebScrollbar*) OVERRIDE; + virtual bool hasThumb(WebKit::WebScrollbar*) OVERRIDE; + virtual WebKit::WebRect trackRect(WebKit::WebScrollbar*) OVERRIDE; + virtual WebKit::WebRect thumbRect(WebKit::WebScrollbar*) OVERRIDE; + virtual int minimumThumbLength(WebKit::WebScrollbar*) OVERRIDE; + virtual int scrollbarThickness(WebKit::WebScrollbar*) OVERRIDE; + virtual WebKit::WebRect backButtonStartRect(WebKit::WebScrollbar*) OVERRIDE; + virtual WebKit::WebRect backButtonEndRect(WebKit::WebScrollbar*) OVERRIDE; + virtual WebKit::WebRect forwardButtonStartRect(WebKit::WebScrollbar*) OVERRIDE; + virtual WebKit::WebRect forwardButtonEndRect(WebKit::WebScrollbar*) OVERRIDE; + virtual WebKit::WebRect constrainTrackRectToTrackPieces(WebKit::WebScrollbar*, const WebKit::WebRect&) OVERRIDE; + virtual void splitTrack(WebKit::WebScrollbar*, const WebKit::WebRect& track, WebKit::WebRect& startTrack, WebKit::WebRect& thumb, WebKit::WebRect& endTrack) OVERRIDE; + +protected: + explicit CCScrollbarGeometryStub(PassOwnPtr); + +private: + OwnPtr m_geometry; +}; + +} + +#endif diff --git a/cc/ScrollbarLayerChromium.cpp b/cc/scrollbar_layer.cc similarity index 100% rename from cc/ScrollbarLayerChromium.cpp rename to cc/scrollbar_layer.cc diff --git a/cc/scrollbar_layer.h b/cc/scrollbar_layer.h index 638cbb270ce9b2..5c7cc5c0cd293c 100644 --- a/cc/scrollbar_layer.h +++ b/cc/scrollbar_layer.h @@ -1,3 +1,70 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef ScrollbarLayerChromium_h +#define ScrollbarLayerChromium_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "LayerChromium.h" +#include "caching_bitmap_canvas_layer_texture_updater.h" +#include +#include +#include + +namespace cc { + +class Scrollbar; +class ScrollbarThemeComposite; +class CCTextureUpdateQueue; + +class ScrollbarLayerChromium : public LayerChromium { +public: + virtual scoped_ptr createCCLayerImpl() OVERRIDE; + + static scoped_refptr create(PassOwnPtr, WebKit::WebScrollbarThemePainter, PassOwnPtr, int scrollLayerId); + + // LayerChromium interface + virtual bool needsContentsScale() const OVERRIDE; + virtual IntSize contentBounds() const OVERRIDE; + virtual void setTexturePriorities(const CCPriorityCalculator&) OVERRIDE; + virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) OVERRIDE; + virtual void setLayerTreeHost(CCLayerTreeHost*) OVERRIDE; + virtual void pushPropertiesTo(CCLayerImpl*) OVERRIDE; + + int scrollLayerId() const { return m_scrollLayerId; } + void setScrollLayerId(int id) { m_scrollLayerId = id; } + + virtual ScrollbarLayerChromium* toScrollbarLayerChromium() OVERRIDE; + +protected: + ScrollbarLayerChromium(PassOwnPtr, WebKit::WebScrollbarThemePainter, PassOwnPtr, int scrollLayerId); + virtual ~ScrollbarLayerChromium(); + +private: + void updatePart(CachingBitmapCanvasLayerTextureUpdater*, LayerTextureUpdater::Texture*, const IntRect&, CCTextureUpdateQueue&, CCRenderingStats&); + void createTextureUpdaterIfNeeded(); + + OwnPtr m_scrollbar; + WebKit::WebScrollbarThemePainter m_painter; + OwnPtr m_geometry; + int m_scrollLayerId; + + GC3Denum m_textureFormat; + + RefPtr m_backTrackUpdater; + RefPtr m_foreTrackUpdater; + RefPtr m_thumbUpdater; + + // All the parts of the scrollbar except the thumb + OwnPtr m_backTrack; + OwnPtr m_foreTrack; + OwnPtr m_thumb; +}; + +} +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCScrollbarLayerImpl.cpp b/cc/scrollbar_layer_impl.cc similarity index 100% rename from cc/CCScrollbarLayerImpl.cpp rename to cc/scrollbar_layer_impl.cc diff --git a/cc/scrollbar_layer_impl.h b/cc/scrollbar_layer_impl.h index 638cbb270ce9b2..e7cf58417a7ba1 100644 --- a/cc/scrollbar_layer_impl.h +++ b/cc/scrollbar_layer_impl.h @@ -1,3 +1,112 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCScrollbarLayerImpl_h +#define CCScrollbarLayerImpl_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "CCLayerImpl.h" +#include "CCScrollbarGeometryFixedThumb.h" +#include +#include +#include + +namespace cc { + +class ScrollView; + +class CCScrollbarLayerImpl : public CCLayerImpl { +public: + static scoped_ptr create(int id); + virtual ~CCScrollbarLayerImpl(); + + CCScrollbarGeometryFixedThumb* scrollbarGeometry() const { return m_geometry.get(); } + void setScrollbarGeometry(PassOwnPtr); + void setScrollbarData(WebKit::WebScrollbar*); + + void setBackTrackResourceId(CCResourceProvider::ResourceId id) { m_backTrackResourceId = id; } + void setForeTrackResourceId(CCResourceProvider::ResourceId id) { m_foreTrackResourceId = id; } + void setThumbResourceId(CCResourceProvider::ResourceId id) { m_thumbResourceId = id; } + + float currentPos() const { return m_currentPos; } + void setCurrentPos(float currentPos) { m_currentPos = currentPos; } + + int totalSize() const { return m_totalSize; } + void setTotalSize(int totalSize) { m_totalSize = totalSize; } + + int maximum() const { return m_maximum; } + void setMaximum(int maximum) { m_maximum = maximum; } + + WebKit::WebScrollbar::Orientation orientation() const { return m_orientation; } + + virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; + + virtual void didLoseContext() OVERRIDE; + +protected: + explicit CCScrollbarLayerImpl(int id); + +private: + // nested class only to avoid namespace problem + class CCScrollbar : public WebKit::WebScrollbar { + public: + explicit CCScrollbar(CCScrollbarLayerImpl* owner) : m_owner(owner) { } + + // WebScrollbar implementation + virtual bool isOverlay() const; + virtual int value() const; + virtual WebKit::WebPoint location() const; + virtual WebKit::WebSize size() const; + virtual bool enabled() const; + virtual int maximum() const; + virtual int totalSize() const; + virtual bool isScrollViewScrollbar() const; + virtual bool isScrollableAreaActive() const; + virtual void getTickmarks(WebKit::WebVector& tickmarks) const; + virtual WebScrollbar::ScrollbarControlSize controlSize() const; + virtual WebScrollbar::ScrollbarPart pressedPart() const; + virtual WebScrollbar::ScrollbarPart hoveredPart() const; + virtual WebScrollbar::ScrollbarOverlayStyle scrollbarOverlayStyle() const; + virtual WebScrollbar::Orientation orientation() const; + virtual bool isCustomScrollbar() const; + + private: + CCScrollbarLayerImpl* m_owner; + + }; + + virtual const char* layerTypeAsString() const OVERRIDE; + + CCScrollbar m_scrollbar; + + CCResourceProvider::ResourceId m_backTrackResourceId; + CCResourceProvider::ResourceId m_foreTrackResourceId; + CCResourceProvider::ResourceId m_thumbResourceId; + + OwnPtr m_geometry; + + // Data to implement CCScrollbar + WebKit::WebScrollbar::ScrollbarOverlayStyle m_scrollbarOverlayStyle; + WebKit::WebVector m_tickmarks; + WebKit::WebScrollbar::Orientation m_orientation; + WebKit::WebScrollbar::ScrollbarControlSize m_controlSize; + WebKit::WebScrollbar::ScrollbarPart m_pressedPart; + WebKit::WebScrollbar::ScrollbarPart m_hoveredPart; + + float m_currentPos; + int m_totalSize; + int m_maximum; + + bool m_isScrollableAreaActive; + bool m_isScrollViewScrollbar; + bool m_enabled; + bool m_isCustomScrollbar; + bool m_isOverlayScrollbar; +}; + +} +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCSettings.cpp b/cc/settings.cc similarity index 100% rename from cc/CCSettings.cpp rename to cc/settings.cc diff --git a/cc/settings.h b/cc/settings.h index 638cbb270ce9b2..cde48caa2a453c 100644 --- a/cc/settings.h +++ b/cc/settings.h @@ -1,3 +1,40 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCSettings_h +#define CCSettings_h + +#include "IntSize.h" + +namespace cc { + +// This file is for settings that apply to all compositors. Add settings to +// CCLayerTreeSettings if a ui and renderer compositor might not want the same +// setting. + +class CCSettings { +public: + static bool perTilePaintingEnabled(); + static bool partialSwapEnabled(); + static bool acceleratedAnimationEnabled(); + static bool pageScalePinchZoomEnabled(); + + static bool jankInsteadOfCheckerboard(); + static bool backgroundColorInsteadOfCheckerboard(); + + // These setters should only be used on the main thread before the layer + // renderer is initialized. + static void setPerTilePaintingEnabled(bool); + static void setPartialSwapEnabled(bool); + static void setAcceleratedAnimationEnabled(bool); + static void setPageScalePinchZoomEnabled(bool); + + // These settings are meant to be set only once, and only read thereafter. + // This function is only for resetting settings in tests. + static void reset(); +}; + +} // namespace cc + +#endif // CCSettings_h diff --git a/cc/ShaderChromium.cpp b/cc/shader.cc similarity index 100% rename from cc/ShaderChromium.cpp rename to cc/shader.cc diff --git a/cc/shader.h b/cc/shader.h index 638cbb270ce9b2..2518382e318f06 100644 --- a/cc/shader.h +++ b/cc/shader.h @@ -1,3 +1,353 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef ShaderChromium_h +#define ShaderChromium_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "SkColorPriv.h" +#include + +namespace WebKit { +class WebGraphicsContext3D; +} + +namespace cc { + +class VertexShaderPosTex { +public: + VertexShaderPosTex(); + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + std::string getShaderString() const; + + int matrixLocation() const { return m_matrixLocation; } + +private: + int m_matrixLocation; +}; + +class VertexShaderPosTexYUVStretch { +public: + VertexShaderPosTexYUVStretch(); + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + std::string getShaderString() const; + + int matrixLocation() const { return m_matrixLocation; } + int yWidthScaleFactorLocation() const { return m_yWidthScaleFactorLocation; } + int uvWidthScaleFactorLocation() const { return m_uvWidthScaleFactorLocation; } + +private: + int m_matrixLocation; + int m_yWidthScaleFactorLocation; + int m_uvWidthScaleFactorLocation; +}; + +class VertexShaderPos { +public: + VertexShaderPos(); + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + std::string getShaderString() const; + + int matrixLocation() const { return m_matrixLocation; } + +private: + int m_matrixLocation; +}; + +class VertexShaderPosTexIdentity { +public: + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex) { } + std::string getShaderString() const; +}; + +class VertexShaderPosTexTransform { +public: + VertexShaderPosTexTransform(); + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + std::string getShaderString() const; + + int matrixLocation() const { return m_matrixLocation; } + int texTransformLocation() const { return m_texTransformLocation; } + +private: + int m_matrixLocation; + int m_texTransformLocation; +}; + +class VertexShaderQuad { +public: + VertexShaderQuad(); + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + std::string getShaderString() const; + + int matrixLocation() const { return m_matrixLocation; } + int pointLocation() const { return m_pointLocation; } + +private: + int m_matrixLocation; + int m_pointLocation; +}; + +class VertexShaderTile { +public: + VertexShaderTile(); + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + std::string getShaderString() const; + + int matrixLocation() const { return m_matrixLocation; } + int pointLocation() const { return m_pointLocation; } + int vertexTexTransformLocation() const { return m_vertexTexTransformLocation; } + +private: + int m_matrixLocation; + int m_pointLocation; + int m_vertexTexTransformLocation; +}; + +class VertexShaderVideoTransform { +public: + VertexShaderVideoTransform(); + + bool init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + std::string getShaderString() const; + + int matrixLocation() const { return m_matrixLocation; } + int texMatrixLocation() const { return m_texMatrixLocation; } + +private: + int m_matrixLocation; + int m_texMatrixLocation; +}; + +class FragmentTexAlphaBinding { +public: + FragmentTexAlphaBinding(); + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + int alphaLocation() const { return m_alphaLocation; } + int edgeLocation() const { return -1; } + int fragmentTexTransformLocation() const { return -1; } + int samplerLocation() const { return m_samplerLocation; } + +private: + int m_samplerLocation; + int m_alphaLocation; +}; + +class FragmentTexOpaqueBinding { +public: + FragmentTexOpaqueBinding(); + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + int alphaLocation() const { return -1; } + int edgeLocation() const { return -1; } + int fragmentTexTransformLocation() const { return -1; } + int samplerLocation() const { return m_samplerLocation; } + +private: + int m_samplerLocation; +}; + +class FragmentShaderRGBATexFlipAlpha : public FragmentTexAlphaBinding { +public: + std::string getShaderString() const; +}; + +class FragmentShaderRGBATexAlpha : public FragmentTexAlphaBinding { +public: + std::string getShaderString() const; +}; + +class FragmentShaderRGBATexRectFlipAlpha : public FragmentTexAlphaBinding { +public: + std::string getShaderString() const; +}; + +class FragmentShaderRGBATexRectAlpha : public FragmentTexAlphaBinding { +public: + std::string getShaderString() const; +}; + +class FragmentShaderRGBATexOpaque : public FragmentTexOpaqueBinding { +public: + std::string getShaderString() const; +}; + +class FragmentShaderRGBATex : public FragmentTexOpaqueBinding { +public: + std::string getShaderString() const; +}; + +// Swizzles the red and blue component of sampled texel with alpha. +class FragmentShaderRGBATexSwizzleAlpha : public FragmentTexAlphaBinding { +public: + std::string getShaderString() const; +}; + +// Swizzles the red and blue component of sampled texel without alpha. +class FragmentShaderRGBATexSwizzleOpaque : public FragmentTexOpaqueBinding { +public: + std::string getShaderString() const; +}; + +// Fragment shader for external textures. +class FragmentShaderOESImageExternal : public FragmentTexAlphaBinding { +public: + std::string getShaderString() const; + bool init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); +private: + int m_samplerLocation; +}; + +class FragmentShaderRGBATexAlphaAA { +public: + FragmentShaderRGBATexAlphaAA(); + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + std::string getShaderString() const; + + int alphaLocation() const { return m_alphaLocation; } + int samplerLocation() const { return m_samplerLocation; } + int edgeLocation() const { return m_edgeLocation; } + +private: + int m_samplerLocation; + int m_alphaLocation; + int m_edgeLocation; +}; + +class FragmentTexClampAlphaAABinding { +public: + FragmentTexClampAlphaAABinding(); + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + int alphaLocation() const { return m_alphaLocation; } + int samplerLocation() const { return m_samplerLocation; } + int fragmentTexTransformLocation() const { return m_fragmentTexTransformLocation; } + int edgeLocation() const { return m_edgeLocation; } + +private: + int m_samplerLocation; + int m_alphaLocation; + int m_fragmentTexTransformLocation; + int m_edgeLocation; +}; + +class FragmentShaderRGBATexClampAlphaAA : public FragmentTexClampAlphaAABinding { +public: + std::string getShaderString() const; +}; + +// Swizzles the red and blue component of sampled texel. +class FragmentShaderRGBATexClampSwizzleAlphaAA : public FragmentTexClampAlphaAABinding { +public: + std::string getShaderString() const; +}; + +class FragmentShaderRGBATexAlphaMask { +public: + FragmentShaderRGBATexAlphaMask(); + std::string getShaderString() const; + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + int alphaLocation() const { return m_alphaLocation; } + int samplerLocation() const { return m_samplerLocation; } + int maskSamplerLocation() const { return m_maskSamplerLocation; } + int maskTexCoordScaleLocation() const { return m_maskTexCoordScaleLocation; } + int maskTexCoordOffsetLocation() const { return m_maskTexCoordOffsetLocation; } + +private: + int m_samplerLocation; + int m_maskSamplerLocation; + int m_alphaLocation; + int m_maskTexCoordScaleLocation; + int m_maskTexCoordOffsetLocation; +}; + +class FragmentShaderRGBATexAlphaMaskAA { +public: + FragmentShaderRGBATexAlphaMaskAA(); + std::string getShaderString() const; + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + int alphaLocation() const { return m_alphaLocation; } + int samplerLocation() const { return m_samplerLocation; } + int maskSamplerLocation() const { return m_maskSamplerLocation; } + int edgeLocation() const { return m_edgeLocation; } + int maskTexCoordScaleLocation() const { return m_maskTexCoordScaleLocation; } + int maskTexCoordOffsetLocation() const { return m_maskTexCoordOffsetLocation; } + +private: + int m_samplerLocation; + int m_maskSamplerLocation; + int m_alphaLocation; + int m_edgeLocation; + int m_maskTexCoordScaleLocation; + int m_maskTexCoordOffsetLocation; +}; + +class FragmentShaderYUVVideo { +public: + FragmentShaderYUVVideo(); + std::string getShaderString() const; + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + + int yTextureLocation() const { return m_yTextureLocation; } + int uTextureLocation() const { return m_uTextureLocation; } + int vTextureLocation() const { return m_vTextureLocation; } + int alphaLocation() const { return m_alphaLocation; } + int ccMatrixLocation() const { return m_ccMatrixLocation; } + int yuvAdjLocation() const { return m_yuvAdjLocation; } + +private: + int m_yTextureLocation; + int m_uTextureLocation; + int m_vTextureLocation; + int m_alphaLocation; + int m_ccMatrixLocation; + int m_yuvAdjLocation; +}; + +class FragmentShaderColor { +public: + FragmentShaderColor(); + std::string getShaderString() const; + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + int colorLocation() const { return m_colorLocation; } + +private: + int m_colorLocation; +}; + +class FragmentShaderCheckerboard { +public: + FragmentShaderCheckerboard(); + std::string getShaderString() const; + + void init(WebKit::WebGraphicsContext3D*, unsigned program, bool usingBindUniform, int* baseUniformIndex); + int alphaLocation() const { return m_alphaLocation; } + int texTransformLocation() const { return m_texTransformLocation; } + int frequencyLocation() const { return m_frequencyLocation; } + int colorLocation() const { return m_colorLocation; } +private: + int m_alphaLocation; + int m_texTransformLocation; + int m_frequencyLocation; + int m_colorLocation; +}; + +} // namespace cc + +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCSharedQuadState.cpp b/cc/shared_quad_state.cc similarity index 100% rename from cc/CCSharedQuadState.cpp rename to cc/shared_quad_state.cc diff --git a/cc/shared_quad_state.h b/cc/shared_quad_state.h index 638cbb270ce9b2..0f5e386410d599 100644 --- a/cc/shared_quad_state.h +++ b/cc/shared_quad_state.h @@ -1,3 +1,33 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCSharedQuadState_h +#define CCSharedQuadState_h + +#include "IntRect.h" +#include "base/memory/scoped_ptr.h" +#include + +namespace cc { + +struct CCSharedQuadState { + int id; + + // Transforms from quad's original content space to its target content space. + WebKit::WebTransformationMatrix quadTransform; + // This rect lives in the content space for the quad's originating layer. + IntRect visibleContentRect; + IntRect clippedRectInTarget; + float opacity; + bool opaque; + + static scoped_ptr create(const WebKit::WebTransformationMatrix& quadTransform, const IntRect& visibleContentRect, const IntRect& clippedRectInTarget, float opacity, bool opaque); + CCSharedQuadState(const WebKit::WebTransformationMatrix& quadTransform, const IntRect& visibleContentRect, const IntRect& clippedRectInTarget, float opacity, bool opaque); + + scoped_ptr copy() const; +}; + +} + +#endif diff --git a/cc/CCSingleThreadProxy.cpp b/cc/single_thread_proxy.cc similarity index 100% rename from cc/CCSingleThreadProxy.cpp rename to cc/single_thread_proxy.cc diff --git a/cc/single_thread_proxy.h b/cc/single_thread_proxy.h index 638cbb270ce9b2..979dbb3907f529 100644 --- a/cc/single_thread_proxy.h +++ b/cc/single_thread_proxy.h @@ -1,3 +1,134 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCSingleThreadProxy_h +#define CCSingleThreadProxy_h + +#include "CCAnimationEvents.h" +#include "CCLayerTreeHostImpl.h" +#include "CCProxy.h" +#include +#include + +namespace cc { + +class CCLayerTreeHost; + +class CCSingleThreadProxy : public CCProxy, CCLayerTreeHostImplClient { +public: + static scoped_ptr create(CCLayerTreeHost*); + virtual ~CCSingleThreadProxy(); + + // CCProxy implementation + virtual bool compositeAndReadback(void *pixels, const IntRect&) OVERRIDE; + virtual void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double duration) OVERRIDE; + virtual void finishAllRendering() OVERRIDE; + virtual bool isStarted() const OVERRIDE; + virtual bool initializeContext() OVERRIDE; + virtual void setSurfaceReady() OVERRIDE; + virtual void setVisible(bool) OVERRIDE; + virtual bool initializeRenderer() OVERRIDE; + virtual bool recreateContext() OVERRIDE; + virtual void renderingStats(CCRenderingStats*) OVERRIDE; + virtual const RendererCapabilities& rendererCapabilities() const OVERRIDE; + virtual void loseContext() OVERRIDE; + virtual void setNeedsAnimate() OVERRIDE; + virtual void setNeedsCommit() OVERRIDE; + virtual void setNeedsRedraw() OVERRIDE; + virtual bool commitRequested() const OVERRIDE; + virtual void didAddAnimation() OVERRIDE; + virtual void start() OVERRIDE; + virtual void stop() OVERRIDE; + virtual size_t maxPartialTextureUpdates() const OVERRIDE; + virtual void acquireLayerTextures() OVERRIDE { } + virtual void forceSerializeOnSwapBuffers() OVERRIDE; + + // CCLayerTreeHostImplClient implementation + virtual void didLoseContextOnImplThread() OVERRIDE { } + virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE; + virtual void onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds) OVERRIDE { } + virtual void onCanDrawStateChanged(bool canDraw) OVERRIDE { } + virtual void setNeedsRedrawOnImplThread() OVERRIDE; + virtual void setNeedsCommitOnImplThread() OVERRIDE; + virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr, double wallClockTime) OVERRIDE; + virtual void releaseContentsTexturesOnImplThread() OVERRIDE; + + // Called by the legacy path where RenderWidget does the scheduling. + void compositeImmediately(); + +private: + explicit CCSingleThreadProxy(CCLayerTreeHost*); + + bool commitAndComposite(); + void doCommit(PassOwnPtr); + bool doComposite(); + void didSwapFrame(); + + // Accessed on main thread only. + CCLayerTreeHost* m_layerTreeHost; + bool m_contextLost; + + // Holds on to the context between initializeContext() and initializeRenderer() calls. Shouldn't + // be used for anything else. + scoped_ptr m_contextBeforeInitialization; + + // Used on the CCThread, but checked on main thread during initialization/shutdown. + scoped_ptr m_layerTreeHostImpl; + bool m_rendererInitialized; + RendererCapabilities m_RendererCapabilitiesForMainThread; + + bool m_nextFrameIsNewlyCommittedFrame; + + base::TimeDelta m_totalCommitTime; + size_t m_totalCommitCount; +}; + +// For use in the single-threaded case. In debug builds, it pretends that the +// code is running on the impl thread to satisfy assertion checks. +class DebugScopedSetImplThread { +public: + DebugScopedSetImplThread() + { +#if !ASSERT_DISABLED + CCProxy::setCurrentThreadIsImplThread(true); +#endif + } + ~DebugScopedSetImplThread() + { +#if !ASSERT_DISABLED + CCProxy::setCurrentThreadIsImplThread(false); +#endif + } +}; + +// For use in the single-threaded case. In debug builds, it pretends that the +// code is running on the main thread to satisfy assertion checks. +class DebugScopedSetMainThread { +public: + DebugScopedSetMainThread() + { +#if !ASSERT_DISABLED + CCProxy::setCurrentThreadIsImplThread(false); +#endif + } + ~DebugScopedSetMainThread() + { +#if !ASSERT_DISABLED + CCProxy::setCurrentThreadIsImplThread(true); +#endif + } +}; + +// For use in the single-threaded case. In debug builds, it pretends that the +// code is running on the impl thread and that the main thread is blocked to +// satisfy assertion checks +class DebugScopedSetImplThreadAndMainThreadBlocked { +private: + DebugScopedSetImplThread m_implThread; + DebugScopedSetMainThreadBlocked m_mainThreadBlocked; +}; + +} // namespace cc + +#endif diff --git a/cc/SkPictureCanvasLayerTextureUpdater.cpp b/cc/skpicture_canvas_layer_texture_updater.cc similarity index 100% rename from cc/SkPictureCanvasLayerTextureUpdater.cpp rename to cc/skpicture_canvas_layer_texture_updater.cc diff --git a/cc/skpicture_canvas_layer_texture_updater.h b/cc/skpicture_canvas_layer_texture_updater.h index 638cbb270ce9b2..fd9bb5fccd1703 100644 --- a/cc/skpicture_canvas_layer_texture_updater.h +++ b/cc/skpicture_canvas_layer_texture_updater.h @@ -1,3 +1,48 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef SkPictureCanvasLayerTextureUpdater_h +#define SkPictureCanvasLayerTextureUpdater_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "CanvasLayerTextureUpdater.h" +#include "SkPicture.h" + +class SkCanvas; + +namespace cc { + +class LayerPainterChromium; + +// This class records the contentRect into an SkPicture. Subclasses, provide +// different implementations of tile updating based on this recorded picture. +// The BitmapSkPictureCanvasLayerTextureUpdater and +// FrameBufferSkPictureCanvasLayerTextureUpdater are two examples of such +// implementations. +class SkPictureCanvasLayerTextureUpdater : public CanvasLayerTextureUpdater { +public: + virtual ~SkPictureCanvasLayerTextureUpdater(); + + virtual void setOpaque(bool) OVERRIDE; + +protected: + explicit SkPictureCanvasLayerTextureUpdater(PassOwnPtr); + + virtual void prepareToUpdate(const IntRect& contentRect, const IntSize& tileSize, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, CCRenderingStats&) OVERRIDE; + void drawPicture(SkCanvas*); + + bool layerIsOpaque() const { return m_layerIsOpaque; } + +private: + // Recording canvas. + SkPicture m_picture; + // True when it is known that all output pixels will be opaque. + bool m_layerIsOpaque; +}; + +} // namespace cc +#endif // USE(ACCELERATED_COMPOSITING) +#endif // SkPictureCanvasLayerTextureUpdater_h diff --git a/cc/CCRendererSoftware.cpp b/cc/software_renderer.cc similarity index 100% rename from cc/CCRendererSoftware.cpp rename to cc/software_renderer.cc diff --git a/cc/software_renderer.h b/cc/software_renderer.h index 638cbb270ce9b2..2ad688fc0a1f6a 100644 --- a/cc/software_renderer.h +++ b/cc/software_renderer.h @@ -1,3 +1,76 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCRendererSoftware_h +#define CCRendererSoftware_h + +#include "base/basictypes.h" +#include "CCDirectRenderer.h" +#include "CCLayerTreeHost.h" +#include + +namespace cc { + +class CCDebugBorderDrawQuad; +class CCRendererClient; +class CCResourceProvider; +class CCSolidColorDrawQuad; +class CCTextureDrawQuad; +class CCTileDrawQuad; + +class CCRendererSoftware : public CCDirectRenderer { +public: + static PassOwnPtr create(CCRendererClient*, CCResourceProvider*, WebKit::WebCompositorSoftwareOutputDevice*); + virtual ~CCRendererSoftware(); + + virtual const RendererCapabilities& capabilities() const OVERRIDE; + + virtual void viewportChanged() OVERRIDE; + + virtual void finish() OVERRIDE; + + virtual bool swapBuffers() OVERRIDE; + + virtual void getFramebufferPixels(void *pixels, const IntRect&) OVERRIDE; + + virtual void setVisible(bool) OVERRIDE; + +protected: + virtual void bindFramebufferToOutputSurface(DrawingFrame&) OVERRIDE; + virtual bool bindFramebufferToTexture(DrawingFrame&, const CCScopedTexture*, const IntRect& framebufferRect) OVERRIDE; + virtual void setDrawViewportSize(const IntSize&) OVERRIDE; + virtual void enableScissorTestRect(const IntRect& scissorRect) OVERRIDE; + virtual void disableScissorTest() OVERRIDE; + virtual void clearFramebuffer(DrawingFrame&) OVERRIDE; + virtual void drawQuad(DrawingFrame&, const CCDrawQuad*) OVERRIDE; + virtual void beginDrawingFrame(DrawingFrame&) OVERRIDE; + virtual void finishDrawingFrame(DrawingFrame&) OVERRIDE; + virtual bool flippedFramebuffer() const OVERRIDE; + +private: + CCRendererSoftware(CCRendererClient*, CCResourceProvider*, WebKit::WebCompositorSoftwareOutputDevice*); + + bool isSoftwareResource(CCResourceProvider::ResourceId) const; + + void drawDebugBorderQuad(const DrawingFrame&, const CCDebugBorderDrawQuad*); + void drawSolidColorQuad(const DrawingFrame&, const CCSolidColorDrawQuad*); + void drawTextureQuad(const DrawingFrame&, const CCTextureDrawQuad*); + void drawTileQuad(const DrawingFrame&, const CCTileDrawQuad*); + void drawUnsupportedQuad(const DrawingFrame&, const CCDrawQuad*); + + RendererCapabilities m_capabilities; + bool m_visible; + + WebKit::WebCompositorSoftwareOutputDevice* m_outputDevice; + OwnPtr m_skRootCanvas; + SkCanvas* m_skCurrentCanvas; + SkPaint m_skCurrentPaint; + OwnPtr m_currentFramebufferLock; + + DISALLOW_COPY_AND_ASSIGN(CCRendererSoftware); +}; + +} + +#endif diff --git a/cc/CCSolidColorDrawQuad.cpp b/cc/solid_color_draw_quad.cc similarity index 100% rename from cc/CCSolidColorDrawQuad.cpp rename to cc/solid_color_draw_quad.cc diff --git a/cc/solid_color_draw_quad.h b/cc/solid_color_draw_quad.h index 638cbb270ce9b2..6825612e491472 100644 --- a/cc/solid_color_draw_quad.h +++ b/cc/solid_color_draw_quad.h @@ -1,3 +1,33 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCSolidColorDrawQuad_h +#define CCSolidColorDrawQuad_h + +#include "CCDrawQuad.h" +#include "SkColor.h" +#include "base/memory/scoped_ptr.h" + +namespace cc { + +#pragma pack(push, 4) + +class CCSolidColorDrawQuad : public CCDrawQuad { +public: + static scoped_ptr create(const CCSharedQuadState*, const IntRect&, SkColor); + + SkColor color() const { return m_color; }; + + static const CCSolidColorDrawQuad* materialCast(const CCDrawQuad*); +private: + CCSolidColorDrawQuad(const CCSharedQuadState*, const IntRect&, SkColor); + + SkColor m_color; +}; + +#pragma pack(pop) + +} + +#endif diff --git a/cc/SolidColorLayerChromium.cpp b/cc/solid_color_layer.cc similarity index 100% rename from cc/SolidColorLayerChromium.cpp rename to cc/solid_color_layer.cc diff --git a/cc/solid_color_layer.h b/cc/solid_color_layer.h index 638cbb270ce9b2..912348410ae50f 100644 --- a/cc/solid_color_layer.h +++ b/cc/solid_color_layer.h @@ -1,3 +1,33 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef SolidColorLayerChromium_h +#define SolidColorLayerChromium_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "LayerChromium.h" + +namespace cc { + +// A Layer that renders a solid color. The color is specified by using +// setBackgroundColor() on the base class. +class SolidColorLayerChromium : public LayerChromium { +public: + static scoped_refptr create(); + + virtual scoped_ptr createCCLayerImpl() OVERRIDE; + +protected: + SolidColorLayerChromium(); + +private: + virtual ~SolidColorLayerChromium(); +}; + +} +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCSolidColorLayerImpl.cpp b/cc/solid_color_layer_impl.cc similarity index 100% rename from cc/CCSolidColorLayerImpl.cpp rename to cc/solid_color_layer_impl.cc diff --git a/cc/solid_color_layer_impl.h b/cc/solid_color_layer_impl.h index 638cbb270ce9b2..72beb25505a6fd 100644 --- a/cc/solid_color_layer_impl.h +++ b/cc/solid_color_layer_impl.h @@ -1,3 +1,34 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCSolidColorLayerImpl_h +#define CCSolidColorLayerImpl_h + +#include "CCLayerImpl.h" +#include + +namespace cc { + +class CCSolidColorLayerImpl : public CCLayerImpl { +public: + static scoped_ptr create(int id) + { + return make_scoped_ptr(new CCSolidColorLayerImpl(id)); + } + virtual ~CCSolidColorLayerImpl(); + + virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; + +protected: + explicit CCSolidColorLayerImpl(int id); + +private: + virtual const char* layerTypeAsString() const OVERRIDE; + + const int m_tileSize; +}; + +} + +#endif // CCSolidColorLayerImpl_h diff --git a/cc/CCStreamVideoDrawQuad.cpp b/cc/stream_video_draw_quad.cc similarity index 100% rename from cc/CCStreamVideoDrawQuad.cpp rename to cc/stream_video_draw_quad.cc diff --git a/cc/stream_video_draw_quad.h b/cc/stream_video_draw_quad.h index 638cbb270ce9b2..6a1b6c407dcec8 100644 --- a/cc/stream_video_draw_quad.h +++ b/cc/stream_video_draw_quad.h @@ -1,3 +1,35 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCStreamVideoDrawQuad_h +#define CCStreamVideoDrawQuad_h + +#include "CCDrawQuad.h" +#include "base/memory/scoped_ptr.h" +#include + +namespace cc { + +#pragma pack(push, 4) + +class CCStreamVideoDrawQuad : public CCDrawQuad { +public: + static scoped_ptr create(const CCSharedQuadState*, const IntRect&, unsigned textureId, const WebKit::WebTransformationMatrix&); + + unsigned textureId() const { return m_textureId; } + const WebKit::WebTransformationMatrix& matrix() const { return m_matrix; } + + static const CCStreamVideoDrawQuad* materialCast(const CCDrawQuad*); +private: + CCStreamVideoDrawQuad(const CCSharedQuadState*, const IntRect&, unsigned textureId, const WebKit::WebTransformationMatrix&); + + unsigned m_textureId; + WebKit::WebTransformationMatrix m_matrix; +}; + +#pragma pack(pop) + +} + +#endif diff --git a/cc/stubs/Extensions3D.h b/cc/stubs/Extensions3D.h index bbeb9e6e9f2662..77f010e4724585 100644 --- a/cc/stubs/Extensions3D.h +++ b/cc/stubs/Extensions3D.h @@ -1,25 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_EXTENSIONS3D_H_ -#define CC_STUBS_EXTENSIONS3D_H_ - -#include "third_party/khronos/GLES2/gl2.h" -#include "third_party/khronos/GLES2/gl2ext.h" - -namespace cc { - -class Extensions3D { -public: - enum { - TEXTURE_RECTANGLE_ARB = GL_TEXTURE_RECTANGLE_ARB, - BGRA_EXT = GL_BGRA_EXT, - RGBA8_OES = GL_RGBA8_OES, - }; -}; - -} - - -#endif // CC_STUBS_EXTENSIONS3D_H_ +// Temporary forwarding header +#include "cc/stubs/extensions_3d.h" diff --git a/cc/stubs/Extensions3DChromium.h b/cc/stubs/Extensions3DChromium.h index f5d36d2300a7e4..f3c6fa9831d305 100644 --- a/cc/stubs/Extensions3DChromium.h +++ b/cc/stubs/Extensions3DChromium.h @@ -1,54 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_EXTENSIONS3DCHROMIUM_H_ -#define CC_STUBS_EXTENSIONS3DCHROMIUM_H_ - -#include "Extensions3D.h" - -// These enum names collides with gl2ext.h, so we just redefine them. -#ifdef GL_TEXTURE_EXTERNAL_OES -#undef GL_TEXTURE_EXTERNAL_OES -#endif -#ifdef GL_TEXTURE_USAGE_ANGLE -#undef GL_TEXTURE_USAGE_ANGLE -#endif -#ifdef GL_FRAMEBUFFER_ATTACHMENT_ANGLE -#undef GL_FRAMEBUFFER_ATTACHMENT_ANGLE -#endif - -namespace cc { - -class Extensions3DChromium { -public: - enum { - // GL_OES_EGL_image_external - GL_TEXTURE_EXTERNAL_OES = 0x8D65, - - // GL_CHROMIUM_map_sub (enums inherited from GL_ARB_vertex_buffer_object) - READ_ONLY = 0x88B8, - WRITE_ONLY = 0x88B9, - - // GL_ANGLE_texture_usage - GL_TEXTURE_USAGE_ANGLE = 0x93A2, - GL_FRAMEBUFFER_ATTACHMENT_ANGLE = 0x93A3, - - // GL_EXT_texture_storage - BGRA8_EXT = 0x93A1, - - // GL_EXT_occlusion_query_boolean - ANY_SAMPLES_PASSED_EXT = 0x8C2F, - ANY_SAMPLES_PASSED_CONSERVATIVE_EXT = 0x8D6A, - CURRENT_QUERY_EXT = 0x8865, - QUERY_RESULT_EXT = 0x8866, - QUERY_RESULT_AVAILABLE_EXT = 0x8867, - - // GL_CHROMIUM_command_buffer_query - COMMANDS_ISSUED_CHROMIUM = 0x84F2 - }; -}; - -} - -#endif // CC_STUBS_EXTENSIONS3DCHROMIUM_H_ +// Temporary forwarding header +#include "cc/stubs/extensions_3d_chromium.h" diff --git a/cc/stubs/FloatPoint.h b/cc/stubs/FloatPoint.h index 4ce268188aa7ee..df1fe9f65fbb4c 100644 --- a/cc/stubs/FloatPoint.h +++ b/cc/stubs/FloatPoint.h @@ -1,51 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_FLOATPOINT_H_ -#define CC_STUBS_FLOATPOINT_H_ - -#include "FloatSize.h" -#include "IntPoint.h" -#if INSIDE_WEBKIT_BUILD -#include "Source/WebCore/platform/graphics/FloatPoint.h" -#else -#include "third_party/WebKit/Source/WebCore/platform/graphics/FloatPoint.h" -#endif - -namespace cc { - -class FloatPoint : public WebCore::FloatPoint { -public: - FloatPoint() { } - - FloatPoint(float width, float height) - : WebCore::FloatPoint(width, height) - { - } - - FloatPoint(FloatSize size) - : WebCore::FloatPoint(size) - { - } - - FloatPoint(IntPoint point) - : WebCore::FloatPoint(point) - { - } - - FloatPoint(WebCore::IntPoint point) - : WebCore::FloatPoint(point) - { - } - - FloatPoint(WebCore::FloatPoint point) - : WebCore::FloatPoint(point.x(), point.y()) - { - - } -}; - -} - -#endif +// Temporary forwarding header +#include "cc/stubs/float_point.h" diff --git a/cc/stubs/FloatPoint3D.h b/cc/stubs/FloatPoint3D.h index 02ff076d7ff347..3d5f90c3ea4a32 100644 --- a/cc/stubs/FloatPoint3D.h +++ b/cc/stubs/FloatPoint3D.h @@ -1,50 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_FLOATPOINT3D_H_ -#define CC_STUBS_FLOATPOINT3D_H_ - -#include "FloatPoint.h" - -#if INSIDE_WEBKIT_BUILD -#include "Source/WebCore/platform/graphics/FloatPoint3D.h" -#else -#include "third_party/WebKit/Source/WebCore/platform/graphics/FloatPoint3D.h" -#endif - -namespace cc { - -class FloatPoint3D : public WebCore::FloatPoint3D { -public: - FloatPoint3D() { } - - FloatPoint3D(float x, float y, float z) - : WebCore::FloatPoint3D(x, y, z) - { - } - - FloatPoint3D(FloatPoint point) - : WebCore::FloatPoint3D(point.x(), point.y(), 0) - { - } - - FloatPoint3D(const FloatPoint3D& point) - : WebCore::FloatPoint3D(point) - { - } - - FloatPoint3D(WebCore::FloatPoint3D point) - : WebCore::FloatPoint3D(point) - { - } - - FloatPoint3D(WebCore::FloatPoint point) - : WebCore::FloatPoint3D(point) - { - } -}; - -} - -#endif +// Temporary forwarding header +#include "cc/stubs/float_point_3d.h" diff --git a/cc/stubs/FloatQuad.h b/cc/stubs/FloatQuad.h index f2f45ed568371a..4495a84c9efd6e 100644 --- a/cc/stubs/FloatQuad.h +++ b/cc/stubs/FloatQuad.h @@ -1,56 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_FLOATQUAD_H_ -#define CC_STUBS_FLOATQUAD_H_ - -#include "FloatPoint.h" -#include "FloatRect.h" -#if INSIDE_WEBKIT_BUILD -#include "Source/WebCore/platform/graphics/FloatQuad.h" -#else -#include "third_party/WebKit/Source/WebCore/platform/graphics/FloatQuad.h" -#endif - -namespace cc { - -class FloatQuad : public WebCore::FloatQuad -{ -public: - FloatQuad() { } - - FloatQuad(const FloatPoint& p1, const FloatPoint& p2, const FloatPoint& p3, const FloatPoint& p4) - : WebCore::FloatQuad(p1, p2, p3, p4) - { - } - - FloatQuad(const FloatRect& rect) - : WebCore::FloatQuad(rect) - { - } - - FloatQuad(const IntRect& rect) - : WebCore::FloatQuad(rect) - { - } - - FloatQuad(const WebCore::FloatRect& rect) - : WebCore::FloatQuad(rect) - { - } - - FloatQuad(const WebCore::IntRect& rect) - : WebCore::FloatQuad(rect) - { - } - - FloatQuad(const WebCore::FloatQuad& quad) - : WebCore::FloatQuad(quad) - { - } -}; - -} - -#endif +// Temporary forwarding header +#include "cc/stubs/float_quad.h" diff --git a/cc/stubs/FloatRect.h b/cc/stubs/FloatRect.h index 2eb03e2749e738..1957e86db35929 100644 --- a/cc/stubs/FloatRect.h +++ b/cc/stubs/FloatRect.h @@ -1,56 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_FLOATRECT_H_ -#define CC_STUBS_FLOATRECT_H_ - -#include "FloatPoint.h" -#include "FloatSize.h" -#include "IntRect.h" -#if INSIDE_WEBKIT_BUILD -#include "Source/WebCore/platform/graphics/FloatRect.h" -#else -#include "third_party/WebKit/Source/WebCore/platform/graphics/FloatRect.h" -#endif - -namespace cc { - -class FloatRect : public WebCore::FloatRect { -public: - FloatRect() { } - - FloatRect(const FloatPoint& location, const FloatSize& size) - : WebCore::FloatRect(location, size) - { - } - - FloatRect(const IntPoint& location, const IntSize& size) - : WebCore::FloatRect(location, size) - { - } - - FloatRect(float x, float y, float width, float height) - : WebCore::FloatRect(x, y, width, height) - { - } - - FloatRect(const IntRect& rect) - : WebCore::FloatRect(rect) - { - } - - FloatRect(const WebCore::IntRect& rect) - : WebCore::FloatRect(rect) - { - } - - FloatRect(const WebCore::FloatRect& rect) - :WebCore::FloatRect(rect) - { - } -}; - -} - -#endif +// Temporary forwarding header +#include "cc/stubs/float_rect.h" diff --git a/cc/stubs/FloatSize.h b/cc/stubs/FloatSize.h index 9db59788f7d52b..f5d5c4ea5ab664 100644 --- a/cc/stubs/FloatSize.h +++ b/cc/stubs/FloatSize.h @@ -1,43 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_FLOATSIZE_H_ -#define CC_STUBS_FLOATSIZE_H_ - -#include "IntSize.h" -#if INSIDE_WEBKIT_BUILD -#include "Source/WebCore/platform/graphics/FloatSize.h" -#else -#include "third_party/WebKit/Source/WebCore/platform/graphics/FloatSize.h" -#endif - -namespace cc { -class FloatSize : public WebCore::FloatSize { -public: - FloatSize() { } - - FloatSize(float width, float height) - : WebCore::FloatSize(width, height) - { - } - - FloatSize(IntSize size) - : WebCore::FloatSize(size.width(), size.height()) - { - } - - FloatSize(WebCore::FloatSize size) - : WebCore::FloatSize(size.width(), size.height()) - { - } - - FloatSize(WebCore::IntSize size) - : WebCore::FloatSize(size.width(), size.height()) - { - } -}; - -} - -#endif +// Temporary forwarding header +#include "cc/stubs/float_size.h" diff --git a/cc/stubs/GraphicsContext3D.h b/cc/stubs/GraphicsContext3D.h index e7f7a606dadaa1..3460a308b29b33 100644 --- a/cc/stubs/GraphicsContext3D.h +++ b/cc/stubs/GraphicsContext3D.h @@ -1,74 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_GRAPHICSCONTEXT3D_H_ -#define CC_STUBS_GRAPHICSCONTEXT3D_H_ - -#include "GraphicsTypes3D.h" -#include "IntSize.h" -#include "third_party/khronos/GLES2/gl2.h" - -#ifdef NO_ERROR -#undef NO_ERROR -#endif - -namespace cc { - -class GraphicsContext3D { -public: - enum SourceDataFormat { SourceFormatRGBA8, SourceFormatBGRA8 }; - static bool computeFormatAndTypeParameters(unsigned, unsigned, unsigned* componentsPerPixel, unsigned* bytesPerComponent); - - enum { - ARRAY_BUFFER = GL_ARRAY_BUFFER, - BLEND = GL_BLEND, - CLAMP_TO_EDGE = GL_CLAMP_TO_EDGE, - COLOR_ATTACHMENT0 = GL_COLOR_ATTACHMENT0, - COLOR_BUFFER_BIT = GL_COLOR_BUFFER_BIT, - COMPILE_STATUS = GL_COMPILE_STATUS, - CULL_FACE = GL_CULL_FACE, - DEPTH_TEST = GL_DEPTH_TEST, - ELEMENT_ARRAY_BUFFER = GL_ELEMENT_ARRAY_BUFFER, - EXTENSIONS = GL_EXTENSIONS, - FLOAT = GL_FLOAT, - FRAGMENT_SHADER = GL_FRAGMENT_SHADER, - FRAMEBUFFER_COMPLETE = GL_FRAMEBUFFER_COMPLETE, - FRAMEBUFFER = GL_FRAMEBUFFER, - INVALID_ENUM = GL_INVALID_ENUM, - INVALID_VALUE = GL_INVALID_VALUE, - LINEAR = GL_LINEAR, - LINE_LOOP = GL_LINE_LOOP , - LINK_STATUS = GL_LINK_STATUS, - LUMINANCE = GL_LUMINANCE, - MAX_TEXTURE_SIZE = GL_MAX_TEXTURE_SIZE, - NEAREST = GL_NEAREST, - NO_ERROR = GL_NO_ERROR, - ONE = GL_ONE, - ONE_MINUS_SRC_ALPHA = GL_ONE_MINUS_SRC_ALPHA, - RGBA = GL_RGBA, - RGB = GL_RGB, - SCISSOR_TEST = GL_SCISSOR_TEST, - SRC_ALPHA = GL_SRC_ALPHA, - STATIC_DRAW = GL_STATIC_DRAW, - TEXTURE0 = GL_TEXTURE0, - TEXTURE1 = GL_TEXTURE1, - TEXTURE_2D = GL_TEXTURE_2D, - TEXTURE2 = GL_TEXTURE2, - TEXTURE3 = GL_TEXTURE3, - TEXTURE_MAG_FILTER = GL_TEXTURE_MAG_FILTER, - TEXTURE_MIN_FILTER = GL_TEXTURE_MIN_FILTER, - TEXTURE_WRAP_S = GL_TEXTURE_WRAP_S, - TEXTURE_WRAP_T = GL_TEXTURE_WRAP_T, - TRIANGLES = GL_TRIANGLES, - TRIANGLE_FAN = GL_TRIANGLE_FAN, - UNSIGNED_BYTE = GL_UNSIGNED_BYTE, - UNSIGNED_SHORT = GL_UNSIGNED_SHORT, - VERTEX_SHADER = GL_VERTEX_SHADER, - ZERO = GL_ZERO, - }; -}; - -} - -#endif // CC_STUBS_GRAPHICSCONTEXT3D_H_ +// Temporary forwarding header +#include "cc/stubs/graphics_context_3d.h" diff --git a/cc/stubs/GraphicsTypes3D.h b/cc/stubs/GraphicsTypes3D.h index a01414e5179cfb..8d08bb3963f2e5 100644 --- a/cc/stubs/GraphicsTypes3D.h +++ b/cc/stubs/GraphicsTypes3D.h @@ -1,18 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_GRAPHICSTYPES3D_H_ -#define CC_STUBS_GRAPHICSTYPES3D_H_ - -#define NullPlatform3DObject 0 - -typedef unsigned char GC3Dboolean; -typedef unsigned GC3Denum; -typedef unsigned GC3Duint; -typedef unsigned Platform3DObject; -typedef int GC3Dint; -typedef signed char GC3Dbyte; - -#endif // CC_STUBS_GRAPHICSTYPES3D_H_ - +// Temporary forwarding header +#include "cc/stubs/graphics_types_3d.h" diff --git a/cc/stubs/IntPoint.h b/cc/stubs/IntPoint.h index fa12deadd4c943..d996ea85829add 100644 --- a/cc/stubs/IntPoint.h +++ b/cc/stubs/IntPoint.h @@ -1,40 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_INTPOINT_H_ -#define CC_STUBS_INTPOINT_H_ - -#include "IntSize.h" -#if INSIDE_WEBKIT_BUILD -#include "Source/WebCore/platform/graphics/IntPoint.h" -#else -#include "third_party/WebKit/Source/WebCore/platform/graphics/IntPoint.h" -#endif - -namespace cc { - -class IntPoint : public WebCore::IntPoint { -public: - IntPoint() { } - - IntPoint(int width, int height) - : WebCore::IntPoint(width, height) - { - } - - IntPoint(IntSize size) - : WebCore::IntPoint(size.width(), size.height()) - { - } - - IntPoint(WebCore::IntPoint point) - : WebCore::IntPoint(point.x(), point.y()) - { - - } -}; - -} - -#endif +// Temporary forwarding header +#include "cc/stubs/int_point.h" diff --git a/cc/stubs/IntRect.h b/cc/stubs/IntRect.h index 1599967a881172..1d136edb4f1500 100644 --- a/cc/stubs/IntRect.h +++ b/cc/stubs/IntRect.h @@ -1,41 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_INTRECT_H_ -#define CC_STUBS_INTRECT_H_ - -#include "IntPoint.h" -#include "IntSize.h" -#if INSIDE_WEBKIT_BUILD -#include "Source/WebCore/platform/graphics/IntRect.h" -#else -#include "third_party/WebKit/Source/WebCore/platform/graphics/IntRect.h" -#endif - -namespace cc { - -class IntRect : public WebCore::IntRect { -public: - IntRect() { } - - IntRect(const IntPoint& location, const IntSize& size) - : WebCore::IntRect(location, size) - { - } - - IntRect(int x, int y, int width, int height) - : WebCore::IntRect(x, y, width, height) - { - } - - IntRect(WebCore::IntRect rect) - : WebCore::IntRect(rect.x(), rect.y(), rect.width(), rect.height()) - { - - } -}; - -} - -#endif +// Temporary forwarding header +#include "cc/stubs/int_rect.h" diff --git a/cc/stubs/IntSize.h b/cc/stubs/IntSize.h index c53f4f155dd666..4508c696648d00 100644 --- a/cc/stubs/IntSize.h +++ b/cc/stubs/IntSize.h @@ -1,34 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_INTSIZE_H_ -#define CC_STUBS_INTSIZE_H_ - -#if INSIDE_WEBKIT_BUILD -#include "Source/WebCore/platform/graphics/IntSize.h" -#else -#include "third_party/WebKit/Source/WebCore/platform/graphics/IntSize.h" -#endif - -namespace cc { - -class IntSize : public WebCore::IntSize { -public: - IntSize() { } - - IntSize(int width, int height) - : WebCore::IntSize(width, height) - { - } - - IntSize(WebCore::IntSize size) - : WebCore::IntSize(size.width(), size.height()) - { - - } -}; - -} - -#endif +// Temporary forwarding header +#include "cc/stubs/int_size.h" diff --git a/cc/stubs/NotImplemented.h b/cc/stubs/NotImplemented.h index 7c6bba571509a9..4ac19a5ad473bd 100644 --- a/cc/stubs/NotImplemented.h +++ b/cc/stubs/NotImplemented.h @@ -1,10 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_NOTIMPLEMENTED_H -#define CC_STUBS_NOTIMPLEMENTED_H - -#define notImplemented() do { } while(0) - -#endif // CC_STUBS_NOTIMPLEMENTED_H +// Temporary forwarding header +#include "cc/stubs/not_implemented.h" diff --git a/cc/stubs/SkiaUtils.h b/cc/stubs/SkiaUtils.h index fb81f3eec3ad50..c3bbf89ac17a10 100644 --- a/cc/stubs/SkiaUtils.h +++ b/cc/stubs/SkiaUtils.h @@ -1,17 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_SKIAUTILS_H_ -#define CC_STUBS_SKIAUTILS_H_ - -namespace cc { - -inline SkScalar CCFloatToSkScalar(float f) -{ - return SkFloatToScalar(isfinite(f) ? f : 0); -} - -} - -#endif // CC_STUBS_SKIAUTILS_H_ +// Temporary forwarding header +#include "cc/stubs/skia_utils.h" diff --git a/cc/stubs/TilingData.h b/cc/stubs/TilingData.h index 0221500652145c..e6507e322b13c8 100644 --- a/cc/stubs/TilingData.h +++ b/cc/stubs/TilingData.h @@ -1,18 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CC_STUBS_TILINGDATA_H_ -#define CC_STUBS_TILINGDATA_H_ - -#if INSIDE_WEBKIT_BUILD -#include "Source/WebCore/platform/graphics/gpu/TilingData.h" -#else -#include "third_party/WebKit/Source/WebCore/platform/graphics/gpu/TilingData.h" -#endif - -namespace cc { - typedef WebCore::TilingData TilingData; -} - -#endif // CC_STUBS_TILINGDATA_H_ +// Temporary forwarding header +#include "cc/stubs/tiling_data.h" diff --git a/cc/stubs/TraceEvent.h b/cc/stubs/TraceEvent.h index 75587a34a178de..27e408934c5f13 100644 --- a/cc/stubs/TraceEvent.h +++ b/cc/stubs/TraceEvent.h @@ -1,10 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Chromium's LOG() macro collides with one from WTF. -#ifdef LOG -#undef LOG -#endif - -#include "base/debug/trace_event.h" +// Temporary forwarding header +#include "cc/stubs/trace_event.h" diff --git a/cc/stubs/UnitBezier.h b/cc/stubs/UnitBezier.h index 1ff5da9d2a2bd9..d6a792d90e6aaa 100644 --- a/cc/stubs/UnitBezier.h +++ b/cc/stubs/UnitBezier.h @@ -1,14 +1,6 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// TODO(jamesr): Remove or refactor this dependency. -#if INSIDE_WEBKIT_BUILD -#include "Source/WebCore/platform/graphics/UnitBezier.h" -#else -#include "third_party/WebKit/Source/WebCore/platform/graphics/UnitBezier.h" -#endif - -namespace cc { -typedef WebCore::UnitBezier UnitBezier; -} +// Temporary forwarding header +#include "cc/stubs/unit_bezier.h" diff --git a/cc/stubs/extensions_3d.h b/cc/stubs/extensions_3d.h index 638cbb270ce9b2..bbeb9e6e9f2662 100644 --- a/cc/stubs/extensions_3d.h +++ b/cc/stubs/extensions_3d.h @@ -1,3 +1,25 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_EXTENSIONS3D_H_ +#define CC_STUBS_EXTENSIONS3D_H_ + +#include "third_party/khronos/GLES2/gl2.h" +#include "third_party/khronos/GLES2/gl2ext.h" + +namespace cc { + +class Extensions3D { +public: + enum { + TEXTURE_RECTANGLE_ARB = GL_TEXTURE_RECTANGLE_ARB, + BGRA_EXT = GL_BGRA_EXT, + RGBA8_OES = GL_RGBA8_OES, + }; +}; + +} + + +#endif // CC_STUBS_EXTENSIONS3D_H_ diff --git a/cc/stubs/extensions_3d_chromium.h b/cc/stubs/extensions_3d_chromium.h index 638cbb270ce9b2..f5d36d2300a7e4 100644 --- a/cc/stubs/extensions_3d_chromium.h +++ b/cc/stubs/extensions_3d_chromium.h @@ -1,3 +1,54 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_EXTENSIONS3DCHROMIUM_H_ +#define CC_STUBS_EXTENSIONS3DCHROMIUM_H_ + +#include "Extensions3D.h" + +// These enum names collides with gl2ext.h, so we just redefine them. +#ifdef GL_TEXTURE_EXTERNAL_OES +#undef GL_TEXTURE_EXTERNAL_OES +#endif +#ifdef GL_TEXTURE_USAGE_ANGLE +#undef GL_TEXTURE_USAGE_ANGLE +#endif +#ifdef GL_FRAMEBUFFER_ATTACHMENT_ANGLE +#undef GL_FRAMEBUFFER_ATTACHMENT_ANGLE +#endif + +namespace cc { + +class Extensions3DChromium { +public: + enum { + // GL_OES_EGL_image_external + GL_TEXTURE_EXTERNAL_OES = 0x8D65, + + // GL_CHROMIUM_map_sub (enums inherited from GL_ARB_vertex_buffer_object) + READ_ONLY = 0x88B8, + WRITE_ONLY = 0x88B9, + + // GL_ANGLE_texture_usage + GL_TEXTURE_USAGE_ANGLE = 0x93A2, + GL_FRAMEBUFFER_ATTACHMENT_ANGLE = 0x93A3, + + // GL_EXT_texture_storage + BGRA8_EXT = 0x93A1, + + // GL_EXT_occlusion_query_boolean + ANY_SAMPLES_PASSED_EXT = 0x8C2F, + ANY_SAMPLES_PASSED_CONSERVATIVE_EXT = 0x8D6A, + CURRENT_QUERY_EXT = 0x8865, + QUERY_RESULT_EXT = 0x8866, + QUERY_RESULT_AVAILABLE_EXT = 0x8867, + + // GL_CHROMIUM_command_buffer_query + COMMANDS_ISSUED_CHROMIUM = 0x84F2 + }; +}; + +} + +#endif // CC_STUBS_EXTENSIONS3DCHROMIUM_H_ diff --git a/cc/stubs/float_point.h b/cc/stubs/float_point.h index 638cbb270ce9b2..4ce268188aa7ee 100644 --- a/cc/stubs/float_point.h +++ b/cc/stubs/float_point.h @@ -1,3 +1,51 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_FLOATPOINT_H_ +#define CC_STUBS_FLOATPOINT_H_ + +#include "FloatSize.h" +#include "IntPoint.h" +#if INSIDE_WEBKIT_BUILD +#include "Source/WebCore/platform/graphics/FloatPoint.h" +#else +#include "third_party/WebKit/Source/WebCore/platform/graphics/FloatPoint.h" +#endif + +namespace cc { + +class FloatPoint : public WebCore::FloatPoint { +public: + FloatPoint() { } + + FloatPoint(float width, float height) + : WebCore::FloatPoint(width, height) + { + } + + FloatPoint(FloatSize size) + : WebCore::FloatPoint(size) + { + } + + FloatPoint(IntPoint point) + : WebCore::FloatPoint(point) + { + } + + FloatPoint(WebCore::IntPoint point) + : WebCore::FloatPoint(point) + { + } + + FloatPoint(WebCore::FloatPoint point) + : WebCore::FloatPoint(point.x(), point.y()) + { + + } +}; + +} + +#endif diff --git a/cc/stubs/float_point_3d.h b/cc/stubs/float_point_3d.h index 638cbb270ce9b2..02ff076d7ff347 100644 --- a/cc/stubs/float_point_3d.h +++ b/cc/stubs/float_point_3d.h @@ -1,3 +1,50 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_FLOATPOINT3D_H_ +#define CC_STUBS_FLOATPOINT3D_H_ + +#include "FloatPoint.h" + +#if INSIDE_WEBKIT_BUILD +#include "Source/WebCore/platform/graphics/FloatPoint3D.h" +#else +#include "third_party/WebKit/Source/WebCore/platform/graphics/FloatPoint3D.h" +#endif + +namespace cc { + +class FloatPoint3D : public WebCore::FloatPoint3D { +public: + FloatPoint3D() { } + + FloatPoint3D(float x, float y, float z) + : WebCore::FloatPoint3D(x, y, z) + { + } + + FloatPoint3D(FloatPoint point) + : WebCore::FloatPoint3D(point.x(), point.y(), 0) + { + } + + FloatPoint3D(const FloatPoint3D& point) + : WebCore::FloatPoint3D(point) + { + } + + FloatPoint3D(WebCore::FloatPoint3D point) + : WebCore::FloatPoint3D(point) + { + } + + FloatPoint3D(WebCore::FloatPoint point) + : WebCore::FloatPoint3D(point) + { + } +}; + +} + +#endif diff --git a/cc/stubs/float_quad.h b/cc/stubs/float_quad.h index 638cbb270ce9b2..f2f45ed568371a 100644 --- a/cc/stubs/float_quad.h +++ b/cc/stubs/float_quad.h @@ -1,3 +1,56 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_FLOATQUAD_H_ +#define CC_STUBS_FLOATQUAD_H_ + +#include "FloatPoint.h" +#include "FloatRect.h" +#if INSIDE_WEBKIT_BUILD +#include "Source/WebCore/platform/graphics/FloatQuad.h" +#else +#include "third_party/WebKit/Source/WebCore/platform/graphics/FloatQuad.h" +#endif + +namespace cc { + +class FloatQuad : public WebCore::FloatQuad +{ +public: + FloatQuad() { } + + FloatQuad(const FloatPoint& p1, const FloatPoint& p2, const FloatPoint& p3, const FloatPoint& p4) + : WebCore::FloatQuad(p1, p2, p3, p4) + { + } + + FloatQuad(const FloatRect& rect) + : WebCore::FloatQuad(rect) + { + } + + FloatQuad(const IntRect& rect) + : WebCore::FloatQuad(rect) + { + } + + FloatQuad(const WebCore::FloatRect& rect) + : WebCore::FloatQuad(rect) + { + } + + FloatQuad(const WebCore::IntRect& rect) + : WebCore::FloatQuad(rect) + { + } + + FloatQuad(const WebCore::FloatQuad& quad) + : WebCore::FloatQuad(quad) + { + } +}; + +} + +#endif diff --git a/cc/stubs/float_rect.h b/cc/stubs/float_rect.h index 638cbb270ce9b2..2eb03e2749e738 100644 --- a/cc/stubs/float_rect.h +++ b/cc/stubs/float_rect.h @@ -1,3 +1,56 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_FLOATRECT_H_ +#define CC_STUBS_FLOATRECT_H_ + +#include "FloatPoint.h" +#include "FloatSize.h" +#include "IntRect.h" +#if INSIDE_WEBKIT_BUILD +#include "Source/WebCore/platform/graphics/FloatRect.h" +#else +#include "third_party/WebKit/Source/WebCore/platform/graphics/FloatRect.h" +#endif + +namespace cc { + +class FloatRect : public WebCore::FloatRect { +public: + FloatRect() { } + + FloatRect(const FloatPoint& location, const FloatSize& size) + : WebCore::FloatRect(location, size) + { + } + + FloatRect(const IntPoint& location, const IntSize& size) + : WebCore::FloatRect(location, size) + { + } + + FloatRect(float x, float y, float width, float height) + : WebCore::FloatRect(x, y, width, height) + { + } + + FloatRect(const IntRect& rect) + : WebCore::FloatRect(rect) + { + } + + FloatRect(const WebCore::IntRect& rect) + : WebCore::FloatRect(rect) + { + } + + FloatRect(const WebCore::FloatRect& rect) + :WebCore::FloatRect(rect) + { + } +}; + +} + +#endif diff --git a/cc/stubs/float_size.h b/cc/stubs/float_size.h index 638cbb270ce9b2..9db59788f7d52b 100644 --- a/cc/stubs/float_size.h +++ b/cc/stubs/float_size.h @@ -1,3 +1,43 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_FLOATSIZE_H_ +#define CC_STUBS_FLOATSIZE_H_ + +#include "IntSize.h" +#if INSIDE_WEBKIT_BUILD +#include "Source/WebCore/platform/graphics/FloatSize.h" +#else +#include "third_party/WebKit/Source/WebCore/platform/graphics/FloatSize.h" +#endif + +namespace cc { +class FloatSize : public WebCore::FloatSize { +public: + FloatSize() { } + + FloatSize(float width, float height) + : WebCore::FloatSize(width, height) + { + } + + FloatSize(IntSize size) + : WebCore::FloatSize(size.width(), size.height()) + { + } + + FloatSize(WebCore::FloatSize size) + : WebCore::FloatSize(size.width(), size.height()) + { + } + + FloatSize(WebCore::IntSize size) + : WebCore::FloatSize(size.width(), size.height()) + { + } +}; + +} + +#endif diff --git a/cc/stubs/graphics_context_3d.h b/cc/stubs/graphics_context_3d.h index 638cbb270ce9b2..e7f7a606dadaa1 100644 --- a/cc/stubs/graphics_context_3d.h +++ b/cc/stubs/graphics_context_3d.h @@ -1,3 +1,74 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_GRAPHICSCONTEXT3D_H_ +#define CC_STUBS_GRAPHICSCONTEXT3D_H_ + +#include "GraphicsTypes3D.h" +#include "IntSize.h" +#include "third_party/khronos/GLES2/gl2.h" + +#ifdef NO_ERROR +#undef NO_ERROR +#endif + +namespace cc { + +class GraphicsContext3D { +public: + enum SourceDataFormat { SourceFormatRGBA8, SourceFormatBGRA8 }; + static bool computeFormatAndTypeParameters(unsigned, unsigned, unsigned* componentsPerPixel, unsigned* bytesPerComponent); + + enum { + ARRAY_BUFFER = GL_ARRAY_BUFFER, + BLEND = GL_BLEND, + CLAMP_TO_EDGE = GL_CLAMP_TO_EDGE, + COLOR_ATTACHMENT0 = GL_COLOR_ATTACHMENT0, + COLOR_BUFFER_BIT = GL_COLOR_BUFFER_BIT, + COMPILE_STATUS = GL_COMPILE_STATUS, + CULL_FACE = GL_CULL_FACE, + DEPTH_TEST = GL_DEPTH_TEST, + ELEMENT_ARRAY_BUFFER = GL_ELEMENT_ARRAY_BUFFER, + EXTENSIONS = GL_EXTENSIONS, + FLOAT = GL_FLOAT, + FRAGMENT_SHADER = GL_FRAGMENT_SHADER, + FRAMEBUFFER_COMPLETE = GL_FRAMEBUFFER_COMPLETE, + FRAMEBUFFER = GL_FRAMEBUFFER, + INVALID_ENUM = GL_INVALID_ENUM, + INVALID_VALUE = GL_INVALID_VALUE, + LINEAR = GL_LINEAR, + LINE_LOOP = GL_LINE_LOOP , + LINK_STATUS = GL_LINK_STATUS, + LUMINANCE = GL_LUMINANCE, + MAX_TEXTURE_SIZE = GL_MAX_TEXTURE_SIZE, + NEAREST = GL_NEAREST, + NO_ERROR = GL_NO_ERROR, + ONE = GL_ONE, + ONE_MINUS_SRC_ALPHA = GL_ONE_MINUS_SRC_ALPHA, + RGBA = GL_RGBA, + RGB = GL_RGB, + SCISSOR_TEST = GL_SCISSOR_TEST, + SRC_ALPHA = GL_SRC_ALPHA, + STATIC_DRAW = GL_STATIC_DRAW, + TEXTURE0 = GL_TEXTURE0, + TEXTURE1 = GL_TEXTURE1, + TEXTURE_2D = GL_TEXTURE_2D, + TEXTURE2 = GL_TEXTURE2, + TEXTURE3 = GL_TEXTURE3, + TEXTURE_MAG_FILTER = GL_TEXTURE_MAG_FILTER, + TEXTURE_MIN_FILTER = GL_TEXTURE_MIN_FILTER, + TEXTURE_WRAP_S = GL_TEXTURE_WRAP_S, + TEXTURE_WRAP_T = GL_TEXTURE_WRAP_T, + TRIANGLES = GL_TRIANGLES, + TRIANGLE_FAN = GL_TRIANGLE_FAN, + UNSIGNED_BYTE = GL_UNSIGNED_BYTE, + UNSIGNED_SHORT = GL_UNSIGNED_SHORT, + VERTEX_SHADER = GL_VERTEX_SHADER, + ZERO = GL_ZERO, + }; +}; + +} + +#endif // CC_STUBS_GRAPHICSCONTEXT3D_H_ diff --git a/cc/stubs/graphics_types_3d.h b/cc/stubs/graphics_types_3d.h index 638cbb270ce9b2..a01414e5179cfb 100644 --- a/cc/stubs/graphics_types_3d.h +++ b/cc/stubs/graphics_types_3d.h @@ -1,3 +1,18 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_GRAPHICSTYPES3D_H_ +#define CC_STUBS_GRAPHICSTYPES3D_H_ + +#define NullPlatform3DObject 0 + +typedef unsigned char GC3Dboolean; +typedef unsigned GC3Denum; +typedef unsigned GC3Duint; +typedef unsigned Platform3DObject; +typedef int GC3Dint; +typedef signed char GC3Dbyte; + +#endif // CC_STUBS_GRAPHICSTYPES3D_H_ + diff --git a/cc/stubs/int_point.h b/cc/stubs/int_point.h index 638cbb270ce9b2..fa12deadd4c943 100644 --- a/cc/stubs/int_point.h +++ b/cc/stubs/int_point.h @@ -1,3 +1,40 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_INTPOINT_H_ +#define CC_STUBS_INTPOINT_H_ + +#include "IntSize.h" +#if INSIDE_WEBKIT_BUILD +#include "Source/WebCore/platform/graphics/IntPoint.h" +#else +#include "third_party/WebKit/Source/WebCore/platform/graphics/IntPoint.h" +#endif + +namespace cc { + +class IntPoint : public WebCore::IntPoint { +public: + IntPoint() { } + + IntPoint(int width, int height) + : WebCore::IntPoint(width, height) + { + } + + IntPoint(IntSize size) + : WebCore::IntPoint(size.width(), size.height()) + { + } + + IntPoint(WebCore::IntPoint point) + : WebCore::IntPoint(point.x(), point.y()) + { + + } +}; + +} + +#endif diff --git a/cc/stubs/int_rect.h b/cc/stubs/int_rect.h index 638cbb270ce9b2..1599967a881172 100644 --- a/cc/stubs/int_rect.h +++ b/cc/stubs/int_rect.h @@ -1,3 +1,41 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_INTRECT_H_ +#define CC_STUBS_INTRECT_H_ + +#include "IntPoint.h" +#include "IntSize.h" +#if INSIDE_WEBKIT_BUILD +#include "Source/WebCore/platform/graphics/IntRect.h" +#else +#include "third_party/WebKit/Source/WebCore/platform/graphics/IntRect.h" +#endif + +namespace cc { + +class IntRect : public WebCore::IntRect { +public: + IntRect() { } + + IntRect(const IntPoint& location, const IntSize& size) + : WebCore::IntRect(location, size) + { + } + + IntRect(int x, int y, int width, int height) + : WebCore::IntRect(x, y, width, height) + { + } + + IntRect(WebCore::IntRect rect) + : WebCore::IntRect(rect.x(), rect.y(), rect.width(), rect.height()) + { + + } +}; + +} + +#endif diff --git a/cc/stubs/int_size.h b/cc/stubs/int_size.h index 638cbb270ce9b2..c53f4f155dd666 100644 --- a/cc/stubs/int_size.h +++ b/cc/stubs/int_size.h @@ -1,3 +1,34 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_INTSIZE_H_ +#define CC_STUBS_INTSIZE_H_ + +#if INSIDE_WEBKIT_BUILD +#include "Source/WebCore/platform/graphics/IntSize.h" +#else +#include "third_party/WebKit/Source/WebCore/platform/graphics/IntSize.h" +#endif + +namespace cc { + +class IntSize : public WebCore::IntSize { +public: + IntSize() { } + + IntSize(int width, int height) + : WebCore::IntSize(width, height) + { + } + + IntSize(WebCore::IntSize size) + : WebCore::IntSize(size.width(), size.height()) + { + + } +}; + +} + +#endif diff --git a/cc/stubs/not_implemented.h b/cc/stubs/not_implemented.h index 638cbb270ce9b2..7c6bba571509a9 100644 --- a/cc/stubs/not_implemented.h +++ b/cc/stubs/not_implemented.h @@ -1,3 +1,10 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_NOTIMPLEMENTED_H +#define CC_STUBS_NOTIMPLEMENTED_H + +#define notImplemented() do { } while(0) + +#endif // CC_STUBS_NOTIMPLEMENTED_H diff --git a/cc/stubs/skia_utils.h b/cc/stubs/skia_utils.h index 638cbb270ce9b2..fb81f3eec3ad50 100644 --- a/cc/stubs/skia_utils.h +++ b/cc/stubs/skia_utils.h @@ -1,3 +1,17 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_SKIAUTILS_H_ +#define CC_STUBS_SKIAUTILS_H_ + +namespace cc { + +inline SkScalar CCFloatToSkScalar(float f) +{ + return SkFloatToScalar(isfinite(f) ? f : 0); +} + +} + +#endif // CC_STUBS_SKIAUTILS_H_ diff --git a/cc/stubs/tiling_data.h b/cc/stubs/tiling_data.h index 638cbb270ce9b2..0221500652145c 100644 --- a/cc/stubs/tiling_data.h +++ b/cc/stubs/tiling_data.h @@ -1,3 +1,18 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CC_STUBS_TILINGDATA_H_ +#define CC_STUBS_TILINGDATA_H_ + +#if INSIDE_WEBKIT_BUILD +#include "Source/WebCore/platform/graphics/gpu/TilingData.h" +#else +#include "third_party/WebKit/Source/WebCore/platform/graphics/gpu/TilingData.h" +#endif + +namespace cc { + typedef WebCore::TilingData TilingData; +} + +#endif // CC_STUBS_TILINGDATA_H_ diff --git a/cc/stubs/trace_event.h b/cc/stubs/trace_event.h index 638cbb270ce9b2..75587a34a178de 100644 --- a/cc/stubs/trace_event.h +++ b/cc/stubs/trace_event.h @@ -1,3 +1,10 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +// Chromium's LOG() macro collides with one from WTF. +#ifdef LOG +#undef LOG +#endif + +#include "base/debug/trace_event.h" diff --git a/cc/stubs/unit_bezier.h b/cc/stubs/unit_bezier.h index 638cbb270ce9b2..1ff5da9d2a2bd9 100644 --- a/cc/stubs/unit_bezier.h +++ b/cc/stubs/unit_bezier.h @@ -1,3 +1,14 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +// TODO(jamesr): Remove or refactor this dependency. +#if INSIDE_WEBKIT_BUILD +#include "Source/WebCore/platform/graphics/UnitBezier.h" +#else +#include "third_party/WebKit/Source/WebCore/platform/graphics/UnitBezier.h" +#endif + +namespace cc { +typedef WebCore::UnitBezier UnitBezier; +} diff --git a/cc/CCTexture.cpp b/cc/texture.cc similarity index 100% rename from cc/CCTexture.cpp rename to cc/texture.cc diff --git a/cc/texture.h b/cc/texture.h index 638cbb270ce9b2..8d0def354495aa 100644 --- a/cc/texture.h +++ b/cc/texture.h @@ -1,3 +1,42 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCTexture_h +#define CCTexture_h + +#include "CCResourceProvider.h" +#include "CCTexture.h" +#include "GraphicsContext3D.h" +#include "IntSize.h" + +namespace cc { + +class CCTexture { +public: + CCTexture() : m_id(0) { } + CCTexture(unsigned id, IntSize size, GC3Denum format) + : m_id(id) + , m_size(size) + , m_format(format) { } + + CCResourceProvider::ResourceId id() const { return m_id; } + const IntSize& size() const { return m_size; } + GC3Denum format() const { return m_format; } + + void setId(CCResourceProvider::ResourceId id) { m_id = id; } + void setDimensions(const IntSize&, GC3Denum format); + + size_t bytes() const; + + static size_t memorySizeBytes(const IntSize&, GC3Denum format); + +private: + CCResourceProvider::ResourceId m_id; + IntSize m_size; + GC3Denum m_format; +}; + +} + +#endif diff --git a/cc/TextureCopier.cpp b/cc/texture_copier.cc similarity index 100% rename from cc/TextureCopier.cpp rename to cc/texture_copier.cc diff --git a/cc/texture_copier.h b/cc/texture_copier.h index 638cbb270ce9b2..ba8d7bf5e6af9b 100644 --- a/cc/texture_copier.h +++ b/cc/texture_copier.h @@ -1,3 +1,70 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef TextureCopier_h +#define TextureCopier_h + +#include "base/basictypes.h" +#include "GraphicsContext3D.h" +#include "ProgramBinding.h" +#include "ShaderChromium.h" +#include +#include + +namespace WebKit { +class WebGraphicsContext3D; +} + +namespace cc { +class IntSize; + +class TextureCopier { +public: + struct Parameters { + unsigned sourceTexture; + unsigned destTexture; + IntSize size; + }; + // Copy the base level contents of |sourceTexture| to |destTexture|. Both texture objects + // must be complete and have a base level of |size| dimensions. The color formats do not need + // to match, but |destTexture| must have a renderable format. + virtual void copyTexture(Parameters) = 0; + virtual void flush() = 0; + + virtual ~TextureCopier() { } +}; + +#if USE(ACCELERATED_COMPOSITING) + +class AcceleratedTextureCopier : public TextureCopier { +public: + static PassOwnPtr create(WebKit::WebGraphicsContext3D* context, bool usingBindUniforms) + { + return adoptPtr(new AcceleratedTextureCopier(context, usingBindUniforms)); + } + virtual ~AcceleratedTextureCopier(); + + virtual void copyTexture(Parameters) OVERRIDE; + virtual void flush() OVERRIDE; + +protected: + AcceleratedTextureCopier(WebKit::WebGraphicsContext3D*, bool usingBindUniforms); + +private: + typedef ProgramBinding BlitProgram; + + WebKit::WebGraphicsContext3D* m_context; + Platform3DObject m_fbo; + Platform3DObject m_positionBuffer; + OwnPtr m_blitProgram; + bool m_usingBindUniforms; + + DISALLOW_COPY_AND_ASSIGN(AcceleratedTextureCopier); +}; + +#endif // USE(ACCELERATED_COMPOSITING) + +} + +#endif diff --git a/cc/CCTextureDrawQuad.cpp b/cc/texture_draw_quad.cc similarity index 100% rename from cc/CCTextureDrawQuad.cpp rename to cc/texture_draw_quad.cc diff --git a/cc/texture_draw_quad.h b/cc/texture_draw_quad.h index 638cbb270ce9b2..daa600f717f6d4 100644 --- a/cc/texture_draw_quad.h +++ b/cc/texture_draw_quad.h @@ -1,3 +1,41 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCTextureDrawQuad_h +#define CCTextureDrawQuad_h + +#include "CCDrawQuad.h" +#include "FloatRect.h" +#include "base/memory/scoped_ptr.h" + +namespace cc { + +#pragma pack(push, 4) + +class CCTextureDrawQuad : public CCDrawQuad { +public: + static scoped_ptr create(const CCSharedQuadState*, const IntRect&, unsigned resourceId, bool premultipliedAlpha, const FloatRect& uvRect, bool flipped); + FloatRect uvRect() const { return m_uvRect; } + + unsigned resourceId() const { return m_resourceId; } + bool premultipliedAlpha() const { return m_premultipliedAlpha; } + bool flipped() const { return m_flipped; } + + void setNeedsBlending(); + + static const CCTextureDrawQuad* materialCast(const CCDrawQuad*); +private: + CCTextureDrawQuad(const CCSharedQuadState*, const IntRect&, unsigned resourceId, bool premultipliedAlpha, const FloatRect& uvRect, bool flipped); + + unsigned m_resourceId; + bool m_premultipliedAlpha; + FloatRect m_uvRect; + bool m_flipped; +}; + +#pragma pack(pop) + +} + +#endif diff --git a/cc/TextureLayerChromium.cpp b/cc/texture_layer.cc similarity index 100% rename from cc/TextureLayerChromium.cpp rename to cc/texture_layer.cc diff --git a/cc/texture_layer.h b/cc/texture_layer.h index 638cbb270ce9b2..124f84505d27b6 100644 --- a/cc/texture_layer.h +++ b/cc/texture_layer.h @@ -1,3 +1,77 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2010 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef TextureLayerChromium_h +#define TextureLayerChromium_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "LayerChromium.h" + +namespace WebKit { +class WebGraphicsContext3D; +} + +namespace cc { + +class TextureLayerChromiumClient; + +// A Layer containing a the rendered output of a plugin instance. +class TextureLayerChromium : public LayerChromium { +public: + // If this texture layer requires special preparation logic for each frame driven by + // the compositor, pass in a non-nil client. Pass in a nil client pointer if texture updates + // are driven by an external process. + static scoped_refptr create(TextureLayerChromiumClient*); + + void clearClient() { m_client = 0; } + + virtual scoped_ptr createCCLayerImpl() OVERRIDE; + + // Sets whether this texture should be Y-flipped at draw time. Defaults to true. + void setFlipped(bool); + + // Sets a UV transform to be used at draw time. Defaults to (0, 0, 1, 1). + void setUVRect(const FloatRect&); + + // Sets whether the alpha channel is premultiplied or unpremultiplied. Defaults to true. + void setPremultipliedAlpha(bool); + + // Sets whether this context should rate limit on damage to prevent too many frames from + // being queued up before the compositor gets a chance to run. Requires a non-nil client. + // Defaults to false. + void setRateLimitContext(bool); + + // Code path for plugins which supply their own texture ID. + void setTextureId(unsigned); + + void willModifyTexture(); + + virtual void setNeedsDisplayRect(const FloatRect&) OVERRIDE; + + virtual void setLayerTreeHost(CCLayerTreeHost*) OVERRIDE; + virtual bool drawsContent() const OVERRIDE; + virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) OVERRIDE; + virtual void pushPropertiesTo(CCLayerImpl*) OVERRIDE; + +protected: + explicit TextureLayerChromium(TextureLayerChromiumClient*); + virtual ~TextureLayerChromium(); + +private: + TextureLayerChromiumClient* m_client; + + bool m_flipped; + FloatRect m_uvRect; + bool m_premultipliedAlpha; + bool m_rateLimitContext; + bool m_contextLost; + + unsigned m_textureId; +}; + +} +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/texture_layer_client.h b/cc/texture_layer_client.h index 638cbb270ce9b2..4edbe9f5860ee0 100644 --- a/cc/texture_layer_client.h +++ b/cc/texture_layer_client.h @@ -1,3 +1,31 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef TextureLayerChromiumClient_h +#define TextureLayerChromiumClient_h + +namespace WebKit { +class WebGraphicsContext3D; +} + +namespace cc { +class CCTextureUpdateQueue; + +class TextureLayerChromiumClient { +public: + // Called to prepare this layer's texture for compositing. The client may queue a texture + // upload or copy on the CCTextureUpdateQueue. + // Returns the texture ID to be used for compositing. + virtual unsigned prepareTexture(CCTextureUpdateQueue&) = 0; + + // Returns the context that is providing the texture. Used for rate limiting and detecting lost context. + virtual WebKit::WebGraphicsContext3D* context() = 0; + +protected: + virtual ~TextureLayerChromiumClient() { } +}; + +} + +#endif // TextureLayerChromiumClient_h diff --git a/cc/CCTextureLayerImpl.cpp b/cc/texture_layer_impl.cc similarity index 100% rename from cc/CCTextureLayerImpl.cpp rename to cc/texture_layer_impl.cc diff --git a/cc/texture_layer_impl.h b/cc/texture_layer_impl.h index 638cbb270ce9b2..ff88ff36db2b8a 100644 --- a/cc/texture_layer_impl.h +++ b/cc/texture_layer_impl.h @@ -1,3 +1,48 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCTextureLayerImpl_h +#define CCTextureLayerImpl_h + +#include "CCLayerImpl.h" + +namespace cc { + +class CCTextureLayerImpl : public CCLayerImpl { +public: + static scoped_ptr create(int id) + { + return make_scoped_ptr(new CCTextureLayerImpl(id)); + } + virtual ~CCTextureLayerImpl(); + + virtual void willDraw(CCResourceProvider*) OVERRIDE; + virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; + virtual void didDraw(CCResourceProvider*) OVERRIDE; + + virtual void didLoseContext() OVERRIDE; + + virtual void dumpLayerProperties(std::string*, int indent) const OVERRIDE; + + unsigned textureId() const { return m_textureId; } + void setTextureId(unsigned id) { m_textureId = id; } + void setPremultipliedAlpha(bool premultipliedAlpha) { m_premultipliedAlpha = premultipliedAlpha; } + void setFlipped(bool flipped) { m_flipped = flipped; } + void setUVRect(const FloatRect& rect) { m_uvRect = rect; } + +private: + explicit CCTextureLayerImpl(int); + + virtual const char* layerTypeAsString() const OVERRIDE; + + unsigned m_textureId; + CCResourceProvider::ResourceId m_externalTextureResource; + bool m_premultipliedAlpha; + bool m_flipped; + FloatRect m_uvRect; +}; + +} + +#endif // CCTextureLayerImpl_h diff --git a/cc/CCTextureUpdateController.cpp b/cc/texture_update_controller.cc similarity index 100% rename from cc/CCTextureUpdateController.cpp rename to cc/texture_update_controller.cc diff --git a/cc/texture_update_controller.h b/cc/texture_update_controller.h index 638cbb270ce9b2..74bb8ca957403e 100644 --- a/cc/texture_update_controller.h +++ b/cc/texture_update_controller.h @@ -1,3 +1,77 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCTextureUpdateController_h +#define CCTextureUpdateController_h + +#include "base/basictypes.h" +#include "base/time.h" +#include "CCTextureUpdateQueue.h" +#include "CCTimer.h" +#include + +namespace cc { + +class TextureUploader; + +class CCTextureUpdateControllerClient { +public: + virtual void readyToFinalizeTextureUpdates() = 0; + +protected: + virtual ~CCTextureUpdateControllerClient() { } +}; + +class CCTextureUpdateController : public CCTimerClient { +public: + static PassOwnPtr create(CCTextureUpdateControllerClient* client, CCThread* thread, PassOwnPtr queue, CCResourceProvider* resourceProvider, TextureUploader* uploader) + { + return adoptPtr(new CCTextureUpdateController(client, thread, queue, resourceProvider, uploader)); + } + static size_t maxPartialTextureUpdates(); + + virtual ~CCTextureUpdateController(); + + // Discard uploads to textures that were evicted on the impl thread. + void discardUploadsToEvictedResources(); + + void performMoreUpdates(base::TimeTicks timeLimit); + void finalize(); + + // CCTimerClient implementation. + virtual void onTimerFired() OVERRIDE; + + // Virtual for testing. + virtual base::TimeTicks now() const; + virtual base::TimeDelta updateMoreTexturesTime() const; + virtual size_t updateMoreTexturesSize() const; + +protected: + CCTextureUpdateController(CCTextureUpdateControllerClient*, CCThread*, PassOwnPtr, CCResourceProvider*, TextureUploader*); + + static size_t maxFullUpdatesPerTick(TextureUploader*); + + size_t maxBlockingUpdates() const; + + // This returns true when there were textures left to update. + bool updateMoreTexturesIfEnoughTimeRemaining(); + void updateMoreTexturesNow(); + + CCTextureUpdateControllerClient* m_client; + OwnPtr m_timer; + OwnPtr m_queue; + bool m_contentsTexturesPurged; + CCResourceProvider* m_resourceProvider; + TextureUploader* m_uploader; + base::TimeTicks m_timeLimit; + size_t m_textureUpdatesPerTick; + bool m_firstUpdateAttempt; + +private: + DISALLOW_COPY_AND_ASSIGN(CCTextureUpdateController); +}; + +} + +#endif // CCTextureUpdateController_h diff --git a/cc/CCTextureUpdateQueue.cpp b/cc/texture_update_queue.cc similarity index 100% rename from cc/CCTextureUpdateQueue.cpp rename to cc/texture_update_queue.cc diff --git a/cc/texture_update_queue.h b/cc/texture_update_queue.h index 638cbb270ce9b2..4cf29338bb038a 100644 --- a/cc/texture_update_queue.h +++ b/cc/texture_update_queue.h @@ -1,3 +1,47 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCTextureUpdateQueue_h +#define CCTextureUpdateQueue_h + +#include "base/basictypes.h" +#include "TextureCopier.h" +#include "TextureUploader.h" +#include + +namespace cc { + +class CCTextureUpdateQueue { +public: + CCTextureUpdateQueue(); + virtual ~CCTextureUpdateQueue(); + + void appendFullUpload(TextureUploader::Parameters); + void appendPartialUpload(TextureUploader::Parameters); + void appendCopy(TextureCopier::Parameters); + + void clearUploadsToEvictedResources(); + + TextureUploader::Parameters takeFirstFullUpload(); + TextureUploader::Parameters takeFirstPartialUpload(); + TextureCopier::Parameters takeFirstCopy(); + + size_t fullUploadSize() const { return m_fullEntries.size(); } + size_t partialUploadSize() const { return m_partialEntries.size(); } + size_t copySize() const { return m_copyEntries.size(); } + + bool hasMoreUpdates() const; + +private: + void clearUploadsToEvictedResources(Deque& entryQueue); + Deque m_fullEntries; + Deque m_partialEntries; + Deque m_copyEntries; + + DISALLOW_COPY_AND_ASSIGN(CCTextureUpdateQueue); +}; + +} + +#endif // CCTextureUpdateQueue_h diff --git a/cc/texture_uploader.h b/cc/texture_uploader.h index 638cbb270ce9b2..5505204a689060 100644 --- a/cc/texture_uploader.h +++ b/cc/texture_uploader.h @@ -1,3 +1,32 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef TextureUploader_h +#define TextureUploader_h + +#include "LayerTextureUpdater.h" + +namespace cc { + +class TextureUploader { +public: + struct Parameters { + LayerTextureUpdater::Texture* texture; + IntRect sourceRect; + IntSize destOffset; + }; + + virtual ~TextureUploader() { } + + virtual size_t numBlockingUploads() = 0; + virtual void markPendingUploadsAsNonBlocking() = 0; + + // Returns our throughput on the GPU process + virtual double estimatedTexturesPerSecond() = 0; + virtual void uploadTexture(CCResourceProvider*, Parameters) = 0; +}; + +} + +#endif diff --git a/cc/thread.h b/cc/thread.h index 638cbb270ce9b2..1ac494663199a1 100644 --- a/cc/thread.h +++ b/cc/thread.h @@ -1,3 +1,43 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCThread_h +#define CCThread_h + +#include "base/basictypes.h" +#include "base/threading/platform_thread.h" +#include + +namespace cc { + +// CCThread provides basic infrastructure for messaging with the compositor in a +// platform-neutral way. +class CCThread { +public: + virtual ~CCThread() { } + + class Task { + public: + virtual ~Task() { } + virtual void performTask() = 0; + void* instance() const { return m_instance; } + protected: + Task(void* instance) : m_instance(instance) { } + void* m_instance; + private: + DISALLOW_COPY_AND_ASSIGN(Task); + }; + + // Executes the task on context's thread asynchronously. + virtual void postTask(PassOwnPtr) = 0; + + // Executes the task after the specified delay. + virtual void postDelayedTask(PassOwnPtr, long long delayMs) = 0; + + virtual base::PlatformThreadId threadID() const = 0; +}; + +} + +#endif diff --git a/cc/CCThreadProxy.cpp b/cc/thread_proxy.cc similarity index 100% rename from cc/CCThreadProxy.cpp rename to cc/thread_proxy.cc diff --git a/cc/thread_proxy.h b/cc/thread_proxy.h index 638cbb270ce9b2..a6ea6acbbc22c4 100644 --- a/cc/thread_proxy.h +++ b/cc/thread_proxy.h @@ -1,3 +1,185 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCThreadProxy_h +#define CCThreadProxy_h + +#include "CCAnimationEvents.h" +#include "CCCompletionEvent.h" +#include "CCLayerTreeHostImpl.h" +#include "CCProxy.h" +#include "CCScheduler.h" +#include "CCTextureUpdateController.h" +#include +#include + +namespace cc { + +class CCInputHandler; +class CCLayerTreeHost; +class CCScheduler; +class CCScopedThreadProxy; +class CCTextureUpdateQueue; +class CCThread; +class CCThreadProxyContextRecreationTimer; + +class CCThreadProxy : public CCProxy, CCLayerTreeHostImplClient, CCSchedulerClient, CCTextureUpdateControllerClient { +public: + static scoped_ptr create(CCLayerTreeHost*); + + virtual ~CCThreadProxy(); + + // CCProxy implementation + virtual bool compositeAndReadback(void *pixels, const IntRect&) OVERRIDE; + virtual void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double duration) OVERRIDE; + virtual void finishAllRendering() OVERRIDE; + virtual bool isStarted() const OVERRIDE; + virtual bool initializeContext() OVERRIDE; + virtual void setSurfaceReady() OVERRIDE; + virtual void setVisible(bool) OVERRIDE; + virtual bool initializeRenderer() OVERRIDE; + virtual bool recreateContext() OVERRIDE; + virtual void renderingStats(CCRenderingStats*) OVERRIDE; + virtual const RendererCapabilities& rendererCapabilities() const OVERRIDE; + virtual void loseContext() OVERRIDE; + virtual void setNeedsAnimate() OVERRIDE; + virtual void setNeedsCommit() OVERRIDE; + virtual void setNeedsRedraw() OVERRIDE; + virtual bool commitRequested() const OVERRIDE; + virtual void didAddAnimation() OVERRIDE { } + virtual void start() OVERRIDE; + virtual void stop() OVERRIDE; + virtual size_t maxPartialTextureUpdates() const OVERRIDE; + virtual void acquireLayerTextures() OVERRIDE; + virtual void forceSerializeOnSwapBuffers() OVERRIDE; + + // CCLayerTreeHostImplClient implementation + virtual void didLoseContextOnImplThread() OVERRIDE; + virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE; + virtual void onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds) OVERRIDE; + virtual void onCanDrawStateChanged(bool canDraw) OVERRIDE; + virtual void setNeedsRedrawOnImplThread() OVERRIDE; + virtual void setNeedsCommitOnImplThread() OVERRIDE; + virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr, double wallClockTime) OVERRIDE; + virtual void releaseContentsTexturesOnImplThread() OVERRIDE; + + // CCSchedulerClient implementation + virtual void scheduledActionBeginFrame() OVERRIDE; + virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible() OVERRIDE; + virtual CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced() OVERRIDE; + virtual void scheduledActionCommit() OVERRIDE; + virtual void scheduledActionBeginContextRecreation() OVERRIDE; + virtual void scheduledActionAcquireLayerTexturesForMainThread() OVERRIDE; + virtual void didAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE; + + // CCTextureUpdateControllerClient implementation + virtual void readyToFinalizeTextureUpdates() OVERRIDE; + +private: + explicit CCThreadProxy(CCLayerTreeHost*); + friend class CCThreadProxyContextRecreationTimer; + + // Set on impl thread, read on main thread. + struct BeginFrameAndCommitState { + BeginFrameAndCommitState(); + ~BeginFrameAndCommitState(); + + double monotonicFrameBeginTime; + scoped_ptr scrollInfo; + WebKit::WebTransformationMatrix implTransform; + CCPrioritizedTextureManager::BackingVector evictedContentsTexturesBackings; + size_t memoryAllocationLimitBytes; + }; + OwnPtr m_pendingBeginFrameRequest; + + // Called on main thread + void beginFrame(); + void didCommitAndDrawFrame(); + void didCompleteSwapBuffers(); + void setAnimationEvents(CCAnimationEventsVector*, double wallClockTime); + void beginContextRecreation(); + void tryToRecreateContext(); + + // Called on impl thread + struct ReadbackRequest { + CCCompletionEvent completion; + bool success; + void* pixels; + IntRect rect; + }; + void forceBeginFrameOnImplThread(CCCompletionEvent*); + void beginFrameCompleteOnImplThread(CCCompletionEvent*, PassOwnPtr); + void beginFrameAbortedOnImplThread(); + void requestReadbackOnImplThread(ReadbackRequest*); + void requestStartPageScaleAnimationOnImplThread(IntSize targetPosition, bool useAnchor, float scale, double durationSec); + void finishAllRenderingOnImplThread(CCCompletionEvent*); + void initializeImplOnImplThread(CCCompletionEvent*, CCInputHandler*); + void setSurfaceReadyOnImplThread(); + void setVisibleOnImplThread(CCCompletionEvent*, bool); + void initializeContextOnImplThread(CCGraphicsContext*); + void initializeRendererOnImplThread(CCCompletionEvent*, bool* initializeSucceeded, RendererCapabilities*); + void layerTreeHostClosedOnImplThread(CCCompletionEvent*); + void setFullRootLayerDamageOnImplThread(); + void acquireLayerTexturesForMainThreadOnImplThread(CCCompletionEvent*); + void recreateContextOnImplThread(CCCompletionEvent*, CCGraphicsContext*, bool* recreateSucceeded, RendererCapabilities*); + void renderingStatsOnImplThread(CCCompletionEvent*, CCRenderingStats*); + CCScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapInternal(bool forcedDraw); + void forceSerializeOnSwapBuffersOnImplThread(CCCompletionEvent*); + void setNeedsForcedCommitOnImplThread(); + + // Accessed on main thread only. + bool m_animateRequested; // Set only when setNeedsAnimate is called. + bool m_commitRequested; // Set only when setNeedsCommit is called. + bool m_commitRequestSentToImplThread; // Set by setNeedsCommit and setNeedsAnimate. + bool m_forcedCommitRequested; + OwnPtr m_contextRecreationTimer; + CCLayerTreeHost* m_layerTreeHost; + bool m_rendererInitialized; + RendererCapabilities m_RendererCapabilitiesMainThreadCopy; + bool m_started; + bool m_texturesAcquired; + bool m_inCompositeAndReadback; + + scoped_ptr m_layerTreeHostImpl; + + scoped_ptr m_inputHandlerOnImplThread; + + OwnPtr m_schedulerOnImplThread; + + RefPtr m_mainThreadProxy; + + // Holds on to the context we might use for compositing in between initializeContext() + // and initializeRenderer() calls. + scoped_ptr m_contextBeforeInitializationOnImplThread; + + // Set when the main thread is waiting on a scheduledActionBeginFrame to be issued. + CCCompletionEvent* m_beginFrameCompletionEventOnImplThread; + + // Set when the main thread is waiting on a readback. + ReadbackRequest* m_readbackRequestOnImplThread; + + // Set when the main thread is waiting on a commit to complete. + CCCompletionEvent* m_commitCompletionEventOnImplThread; + + // Set when the main thread is waiting on layers to be drawn. + CCCompletionEvent* m_textureAcquisitionCompletionEventOnImplThread; + + OwnPtr m_currentTextureUpdateControllerOnImplThread; + + // Set when we need to reset the contentsTexturesPurged flag after the + // commit. + bool m_resetContentsTexturesPurgedAfterCommitOnImplThread; + + // Set when the next draw should post didCommitAndDrawFrame to the main thread. + bool m_nextFrameIsNewlyCommittedFrameOnImplThread; + + bool m_renderVSyncEnabled; + + base::TimeDelta m_totalCommitTime; + size_t m_totalCommitCount; +}; + +} + +#endif diff --git a/cc/thread_task.h b/cc/thread_task.h index 638cbb270ce9b2..25c5509d5c6c94 100644 --- a/cc/thread_task.h +++ b/cc/thread_task.h @@ -1,3 +1,305 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +#ifndef CCThreadTask_h +#define CCThreadTask_h + +#include "CCThread.h" +#include +#include + +namespace cc { + +template +class CCThreadTask0 : public CCThread::Task { +public: + typedef void (T::*Method)(); + typedef CCThreadTask0 CCThreadTaskImpl; + + static PassOwnPtr create(T* instance, Method method) + { + return adoptPtr(new CCThreadTaskImpl(instance, method)); + } + +private: + CCThreadTask0(T* instance, Method method) + : CCThread::Task(instance) + , m_method(method) + { + } + + virtual void performTask() OVERRIDE + { + (*static_cast(instance()).*m_method)(); + } + +private: + Method m_method; +}; + +template +class CCThreadTask1 : public CCThread::Task { +public: + typedef void (T::*Method)(MP1); + typedef CCThreadTask1 CCThreadTaskImpl; + + static PassOwnPtr create(T* instance, Method method, P1 parameter1) + { + return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1)); + } + +private: + CCThreadTask1(T* instance, Method method, P1 parameter1) + : CCThread::Task(instance) + , m_method(method) + , m_parameter1(parameter1) + { + } + + virtual void performTask() OVERRIDE + { + (*static_cast(instance()).*m_method)(m_parameter1); + } + +private: + Method m_method; + P1 m_parameter1; +}; + +template +class CCThreadTask2 : public CCThread::Task { +public: + typedef void (T::*Method)(MP1, MP2); + typedef CCThreadTask2 CCThreadTaskImpl; + + static PassOwnPtr create(T* instance, Method method, P1 parameter1, P2 parameter2) + { + return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2)); + } + +private: + CCThreadTask2(T* instance, Method method, P1 parameter1, P2 parameter2) + : CCThread::Task(instance) + , m_method(method) + , m_parameter1(parameter1) + , m_parameter2(parameter2) + { + } + + virtual void performTask() OVERRIDE + { + (*static_cast(instance()).*m_method)(m_parameter1, m_parameter2); + } + +private: + Method m_method; + P1 m_parameter1; + P2 m_parameter2; +}; + +template +class CCThreadTask3 : public CCThread::Task { +public: + typedef void (T::*Method)(MP1, MP2, MP3); + typedef CCThreadTask3 CCThreadTaskImpl; + + static PassOwnPtr create(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3) + { + return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2, parameter3)); + } + +private: + CCThreadTask3(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3) + : CCThread::Task(instance) + , m_method(method) + , m_parameter1(parameter1) + , m_parameter2(parameter2) + , m_parameter3(parameter3) + { + } + + virtual void performTask() OVERRIDE + { + (*static_cast(instance()).*m_method)(m_parameter1, m_parameter2, m_parameter3); + } + +private: + Method m_method; + P1 m_parameter1; + P2 m_parameter2; + P3 m_parameter3; +}; + + +template +class CCThreadTask4 : public CCThread::Task { +public: + typedef void (T::*Method)(MP1, MP2, MP3, MP4); + typedef CCThreadTask4 CCThreadTaskImpl; + + static PassOwnPtr create(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3, P4 parameter4) + { + return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2, parameter3, parameter4)); + } + +private: + CCThreadTask4(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3, P4 parameter4) + : CCThread::Task(instance) + , m_method(method) + , m_parameter1(parameter1) + , m_parameter2(parameter2) + , m_parameter3(parameter3) + , m_parameter4(parameter4) + { + } + + virtual void performTask() OVERRIDE + { + (*static_cast(instance()).*m_method)(m_parameter1, m_parameter2, m_parameter3, m_parameter4); + } + +private: + Method m_method; + P1 m_parameter1; + P2 m_parameter2; + P3 m_parameter3; + P4 m_parameter4; +}; + +template +class CCThreadTask5 : public CCThread::Task { +public: + typedef void (T::*Method)(MP1, MP2, MP3, MP4, MP5); + typedef CCThreadTask5 CCThreadTaskImpl; + + static PassOwnPtr create(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3, P4 parameter4, P5 parameter5) + { + return adoptPtr(new CCThreadTaskImpl(instance, method, parameter1, parameter2, parameter3, parameter4, parameter5)); + } + +private: + CCThreadTask5(T* instance, Method method, P1 parameter1, P2 parameter2, P3 parameter3, P4 parameter4, P5 parameter5) + : CCThread::Task(instance) + , m_method(method) + , m_parameter1(parameter1) + , m_parameter2(parameter2) + , m_parameter3(parameter3) + , m_parameter4(parameter4) + , m_parameter5(parameter5) + { + } + + virtual void performTask() OVERRIDE + { + (*static_cast(instance()).*m_method)(m_parameter1, m_parameter2, m_parameter3, m_parameter4, m_parameter5); + } + +private: + Method m_method; + P1 m_parameter1; + P2 m_parameter2; + P3 m_parameter3; + P4 m_parameter4; + P5 m_parameter5; +}; + +template +PassOwnPtr createCCThreadTask( + T* const callee, + void (T::*method)()); + +template +PassOwnPtr createCCThreadTask( + T* const callee, + void (T::*method)()) +{ + return CCThreadTask0::create( + callee, + method); +} + +template +PassOwnPtr createCCThreadTask( + T* const callee, + void (T::*method)(MP1), + const P1& parameter1) +{ + return CCThreadTask1::create( + callee, + method, + parameter1); +} + +template +PassOwnPtr createCCThreadTask( + T* const callee, + void (T::*method)(MP1, MP2), + const P1& parameter1, + const P2& parameter2) +{ + return CCThreadTask2::create( + callee, + method, + parameter1, + parameter2); +} + +template +PassOwnPtr createCCThreadTask( + T* const callee, + void (T::*method)(MP1, MP2, MP3), + const P1& parameter1, + const P2& parameter2, + const P3& parameter3) +{ + return CCThreadTask3::create( + callee, + method, + parameter1, + parameter2, + parameter3); +} + +template +PassOwnPtr createCCThreadTask( + T* const callee, + void (T::*method)(MP1, MP2, MP3, MP4), + const P1& parameter1, + const P2& parameter2, + const P3& parameter3, + const P4& parameter4) +{ + return CCThreadTask4::create( + callee, + method, + parameter1, + parameter2, + parameter3, + parameter4); + +} + +template +PassOwnPtr createCCThreadTask( + T* const callee, + void (T::*method)(MP1, MP2, MP3, MP4, MP5), + const P1& parameter1, + const P2& parameter2, + const P3& parameter3, + const P4& parameter4, + const P5& parameter5) +{ + return CCThreadTask5::create( + callee, + method, + parameter1, + parameter2, + parameter3, + parameter4, + parameter5); + +} + +} // namespace cc + +#endif // CCThreadTask_h diff --git a/cc/ThrottledTextureUploader.cpp b/cc/throttled_texture_uploader.cc similarity index 100% rename from cc/ThrottledTextureUploader.cpp rename to cc/throttled_texture_uploader.cc diff --git a/cc/throttled_texture_uploader.h b/cc/throttled_texture_uploader.h index 638cbb270ce9b2..f51740158d1241 100644 --- a/cc/throttled_texture_uploader.h +++ b/cc/throttled_texture_uploader.h @@ -1,3 +1,76 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef ThrottledTextureUploader_h +#define ThrottledTextureUploader_h + +#include "TextureUploader.h" + +#include "base/basictypes.h" +#include +#include + +namespace WebKit { +class WebGraphicsContext3D; +} + +namespace cc { + +class ThrottledTextureUploader : public TextureUploader { +public: + static PassOwnPtr create(WebKit::WebGraphicsContext3D* context) + { + return adoptPtr(new ThrottledTextureUploader(context)); + } + virtual ~ThrottledTextureUploader(); + + virtual size_t numBlockingUploads() OVERRIDE; + virtual void markPendingUploadsAsNonBlocking() OVERRIDE; + virtual double estimatedTexturesPerSecond() OVERRIDE; + virtual void uploadTexture(CCResourceProvider*, Parameters) OVERRIDE; + +private: + class Query { + public: + static PassOwnPtr create(WebKit::WebGraphicsContext3D* context) { return adoptPtr(new Query(context)); } + + virtual ~Query(); + + void begin(); + void end(); + bool isPending(); + void wait(); + unsigned value(); + size_t texturesUploaded(); + void markAsNonBlocking(); + bool isNonBlocking(); + + private: + explicit Query(WebKit::WebGraphicsContext3D*); + + WebKit::WebGraphicsContext3D* m_context; + unsigned m_queryId; + unsigned m_value; + bool m_hasValue; + bool m_isNonBlocking; + }; + + ThrottledTextureUploader(WebKit::WebGraphicsContext3D*); + + void beginQuery(); + void endQuery(); + void processQueries(); + + WebKit::WebGraphicsContext3D* m_context; + Deque > m_pendingQueries; + Deque > m_availableQueries; + std::deque m_texturesPerSecondHistory; + size_t m_numBlockingTextureUploads; + + DISALLOW_COPY_AND_ASSIGN(ThrottledTextureUploader); +}; + +} + +#endif diff --git a/cc/CCTileDrawQuad.cpp b/cc/tile_draw_quad.cc similarity index 100% rename from cc/CCTileDrawQuad.cpp rename to cc/tile_draw_quad.cc diff --git a/cc/tile_draw_quad.h b/cc/tile_draw_quad.h index 638cbb270ce9b2..21a98cfb864a41 100644 --- a/cc/tile_draw_quad.h +++ b/cc/tile_draw_quad.h @@ -1,3 +1,54 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCTileDrawQuad_h +#define CCTileDrawQuad_h + +#include "CCDrawQuad.h" +#include "GraphicsTypes3D.h" +#include "IntPoint.h" +#include "IntSize.h" +#include "base/memory/scoped_ptr.h" + +namespace cc { + +#pragma pack(push, 4) + +class CCTileDrawQuad : public CCDrawQuad { +public: + static scoped_ptr create(const CCSharedQuadState*, const IntRect& quadRect, const IntRect& opaqueRect, unsigned resourceId, const IntPoint& textureOffset, const IntSize& textureSize, GC3Dint textureFilter, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA); + + unsigned resourceId() const { return m_resourceId; } + IntPoint textureOffset() const { return m_textureOffset; } + IntSize textureSize() const { return m_textureSize; } + GC3Dint textureFilter() const { return m_textureFilter; } + bool swizzleContents() const { return m_swizzleContents; } + + bool leftEdgeAA() const { return m_leftEdgeAA; } + bool topEdgeAA() const { return m_topEdgeAA; } + bool rightEdgeAA() const { return m_rightEdgeAA; } + bool bottomEdgeAA() const { return m_bottomEdgeAA; } + + bool isAntialiased() const { return leftEdgeAA() || topEdgeAA() || rightEdgeAA() || bottomEdgeAA(); } + + static const CCTileDrawQuad* materialCast(const CCDrawQuad*); +private: + CCTileDrawQuad(const CCSharedQuadState*, const IntRect& quadRect, const IntRect& opaqueRect, unsigned resourceId, const IntPoint& textureOffset, const IntSize& textureSize, GC3Dint textureFilter, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA); + + unsigned m_resourceId; + IntPoint m_textureOffset; + IntSize m_textureSize; + GC3Dint m_textureFilter; + bool m_swizzleContents; + bool m_leftEdgeAA; + bool m_topEdgeAA; + bool m_rightEdgeAA; + bool m_bottomEdgeAA; +}; + +#pragma pack(pop) + +} + +#endif diff --git a/cc/TiledLayerChromium.cpp b/cc/tiled_layer.cc similarity index 100% rename from cc/TiledLayerChromium.cpp rename to cc/tiled_layer.cc diff --git a/cc/tiled_layer.h b/cc/tiled_layer.h index 638cbb270ce9b2..3c273821613c37 100644 --- a/cc/tiled_layer.h +++ b/cc/tiled_layer.h @@ -1,3 +1,105 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef TiledLayerChromium_h +#define TiledLayerChromium_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "CCLayerTilingData.h" +#include "LayerChromium.h" +#include "LayerTextureUpdater.h" + +namespace cc { +class UpdatableTile; + +class TiledLayerChromium : public LayerChromium { +public: + enum TilingOption { AlwaysTile, NeverTile, AutoTile }; + + virtual void setIsMask(bool) OVERRIDE; + + virtual void pushPropertiesTo(CCLayerImpl*) OVERRIDE; + + virtual bool drawsContent() const OVERRIDE; + virtual bool needsContentsScale() const OVERRIDE; + + virtual IntSize contentBounds() const OVERRIDE; + + virtual void setNeedsDisplayRect(const FloatRect&) OVERRIDE; + + virtual void setUseLCDText(bool) OVERRIDE; + + virtual void setLayerTreeHost(CCLayerTreeHost*) OVERRIDE; + + virtual void setTexturePriorities(const CCPriorityCalculator&) OVERRIDE; + + virtual Region visibleContentOpaqueRegion() const OVERRIDE; + + virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) OVERRIDE; + +protected: + TiledLayerChromium(); + virtual ~TiledLayerChromium(); + + void updateTileSizeAndTilingOption(); + void updateBounds(); + + // Exposed to subclasses for testing. + void setTileSize(const IntSize&); + void setTextureFormat(GC3Denum textureFormat) { m_textureFormat = textureFormat; } + void setBorderTexelOption(CCLayerTilingData::BorderTexelOption); + void setSampledTexelFormat(LayerTextureUpdater::SampledTexelFormat sampledTexelFormat) { m_sampledTexelFormat = sampledTexelFormat; } + size_t numPaintedTiles() { return m_tiler->tiles().size(); } + + virtual LayerTextureUpdater* textureUpdater() const = 0; + virtual void createTextureUpdaterIfNeeded() = 0; + + // Set invalidations to be potentially repainted during update(). + void invalidateContentRect(const IntRect& contentRect); + + // Reset state on tiles that will be used for updating the layer. + void resetUpdateState(); + + // After preparing an update, returns true if more painting is needed. + bool needsIdlePaint(); + IntRect idlePaintRect(); + + bool skipsDraw() const { return m_skipsDraw; } + + // Virtual for testing + virtual CCPrioritizedTextureManager* textureManager() const; + +private: + virtual scoped_ptr createCCLayerImpl() OVERRIDE; + + void createTilerIfNeeded(); + void setTilingOption(TilingOption); + + bool tileOnlyNeedsPartialUpdate(UpdatableTile*); + bool tileNeedsBufferedUpdate(UpdatableTile*); + + void markOcclusionsAndRequestTextures(int left, int top, int right, int bottom, const CCOcclusionTracker*); + + bool updateTiles(int left, int top, int right, int bottom, CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&, bool& didPaint); + bool haveTexturesForTiles(int left, int top, int right, int bottom, bool ignoreOcclusions); + IntRect markTilesForUpdate(int left, int top, int right, int bottom, bool ignoreOcclusions); + void updateTileTextures(const IntRect& paintRect, int left, int top, int right, int bottom, CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&); + + UpdatableTile* tileAt(int, int) const; + UpdatableTile* createTile(int, int); + + GC3Denum m_textureFormat; + bool m_skipsDraw; + bool m_failedUpdate; + LayerTextureUpdater::SampledTexelFormat m_sampledTexelFormat; + + TilingOption m_tilingOption; + OwnPtr m_tiler; +}; + +} +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCTiledLayerImpl.cpp b/cc/tiled_layer_impl.cc similarity index 100% rename from cc/CCTiledLayerImpl.cpp rename to cc/tiled_layer_impl.cc diff --git a/cc/tiled_layer_impl.h b/cc/tiled_layer_impl.h index 638cbb270ce9b2..2d6803d512fed1 100644 --- a/cc/tiled_layer_impl.h +++ b/cc/tiled_layer_impl.h @@ -1,3 +1,62 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCTiledLayerImpl_h +#define CCTiledLayerImpl_h + +#include "CCLayerImpl.h" +#include + +namespace cc { + +class CCLayerTilingData; +class DrawableTile; + +class CCTiledLayerImpl : public CCLayerImpl { +public: + static scoped_ptr create(int id) + { + return make_scoped_ptr(new CCTiledLayerImpl(id)); + } + virtual ~CCTiledLayerImpl(); + + virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; + + virtual CCResourceProvider::ResourceId contentsResourceId() const OVERRIDE; + + virtual void dumpLayerProperties(std::string*, int indent) const OVERRIDE; + + void setSkipsDraw(bool skipsDraw) { m_skipsDraw = skipsDraw; } + void setTilingData(const CCLayerTilingData& tiler); + void pushTileProperties(int, int, CCResourceProvider::ResourceId, const IntRect& opaqueRect); + void pushInvalidTile(int, int); + + void setContentsSwizzled(bool contentsSwizzled) { m_contentsSwizzled = contentsSwizzled; } + bool contentsSwizzled() const { return m_contentsSwizzled; } + + virtual Region visibleContentOpaqueRegion() const OVERRIDE; + virtual void didLoseContext() OVERRIDE; + +protected: + explicit CCTiledLayerImpl(int id); + // Exposed for testing. + bool hasTileAt(int, int) const; + bool hasResourceIdForTileAt(int, int) const; + +private: + + virtual const char* layerTypeAsString() const OVERRIDE; + + DrawableTile* tileAt(int, int) const; + DrawableTile* createTile(int, int); + + bool m_skipsDraw; + bool m_contentsSwizzled; + + OwnPtr m_tiler; +}; + +} + +#endif // CCTiledLayerImpl_h diff --git a/cc/time_source.h b/cc/time_source.h index 638cbb270ce9b2..6f24d35522d5f2 100644 --- a/cc/time_source.h +++ b/cc/time_source.h @@ -1,3 +1,40 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCTimeSource_h +#define CCTimeSource_h + +#include "base/time.h" +#include + +namespace cc { + +class CCThread; + +class CCTimeSourceClient { +public: + virtual void onTimerTick() = 0; + +protected: + virtual ~CCTimeSourceClient() { } +}; + +// An generic interface for getting a reliably-ticking timesource of +// a specified rate. +// +// Be sure to call setActive(false) before releasing your reference to the +// timer, or it will keep on ticking! +class CCTimeSource : public RefCounted { +public: + virtual ~CCTimeSource() { } + virtual void setClient(CCTimeSourceClient*) = 0; + virtual void setActive(bool) = 0; + virtual bool active() const = 0; + virtual void setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval) = 0; + virtual base::TimeTicks lastTickTime() = 0; + virtual base::TimeTicks nextTickTime() = 0; +}; + +} +#endif // CCSmoothedTimer_h diff --git a/cc/CCTimer.cpp b/cc/timer.cc similarity index 100% rename from cc/CCTimer.cpp rename to cc/timer.cc diff --git a/cc/timer.h b/cc/timer.h index 638cbb270ce9b2..9424aef99d48eb 100644 --- a/cc/timer.h +++ b/cc/timer.h @@ -1,3 +1,41 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCTimer_h +#define CCTimer_h + +namespace cc { + +class CCThread; +class CCTimerTask; + +class CCTimerClient { +public: + virtual ~CCTimerClient() { } + + virtual void onTimerFired() = 0; +}; + +class CCTimer { +public: + CCTimer(CCThread*, CCTimerClient*); + ~CCTimer(); + + // If a previous task is pending, it will be replaced with the new one. + void startOneShot(double intervalSeconds); + void stop(); + + bool isActive() const { return m_task; } + +private: + friend class CCTimerTask; + + CCTimerClient* m_client; + CCThread* m_thread; + CCTimerTask* m_task; // weak pointer +}; + +} // namespace cc + +#endif diff --git a/cc/CCTimingFunction.cpp b/cc/timing_function.cc similarity index 100% rename from cc/CCTimingFunction.cpp rename to cc/timing_function.cc diff --git a/cc/timing_function.h b/cc/timing_function.h index 638cbb270ce9b2..993ab872b5bb2a 100644 --- a/cc/timing_function.h +++ b/cc/timing_function.h @@ -1,3 +1,62 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCTimingFunction_h +#define CCTimingFunction_h + +#include "CCAnimationCurve.h" +#include "UnitBezier.h" + +namespace cc { + +// See http://www.w3.org/TR/css3-transitions/. +class CCTimingFunction : public CCFloatAnimationCurve { +public: + virtual ~CCTimingFunction(); + + // Partial implementation of CCFloatAnimationCurve. + virtual double duration() const OVERRIDE; + +protected: + CCTimingFunction(); +}; + +class CCCubicBezierTimingFunction : public CCTimingFunction { +public: + static scoped_ptr create(double x1, double y1, double x2, double y2); + virtual ~CCCubicBezierTimingFunction(); + + // Partial implementation of CCFloatAnimationCurve. + virtual float getValue(double time) const OVERRIDE; + virtual scoped_ptr clone() const OVERRIDE; + +protected: + CCCubicBezierTimingFunction(double x1, double y1, double x2, double y2); + + UnitBezier m_curve; +}; + +class CCEaseTimingFunction { +public: + static scoped_ptr create(); +}; + +class CCEaseInTimingFunction { +public: + static scoped_ptr create(); +}; + +class CCEaseOutTimingFunction { +public: + static scoped_ptr create(); +}; + +class CCEaseInOutTimingFunction { +public: + static scoped_ptr create(); +}; + +} // namespace cc + +#endif // CCTimingFunction_h diff --git a/cc/TreeSynchronizer.cpp b/cc/tree_synchronizer.cc similarity index 100% rename from cc/TreeSynchronizer.cpp rename to cc/tree_synchronizer.cc diff --git a/cc/tree_synchronizer.h b/cc/tree_synchronizer.h index 638cbb270ce9b2..26098411b94294 100644 --- a/cc/tree_synchronizer.h +++ b/cc/tree_synchronizer.h @@ -1,3 +1,41 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef TreeSynchronizer_h +#define TreeSynchronizer_h + +#include "base/basictypes.h" +#include "base/memory/scoped_ptr.h" +#include "cc/scoped_ptr_hash_map.h" + +namespace cc { + +class CCLayerImpl; +class CCLayerTreeHostImpl; +class LayerChromium; + +class TreeSynchronizer { +public: + // Accepts a LayerChromium tree and returns a reference to a CCLayerImpl tree that duplicates the structure + // of the LayerChromium tree, reusing the CCLayerImpls in the tree provided by oldCCLayerImplRoot if possible. + static scoped_ptr synchronizeTrees(LayerChromium* layerRoot, scoped_ptr oldCCLayerImplRoot, CCLayerTreeHostImpl*); + +private: + TreeSynchronizer(); // Not instantiable. + + typedef ScopedPtrHashMap ScopedPtrCCLayerImplMap; + typedef base::hash_map RawPtrCCLayerImplMap; + + // Declared as static member functions so they can access functions on LayerChromium as a friend class. + static scoped_ptr reuseOrCreateCCLayerImpl(RawPtrCCLayerImplMap& newLayers, ScopedPtrCCLayerImplMap& oldLayers, LayerChromium*); + static void collectExistingCCLayerImplRecursive(ScopedPtrCCLayerImplMap& oldLayers, scoped_ptr); + static scoped_ptr synchronizeTreeRecursive(RawPtrCCLayerImplMap& newLayers, ScopedPtrCCLayerImplMap& oldLayers, LayerChromium*, CCLayerTreeHostImpl*); + static void updateScrollbarLayerPointersRecursive(const RawPtrCCLayerImplMap& newLayers, LayerChromium*); + + DISALLOW_COPY_AND_ASSIGN(TreeSynchronizer); +}; + +} // namespace cc + +#endif // TreeSynchronizer_h diff --git a/cc/UnthrottledTextureUploader.cpp b/cc/unthrottled_texture_uploader.cc similarity index 100% rename from cc/UnthrottledTextureUploader.cpp rename to cc/unthrottled_texture_uploader.cc diff --git a/cc/unthrottled_texture_uploader.h b/cc/unthrottled_texture_uploader.h index 638cbb270ce9b2..bc0822ace22ea3 100644 --- a/cc/unthrottled_texture_uploader.h +++ b/cc/unthrottled_texture_uploader.h @@ -1,3 +1,36 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef UnthrottledTextureUploader_h +#define UnthrottledTextureUploader_h + +#include "base/basictypes.h" +#include "CCResourceProvider.h" +#include "TextureUploader.h" + +namespace cc { + +class UnthrottledTextureUploader : public TextureUploader { +public: + static PassOwnPtr create() + { + return adoptPtr(new UnthrottledTextureUploader()); + } + virtual ~UnthrottledTextureUploader() { } + + virtual size_t numBlockingUploads() OVERRIDE; + virtual void markPendingUploadsAsNonBlocking() OVERRIDE; + virtual double estimatedTexturesPerSecond() OVERRIDE; + virtual void uploadTexture(CCResourceProvider* resourceProvider, Parameters upload) OVERRIDE; + +protected: + UnthrottledTextureUploader() { } + +private: + DISALLOW_COPY_AND_ASSIGN(UnthrottledTextureUploader); +}; + +} + +#endif diff --git a/cc/VideoLayerChromium.cpp b/cc/video_layer.cc similarity index 100% rename from cc/VideoLayerChromium.cpp rename to cc/video_layer.cc diff --git a/cc/video_layer.h b/cc/video_layer.h index 638cbb270ce9b2..92b5e1383d54ce 100644 --- a/cc/video_layer.h +++ b/cc/video_layer.h @@ -1,3 +1,39 @@ -// Copyright 2012 The Chromium Authors. All rights reserved. +// Copyright 2010 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + + +#ifndef VideoLayerChromium_h +#define VideoLayerChromium_h + +#if USE(ACCELERATED_COMPOSITING) + +#include "LayerChromium.h" + +namespace WebKit { +class WebVideoFrameProvider; +} + +namespace cc { + +class CCVideoLayerImpl; + +// A Layer that contains a Video element. +class VideoLayerChromium : public LayerChromium { +public: + static scoped_refptr create(WebKit::WebVideoFrameProvider*); + + virtual scoped_ptr createCCLayerImpl() OVERRIDE; + +private: + explicit VideoLayerChromium(WebKit::WebVideoFrameProvider*); + virtual ~VideoLayerChromium(); + + // This pointer is only for passing to CCVideoLayerImpl's constructor. It should never be dereferenced by this class. + WebKit::WebVideoFrameProvider* m_provider; +}; + +} +#endif // USE(ACCELERATED_COMPOSITING) + +#endif diff --git a/cc/CCVideoLayerImpl.cpp b/cc/video_layer_impl.cc similarity index 100% rename from cc/CCVideoLayerImpl.cpp rename to cc/video_layer_impl.cc diff --git a/cc/video_layer_impl.h b/cc/video_layer_impl.h index 638cbb270ce9b2..b254e8c50b0d3b 100644 --- a/cc/video_layer_impl.h +++ b/cc/video_layer_impl.h @@ -1,3 +1,89 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCVideoLayerImpl_h +#define CCVideoLayerImpl_h + +#include "CCLayerImpl.h" +#include "GraphicsContext3D.h" +#include "IntSize.h" +#include +#include + +namespace WebKit { +class WebVideoFrame; +} + +namespace cc { + +class CCLayerTreeHostImpl; +class CCVideoLayerImpl; + +class CCVideoLayerImpl : public CCLayerImpl + , public WebKit::WebVideoFrameProvider::Client { +public: + static scoped_ptr create(int id, WebKit::WebVideoFrameProvider* provider) + { + return make_scoped_ptr(new CCVideoLayerImpl(id, provider)); + } + virtual ~CCVideoLayerImpl(); + + virtual void willDraw(CCResourceProvider*) OVERRIDE; + virtual void appendQuads(CCQuadSink&, CCAppendQuadsData&) OVERRIDE; + virtual void didDraw(CCResourceProvider*) OVERRIDE; + + virtual void dumpLayerProperties(std::string*, int indent) const OVERRIDE; + + Mutex& providerMutex() { return m_providerMutex; } + + // WebKit::WebVideoFrameProvider::Client implementation. + virtual void stopUsingProvider(); // Callable on any thread. + virtual void didReceiveFrame(); // Callable on impl thread. + virtual void didUpdateMatrix(const float*); // Callable on impl thread. + + virtual void didLoseContext() OVERRIDE; + + void setNeedsRedraw(); + + struct FramePlane { + CCResourceProvider::ResourceId resourceId; + IntSize size; + GC3Denum format; + IntSize visibleSize; + + FramePlane() : resourceId(0) { } + + bool allocateData(CCResourceProvider*); + void freeData(CCResourceProvider*); + }; + +private: + CCVideoLayerImpl(int, WebKit::WebVideoFrameProvider*); + + static IntSize computeVisibleSize(const WebKit::WebVideoFrame&, unsigned plane); + virtual const char* layerTypeAsString() const OVERRIDE; + + void willDrawInternal(CCResourceProvider*); + bool allocatePlaneData(CCResourceProvider*); + bool copyPlaneData(CCResourceProvider*); + void freePlaneData(CCResourceProvider*); + void freeUnusedPlaneData(CCResourceProvider*); + + // Guards the destruction of m_provider and the frame that it provides + Mutex m_providerMutex; + WebKit::WebVideoFrameProvider* m_provider; + + WebKit::WebTransformationMatrix m_streamTextureMatrix; + + WebKit::WebVideoFrame* m_frame; + GC3Denum m_format; + CCResourceProvider::ResourceId m_externalTextureResource; + + // Each index in this array corresponds to a plane in WebKit::WebVideoFrame. + FramePlane m_framePlanes[WebKit::WebVideoFrame::maxPlanes]; +}; + +} + +#endif // CCVideoLayerImpl_h diff --git a/cc/CCYUVVideoDrawQuad.cpp b/cc/yuv_video_draw_quad.cc similarity index 100% rename from cc/CCYUVVideoDrawQuad.cpp rename to cc/yuv_video_draw_quad.cc diff --git a/cc/yuv_video_draw_quad.h b/cc/yuv_video_draw_quad.h index 638cbb270ce9b2..5d574b7bb9b882 100644 --- a/cc/yuv_video_draw_quad.h +++ b/cc/yuv_video_draw_quad.h @@ -1,3 +1,36 @@ // Copyright 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. + +#ifndef CCYUVVideoDrawQuad_h +#define CCYUVVideoDrawQuad_h + +#include "base/basictypes.h" +#include "base/memory/scoped_ptr.h" +#include "CCDrawQuad.h" +#include "CCVideoLayerImpl.h" + +namespace cc { + +class CCYUVVideoDrawQuad : public CCDrawQuad { +public: + static scoped_ptr create(const CCSharedQuadState*, const IntRect&, const CCVideoLayerImpl::FramePlane& yPlane, const CCVideoLayerImpl::FramePlane& uPlane, const CCVideoLayerImpl::FramePlane& vPlane); + + const CCVideoLayerImpl::FramePlane& yPlane() const { return m_yPlane; } + const CCVideoLayerImpl::FramePlane& uPlane() const { return m_uPlane; } + const CCVideoLayerImpl::FramePlane& vPlane() const { return m_vPlane; } + + static const CCYUVVideoDrawQuad* materialCast(const CCDrawQuad*); +private: + CCYUVVideoDrawQuad(const CCSharedQuadState*, const IntRect&, const CCVideoLayerImpl::FramePlane& yPlane, const CCVideoLayerImpl::FramePlane& uPlane, const CCVideoLayerImpl::FramePlane& vPlane); + + CCVideoLayerImpl::FramePlane m_yPlane; + CCVideoLayerImpl::FramePlane m_uPlane; + CCVideoLayerImpl::FramePlane m_vPlane; + + DISALLOW_COPY_AND_ASSIGN(CCYUVVideoDrawQuad); +}; + +} + +#endif