A speculative Revert for r165872 - Remove static thread pointers from CC, attempt 2

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 CC_LAYER_TREE_HOST_IMPL_H_
 #define CC_LAYER_TREE_HOST_IMPL_H_
 
 #include "FloatPoint.h"
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 89 matching lines @@
     gfx::SizeF m_layoutViewportSize;
 };
 
 // LayerTreeHostImpl owns the LayerImpl tree as well as associated rendering state
 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*, Proxy*);
+    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;
@@ skipping 28 matching lines @@
     void didDrawAllLayers(const FrameData&);
 
     // RendererClient implementation
     virtual const gfx::Size& deviceViewportSize() const OVERRIDE;
     virtual const LayerTreeSettings& settings() const OVERRIDE;
     virtual void didLoseContext() OVERRIDE;
     virtual void onSwapBuffersComplete() OVERRIDE;
     virtual void setFullRootLayerDamage() OVERRIDE;
     virtual void setManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
     virtual void enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
-    virtual bool hasImplThread() const OVERRIDE;
 
     // WebCompositorOutputSurfaceClient implementation.
     virtual void onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds) OVERRIDE;
 
     // Implementation
     bool canDraw();
     GraphicsContext* context() const;
 
     std::string layerTreeAsText() const;
 
@@ skipping 57 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(); }
-    Proxy* proxy() const { return m_proxy; }
 
     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; }
@@ skipping 12 matching lines @@
         // 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; }
     };
 
     template<typename RenderPassCuller>
     static void removeRenderPasses(RenderPassCuller, FrameData&);
 
 protected:
-    LayerTreeHostImpl(const LayerTreeSettings&, LayerTreeHostImplClient*, Proxy*);
+    LayerTreeHostImpl(const LayerTreeSettings&, LayerTreeHostImplClient*);
 
     void animatePageScale(base::TimeTicks monotonicTime);
     void animateScrollbars(base::TimeTicks monotonicTime);
 
     // Exposed for testing.
     void calculateRenderSurfaceLayerList(LayerList&);
 
     // Virtual for testing.
     virtual void animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime);
 
     // Virtual for testing.
     virtual base::TimeDelta lowFrequencyAnimationInterval() const;
 
     LayerTreeHostImplClient* m_client;
-    Proxy* m_proxy;
     int m_sourceFrameNumber;
 
 private:
     void computeDoubleTapZoomDeltas(ScrollAndScaleSet* scrollInfo);
     void computePinchZoomDeltas(ScrollAndScaleSet* scrollInfo);
     void makeScrollAndScaleSet(ScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale);
 
     void setPageScaleDelta(float);
     void updateMaxScrollPosition();
     void trackDamageForAllSurfaces(LayerImpl* rootDrawLayer, const LayerList& renderSurfaceLayerList);
@@ skipping 58 matching lines @@
 
     size_t m_numImplThreadScrolls;
     size_t m_numMainThreadScrolls;
 
     DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYER_TREE_HOST_IMPL_H_