Make cc a component

cc/layer_tree_host_impl.h

 // 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/memory/scoped_ptr.h"
 #include "base/time.h"
 #include "cc/animation_events.h"
+#include "cc/cc_export.h"
 #include "cc/input_handler.h"
 #include "cc/layer_sorter.h"
 #include "cc/render_pass.h"
 #include "cc/render_pass_sink.h"
 #include "cc/renderer.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/rect.h"
 #include <public/WebCompositorOutputSurfaceClient.h>
 
 namespace cc {
@@ skipping 70 matching lines @@
     float m_pageScaleDelta;
     float m_sentPageScaleDelta;
     float m_maxPageScaleFactor;
     float m_minPageScaleFactor;
 
     FloatPoint m_pinchViewportScrollDelta;
     gfx::SizeF m_layoutViewportSize;
 };
 
 // LayerTreeHostImpl owns the LayerImpl tree as well as associated rendering state
-class LayerTreeHostImpl : public InputHandlerClient,
-                            public RendererClient,
-                            public WebKit::WebCompositorOutputSurfaceClient {
+class CC_EXPORT LayerTreeHostImpl : public InputHandlerClient,
+                                    public RendererClient,
+                                    public NON_EXPORTED_BASE(WebKit::WebCompositorOutputSurfaceClient) {
     typedef std::vector<LayerImpl*> LayerList;
 
 public:
     static scoped_ptr<LayerTreeHostImpl> create(const LayerTreeSettings&, LayerTreeHostImplClient*);
     virtual ~LayerTreeHostImpl();
 
     // InputHandlerClient implementation
     virtual InputHandlerClient::ScrollStatus scrollBegin(const gfx::Point&, InputHandlerClient::ScrollInputType) OVERRIDE;
     virtual void scrollBy(const gfx::Point&, 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, base::TimeTicks startTime, base::TimeDelta duration) OVERRIDE;
     virtual void scheduleAnimation() OVERRIDE;
 
-    struct FrameData : public RenderPassSink {
+    struct CC_EXPORT FrameData : public RenderPassSink {
         FrameData();
         ~FrameData();
 
         std::vector<gfx::Rect> occludingScreenSpaceRects;
         RenderPassList renderPasses;
         RenderPassIdHashMap renderPassesById;
         LayerList* renderSurfaceLayerList;
         LayerList willDrawLayers;
 
         // RenderPassSink implementation.
@@ skipping 93 matching lines @@
     void setNeedsRedraw();
 
     void renderingStats(RenderingStats*) const;
 
     void updateRootScrollLayerImplTransform();
 
     FrameRateCounter* fpsCounter() const { return m_fpsCounter.get(); }
     DebugRectHistory* debugRectHistory() const { return m_debugRectHistory.get(); }
     ResourceProvider* resourceProvider() const { return m_resourceProvider.get(); }
 
-    class CullRenderPassesWithCachedTextures {
+    class CC_EXPORT CullRenderPassesWithCachedTextures {
     public:
         bool shouldRemoveRenderPass(const RenderPassDrawQuad&, 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 RenderPassList& list) const { return list.size() - 1; }
         size_t renderPassListEnd(const RenderPassList&) const { return 0 - 1; }
         size_t renderPassListNext(size_t it) const { return it - 1; }
 
         CullRenderPassesWithCachedTextures(Renderer& renderer) : m_renderer(renderer) { }
     private:
         Renderer& m_renderer;
     };
 
-    class CullRenderPassesWithNoQuads {
+    class CC_EXPORT CullRenderPassesWithNoQuads {
     public:
         bool shouldRemoveRenderPass(const RenderPassDrawQuad&, 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 RenderPassList&) const { return 0; }
         size_t renderPassListEnd(const RenderPassList& list) const { return list.size(); }
         size_t renderPassListNext(size_t it) const { return it + 1; }
     };
 
@@ skipping 87 matching lines @@
 
     size_t m_numImplThreadScrolls;
     size_t m_numMainThreadScrolls;
 
     DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
 };
 
 }  // namespace cc
 
 #endif