Split ThreadProxy methods to ProxyMain and ProxyImpl.

cc/test/layer_tree_test.cc

Index: cc/test/layer_tree_test.cc
diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index 86ba7c16e5415076c349a824fef0cab6b214a7cd..169a0e050ed6413620188a1a337641923c75c444 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -181,6 +181,141 @@ class ThreadProxyForTest : public ThreadProxy {
     test_hooks_->SendBeginMainFrameNotExpectedSoon();
   }
 
+  void SetThrottleFrameProductionOnImpl(bool throttle) override {
+    ThreadProxy::SetThrottleFrameProductionOnImpl(throttle);
+    test_hooks_->SetThrottleFrameProductionOnImpl(throttle);
+  }
+
+  void InitializeOutputSurfaceOnImpl(OutputSurface* output_surface) override {
+    ThreadProxy::InitializeOutputSurfaceOnImpl(output_surface);
+    test_hooks_->InitializeOutputSurfaceOnImpl(output_surface);
+  }
+
+  void MainThreadHasStoppedFlingingOnImpl() override {
+    ThreadProxy::MainThreadHasStoppedFlingingOnImpl();
+    test_hooks_->MainThreadHasStoppedFlingingOnImpl();
+  }
+
+  void SetInputThrottledUntilCommitOnImpl(bool is_throttled) override {
+    ThreadProxy::SetInputThrottledUntilCommitOnImpl(is_throttled);
+    test_hooks_->SetInputThrottledUntilCommitOnImpl(is_throttled);
+  }
+
+  void UpdateTopControlsStateOnImpl(TopControlsState constraints,
+                                    TopControlsState current,
+                                    bool animate) override {
+    ThreadProxy::UpdateTopControlsStateOnImpl(constraints, current, animate);
+    test_hooks_->UpdateTopControlsStateOnImpl(constraints, current, animate);
+  }
+
+  void SetDeferCommitsOnImpl(bool defer_commits) const override {
+    ThreadProxy::SetDeferCommitsOnImpl(defer_commits);
+    test_hooks_->SetDeferCommitsOnImpl(defer_commits);
+  }
+
+  void BeginMainFrameAbortedOnImpl(CommitEarlyOutReason reason) override {
+    ThreadProxy::BeginMainFrameAbortedOnImpl(reason);
+    test_hooks_->BeginMainFrameAbortedOnImpl(reason);
+  }
+
+  void SetNeedsRedrawOnImpl(const gfx::Rect& damage_rect) override {
+    ThreadProxy::SetNeedsRedrawOnImpl(damage_rect);
+    test_hooks_->SetNeedsRedrawOnImpl(damage_rect);
+  };
+
+  void SetNeedsCommitOnImpl() override {
+    ThreadProxy::SetNeedsCommitOnImpl();
+    test_hooks_->SetNeedsCommitOnImpl();
+  }
+
+  void FinishAllRenderingOnImpl(CompletionEvent* completion) override {
+    ThreadProxy::FinishAllRenderingOnImpl(completion);
+    test_hooks_->FinishAllRenderingOnImpl();
+  };
+
+  void SetVisibleOnImpl(CompletionEvent* completion, bool visible) override {
+    ThreadProxy::SetVisibleOnImpl(completion, visible);
+    test_hooks_->SetVisibleOnImpl(visible);
+  }
+
+  void ReleaseOutputSurfaceOnImpl(CompletionEvent* completion) override {
+    ThreadProxy::ReleaseOutputSurfaceOnImpl(completion);
+    test_hooks_->ReleaseOutputSurfaceOnImpl();
+  }
+
+  void FinishGLOnImpl(CompletionEvent* completion) override {
+    ThreadProxy::FinishGLOnImpl(completion);
+    test_hooks_->FinishGLOnImpl();
+  }
+
+  void StartCommitOnImpl(CompletionEvent* completion) override {
+    ThreadProxy::StartCommitOnImpl(completion);
+    test_hooks_->StartCommitOnImpl();
+  }
+
+  void DidCompleteSwapBuffers() override {
+    ThreadProxy::DidCompleteSwapBuffers();
+    test_hooks_->ReceivedDidCompleteSwapBuffers();
+  }
+
+  void SetRendererCapabilitiesMainCopy(
+      const RendererCapabilities& capabilities) override {
+    ThreadProxy::SetRendererCapabilitiesMainCopy(capabilities);
+    test_hooks_->ReceivedSetRendererCapabilitiesMainCopy(capabilities);
+  }
+
+  void BeginMainFrameNotExpectedSoon() override {
+    ThreadProxy::BeginMainFrameNotExpectedSoon();
+    test_hooks_->ReceivedBeginMainFrameNotExpectedSoon();
+  }
+
+  void DidCommitAndDrawFrame() override {
+    ThreadProxy::DidCommitAndDrawFrame();
+    test_hooks_->ReceivedDidCommitAndDrawFrame();
+  }
+
+  void SetAnimationEvents(scoped_ptr<AnimationEventsVector> events) override {
+    ThreadProxy::SetAnimationEvents(events.Pass());
+    test_hooks_->ReceivedSetAnimationEvents();
+  }
+
+  void DidLoseOutputSurface() override {
+    ThreadProxy::DidLoseOutputSurface();
+    test_hooks_->ReceivedDidLoseOutputSurface();
+  }
+
+  void RequestNewOutputSurface() override {
+    ThreadProxy::RequestNewOutputSurface();
+    test_hooks_->ReceivedRequestNewOutputSurface();
+  }
+
+  void DidInitializeOutputSurface(
+      bool success,
+      const RendererCapabilities& capabilities) override {
+    ThreadProxy::DidInitializeOutputSurface(success, capabilities);
+    test_hooks_->ReceivedDidInitializeOutputSurface(success, capabilities);
+  }
+
+  void DidCompletePageScaleAnimation() override {
+    ThreadProxy::DidCompletePageScaleAnimation();
+    test_hooks_->ReceivedDidCompletePageScaleAnimation();
+  }
+
+  void PostFrameTimingEventsOnMain(
+      scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
+      scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events)
+      override {
+    ThreadProxy::PostFrameTimingEventsOnMain(composite_events.Pass(),
+                                             main_frame_events.Pass());
+    test_hooks_->ReceivedPostFrameTimingEventsOnMain();
+  }
+
+  void BeginMainFrame(scoped_ptr<BeginMainFrameAndCommitState>
+                          begin_main_frame_state) override {
+    ThreadProxy::BeginMainFrame(begin_main_frame_state.Pass());
+    test_hooks_->ReceivedBeginMainFrame();
+  };
+
   ThreadProxyForTest(
       TestHooks* test_hooks,
       LayerTreeHost* host,