Split ThreadProxy methods to ProxyMain and ProxyImpl.

cc/test/layer_tree_test.cc

 // 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.
 
 #include "cc/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 163 matching lines @@
   void ScheduledActionInvalidateOutputSurface() override {
     ThreadProxy::ScheduledActionInvalidateOutputSurface();
     test_hooks_->ScheduledActionInvalidateOutputSurface();
   }
 
   void SendBeginMainFrameNotExpectedSoon() override {
     ThreadProxy::SendBeginMainFrameNotExpectedSoon();
     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,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
       scoped_ptr<BeginFrameSource> external_begin_frame_source)
       : ThreadProxy(host, main_task_runner,
                     impl_task_runner,
                     external_begin_frame_source.Pass()),
         test_hooks_(test_hooks) {}
@@ skipping 803 matching lines @@
 LayerTreeHost* LayerTreeTest::layer_tree_host() {
   // We check for a null proxy here as we sometimes ask for the layer tree host
   // when the proxy does not exist, often for checking settings after a test has
   // completed. For example, LTHPixelResourceTest::RunPixelResourceTest. See
   // elsewhere in this file for other examples.
   DCHECK(!proxy() || proxy()->IsMainThread() || proxy()->IsMainThreadBlocked());
   return layer_tree_host_.get();
 }
 
 }  // namespace cc