Introduce separate client and init path for single-threaded cc

cc/trees/single_thread_proxy.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_TREES_SINGLE_THREAD_PROXY_H_
 #define CC_TREES_SINGLE_THREAD_PROXY_H_
 
 #include <limits>
 
 #include "base/time/time.h"
 #include "cc/animation/animation_events.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/proxy.h"
 
 namespace cc {
 
 class ContextProvider;
 class LayerTreeHost;
+class LayerTreeHostSingleThreadClient;
 
 class SingleThreadProxy : public Proxy, LayerTreeHostImplClient {
  public:
-  static scoped_ptr<Proxy> Create(LayerTreeHost* layer_tree_host);
+  static scoped_ptr<Proxy> Create(
+      LayerTreeHost* layer_tree_host,
+      LayerTreeHostSingleThreadClient* client);
   virtual ~SingleThreadProxy();
 
   // Proxy implementation
   virtual bool CompositeAndReadback(void* pixels, gfx::Rect rect) OVERRIDE;
   virtual void FinishAllRendering() OVERRIDE;
   virtual bool IsStarted() const OVERRIDE;
   virtual void SetLayerTreeHostClientReady() OVERRIDE;
   virtual void SetVisible(bool visible) OVERRIDE;
   virtual void CreateAndInitializeOutputSurface() OVERRIDE;
   virtual const RendererCapabilities& GetRendererCapabilities() const OVERRIDE;
@@ skipping 38 matching lines @@
   virtual void RenewTreePriority() OVERRIDE {}
   virtual void RequestScrollbarAnimationOnImplThread(base::TimeDelta delay)
       OVERRIDE {}
   virtual void DidActivatePendingTree() OVERRIDE {}
   virtual void DidManageTiles() OVERRIDE {}
 
   // Called by the legacy path where RenderWidget does the scheduling.
   void CompositeImmediately(base::TimeTicks frame_begin_time);
 
  private:
-  explicit SingleThreadProxy(LayerTreeHost* layer_tree_host);
+  SingleThreadProxy(LayerTreeHost* layer_tree_host,
+                    LayerTreeHostSingleThreadClient* client);
 
   void OnOutputSurfaceInitializeAttempted(bool success);
   bool CommitAndComposite(base::TimeTicks frame_begin_time,
                           gfx::Rect device_viewport_damage_rect,
                           bool for_readback,
                           LayerTreeHostImpl::FrameData* frame);
   void DoCommit(scoped_ptr<ResourceUpdateQueue> queue);
   bool DoComposite(
       scoped_refptr<cc::ContextProvider> offscreen_context_provider,
       base::TimeTicks frame_begin_time,
       gfx::Rect device_viewport_damage_rect,
       bool for_readback,
       LayerTreeHostImpl::FrameData* frame);
   void DidSwapFrame();
 
   bool ShouldComposite() const;
   void UpdateBackgroundAnimateTicking();
 
   // Accessed on main thread only.
   LayerTreeHost* layer_tree_host_;
+  LayerTreeHostSingleThreadClient* client_;
   bool created_offscreen_context_provider_;
 
   // Holds the first output surface passed from Start. Should not be used for
   // anything else.
   scoped_ptr<OutputSurface> first_output_surface_;
 
   // Used on the Thread, but checked on main thread during
   // initialization/shutdown.
   scoped_ptr<LayerTreeHostImpl> layer_tree_host_impl_;
   RendererCapabilities renderer_capabilities_for_main_thread_;
@@ skipping 62 matching lines @@
  private:
   DebugScopedSetImplThread impl_thread_;
   DebugScopedSetMainThreadBlocked main_thread_blocked_;
 
   DISALLOW_COPY_AND_ASSIGN(DebugScopedSetImplThreadAndMainThreadBlocked);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_SINGLE_THREAD_PROXY_H_