cc: Split ThreadProxy into ProxyMain and ProxyImpl

cc/trees/threaded_channel_unittest.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// Copyright 2015 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/trees/threaded_channel.h"
 
 #include "cc/test/layer_tree_test.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 
 // The ThreadedChannel tests are run only for threaded and direct mode.
 class ThreadedChannelTest : public LayerTreeTest {
  protected:
-  ThreadedChannelTest() : thread_proxy_(nullptr), calls_received_(0) {}
+  ThreadedChannelTest() : calls_received_(0) {}
 
   ~ThreadedChannelTest() override {}
 
   void BeginTest() override {
     DCHECK(HasImplThread());
-    thread_proxy_ = static_cast<ThreadProxy*>(proxy());
     BeginChannelTest();
   };
   virtual void BeginChannelTest() {}
 
   void PostOnImplThread() {
     ImplThreadTaskRunner()->PostTask(
         FROM_HERE, base::Bind(&ThreadedChannelTest::StartTestOnImplThread,
                               base::Unretained(this)));
   }
 
   virtual void StartTestOnImplThread() {
     DCHECK(task_runner_provider()->IsImplThread());
   }
 
   void AfterTest() override {}
 
-  // TODO(khushalsagar): Remove this once ProxyImpl is added to the
-  // LayerTreeTest.
-  ThreadProxy* thread_proxy_;
   int calls_received_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ThreadedChannelTest);
 };
 
 class ThreadedChannelTestInitializationAndShutdown
     : public ThreadedChannelTest {
-  void InitializeImplOnImpl() override { calls_received_++; }
-
   void SetVisibleOnImpl(bool visible) override { calls_received_++; }
 
   void ReceivedRequestNewOutputSurface() override { calls_received_++; }
 
   void InitializeOutputSurfaceOnImpl(OutputSurface* output_surface) override {
     calls_received_++;
   }
 
   void ReceivedSetRendererCapabilitiesMainCopy(
       const RendererCapabilities& capabilities) override {
     calls_received_++;
   }
 
   void ReceivedDidInitializeOutputSurface(
       bool success,
       const RendererCapabilities& capabilities) override {
     calls_received_++;
     EndTest();
   }
 
-  void WillCloseLayerTreeHostOnImpl() override { calls_received_++; }
   void FinishGLOnImpl() override { calls_received_++; }
 
-  void AfterTest() override { EXPECT_EQ(8, calls_received_); }
+  void AfterTest() override { EXPECT_EQ(6, calls_received_); }
 };
 
 MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     ThreadedChannelTestInitializationAndShutdown);
 
 class ThreadedChannelTestThrottleFrameProduction : public ThreadedChannelTest {
   void BeginChannelTest() override {
     proxy()->SetThrottleFrameProduction(true);
   }
 
@@ skipping 153 matching lines @@
   void AfterTest() override { EXPECT_EQ(1, calls_received_); }
 };
 
 MULTI_THREAD_DIRECT_RENDERER_TEST_F(ThreadedChannelTestBeginMainFrameAborted);
 
 class ThreadedChannelTestBeginMainFrameNotExpectedSoon
     : public ThreadedChannelTest {
   void BeginChannelTest() override { PostOnImplThread(); }
 
   void StartTestOnImplThread() override {
-    thread_proxy_->SendBeginMainFrameNotExpectedSoon();
+    GetProxyImpl()->SendBeginMainFrameNotExpectedSoon();
   }
 
   void ReceivedBeginMainFrameNotExpectedSoon() override {
     calls_received_++;
     EndTest();
   }
 
   void AfterTest() override { EXPECT_EQ(1, calls_received_); }
 };
 
 MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     ThreadedChannelTestBeginMainFrameNotExpectedSoon);
 
 class ThreadedChannelTestSetAnimationEvents : public ThreadedChannelTest {
   void BeginChannelTest() override { PostOnImplThread(); }
 
   void StartTestOnImplThread() override {
     scoped_ptr<AnimationEventsVector> events(
         make_scoped_ptr(new AnimationEventsVector));
-    thread_proxy_->PostAnimationEventsToMainThreadOnImplThread(
+    GetProxyImpl()->PostAnimationEventsToMainThreadOnImplThread(
         std::move(events));
   }
 
   void ReceivedSetAnimationEvents() override {
     calls_received_++;
     EndTest();
   }
 
   void AfterTest() override { EXPECT_EQ(1, calls_received_); }
 };
 
 MULTI_THREAD_DIRECT_RENDERER_TEST_F(ThreadedChannelTestSetAnimationEvents);
 
 class ThreadedChannelTestLoseOutputSurface : public ThreadedChannelTest {
   void BeginChannelTest() override { PostOnImplThread(); }
 
   void StartTestOnImplThread() override {
-    thread_proxy_->DidLoseOutputSurfaceOnImplThread();
+    GetProxyImpl()->DidLoseOutputSurfaceOnImplThread();
   }
 
   void ReceivedDidLoseOutputSurface() override {
     calls_received_++;
     EndTest();
   }
 
   void AfterTest() override { EXPECT_EQ(1, calls_received_); }
 };
 
 MULTI_THREAD_DIRECT_RENDERER_TEST_F(ThreadedChannelTestLoseOutputSurface);
 
 class ThreadedChannelTestPageScaleAnimation : public ThreadedChannelTest {
   void BeginChannelTest() override { PostOnImplThread(); }
 
   void StartTestOnImplThread() override {
-    thread_proxy_->DidCompletePageScaleAnimationOnImplThread();
+    GetProxyImpl()->DidCompletePageScaleAnimationOnImplThread();
   }
 
   void ReceivedDidCompletePageScaleAnimation() override {
     calls_received_++;
     EndTest();
   }
 
   void AfterTest() override { EXPECT_EQ(1, calls_received_); }
 };
 
 MULTI_THREAD_DIRECT_RENDERER_TEST_F(ThreadedChannelTestPageScaleAnimation);
 
 }  // namespace cc