cc: Split ThreadProxy into ProxyMain and ProxyImpl

cc/trees/layer_tree_host_unittest_proxy.cc

 // Copyright 2014 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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_picture_layer.h"
 #include "cc/test/layer_tree_test.h"
-#include "cc/trees/thread_proxy.h"
+#include "cc/trees/proxy_impl.h"
+#include "cc/trees/proxy_main.h"
 
-#define THREAD_PROXY_TEST_F(TEST_FIXTURE_NAME) \
+#define PROXY_MAIN_THREADED_TEST_F(TEST_FIXTURE_NAME) \
   TEST_F(TEST_FIXTURE_NAME, MultiThread) { Run(true); }
 
-// Do common tests for single thread proxy and thread proxy.
+// Do common tests for single thread proxy and proxy main in threaded mode.
 // TODO(simonhong): Add SINGLE_THREAD_PROXY_TEST_F
 #define PROXY_TEST_SCHEDULED_ACTION(TEST_FIXTURE_NAME) \
-  THREAD_PROXY_TEST_F(TEST_FIXTURE_NAME);
+  PROXY_MAIN_THREADED_TEST_F(TEST_FIXTURE_NAME);
 
 namespace cc {
 
 class ProxyTest : public LayerTreeTest {
  protected:
   ProxyTest() {}
   ~ProxyTest() override {}
 
   void Run(bool threaded) {
     // We don't need to care about delegating mode.
@@ skipping 35 matching lines @@
   ~ProxyTestScheduledActionsBasic() override {}
 
  private:
   int action_phase_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyTestScheduledActionsBasic);
 };
 
 PROXY_TEST_SCHEDULED_ACTION(ProxyTestScheduledActionsBasic);
 
-class ThreadProxyTest : public ProxyTest {
+class ProxyMainThreaded : public ProxyTest {
  protected:
-  ThreadProxyTest()
+  ProxyMainThreaded()
       : update_check_layer_(
             FakePictureLayer::Create(layer_settings(), &client_)) {}
-  ~ThreadProxyTest() override {}
+  ~ProxyMainThreaded() override {}
 
   void SetupTree() override {
     layer_tree_host()->SetRootLayer(update_check_layer_);
     ProxyTest::SetupTree();
   }
 
-  const ThreadProxy::MainThreadOnly& ThreadProxyMainOnly() const {
-    DCHECK(proxy());
-    DCHECK(proxy()->HasImplThread());
-    return static_cast<const ThreadProxy*>(proxy())->main();
-  }
-
-  const ThreadProxy::CompositorThreadOnly& ThreadProxyImplOnly() const {
-    DCHECK(proxy());
-    DCHECK(proxy()->HasImplThread());
-    return static_cast<const ThreadProxy*>(proxy())->impl();
-  }
-
  protected:
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> update_check_layer_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ThreadProxyTest);
+  DISALLOW_COPY_AND_ASSIGN(ProxyMainThreaded);
 };
 
-class ThreadProxyTestSetNeedsCommit : public ThreadProxyTest {
+class ProxyMainThreadedSetNeedsCommit : public ProxyMainThreaded {
  protected:
-  ThreadProxyTestSetNeedsCommit() {}
-  ~ThreadProxyTestSetNeedsCommit() override {}
+  ProxyMainThreadedSetNeedsCommit() {}
+  ~ProxyMainThreadedSetNeedsCommit() override {}
 
   void BeginTest() override {
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
 
     proxy()->SetNeedsCommit();
 
-    EXPECT_EQ(ThreadProxy::COMMIT_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
+    EXPECT_EQ(ProxyMain::COMMIT_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
   }
 
   void DidBeginMainFrame() override {
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().current_pipeline_stage);
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->current_pipeline_stage());
   }
 
   void DidCommit() override {
     EXPECT_EQ(1, update_check_layer_->update_count());
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().current_pipeline_stage);
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->current_pipeline_stage());
     EndTest();
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ThreadProxyTestSetNeedsCommit);
+  DISALLOW_COPY_AND_ASSIGN(ProxyMainThreadedSetNeedsCommit);
 };
 
-THREAD_PROXY_TEST_F(ThreadProxyTestSetNeedsCommit);
+PROXY_MAIN_THREADED_TEST_F(ProxyMainThreadedSetNeedsCommit);
 
-class ThreadProxyTestSetNeedsAnimate : public ThreadProxyTest {
+class ProxyMainThreadedSetNeedsAnimate : public ProxyMainThreaded {
  protected:
-  ThreadProxyTestSetNeedsAnimate() {}
-  ~ThreadProxyTestSetNeedsAnimate() override {}
+  ProxyMainThreadedSetNeedsAnimate() {}
+  ~ProxyMainThreadedSetNeedsAnimate() override {}
 
   void BeginTest() override {
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
 
     proxy()->SetNeedsAnimate();
 
-    EXPECT_EQ(ThreadProxy::ANIMATE_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
+    EXPECT_EQ(ProxyMain::ANIMATE_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
   }
 
   void DidBeginMainFrame() override {
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().current_pipeline_stage);
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->current_pipeline_stage());
   }
 
   void DidCommit() override {
     EXPECT_EQ(0, update_check_layer_->update_count());
     EndTest();
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ThreadProxyTestSetNeedsAnimate);
+  DISALLOW_COPY_AND_ASSIGN(ProxyMainThreadedSetNeedsAnimate);
 };
 
-THREAD_PROXY_TEST_F(ThreadProxyTestSetNeedsAnimate);
+PROXY_MAIN_THREADED_TEST_F(ProxyMainThreadedSetNeedsAnimate);
 
-class ThreadProxyTestSetNeedsUpdateLayers : public ThreadProxyTest {
+class ProxyMainThreadedSetNeedsUpdateLayers : public ProxyMainThreaded {
  protected:
-  ThreadProxyTestSetNeedsUpdateLayers() {}
-  ~ThreadProxyTestSetNeedsUpdateLayers() override {}
+  ProxyMainThreadedSetNeedsUpdateLayers() {}
+  ~ProxyMainThreadedSetNeedsUpdateLayers() override {}
 
   void BeginTest() override {
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
 
     proxy()->SetNeedsUpdateLayers();
 
-    EXPECT_EQ(ThreadProxy::UPDATE_LAYERS_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
+    EXPECT_EQ(ProxyMain::UPDATE_LAYERS_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
   }
 
   void DidBeginMainFrame() override {
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().current_pipeline_stage);
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->current_pipeline_stage());
   }
 
   void DidCommit() override {
     EXPECT_EQ(1, update_check_layer_->update_count());
     EndTest();
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ThreadProxyTestSetNeedsUpdateLayers);
+  DISALLOW_COPY_AND_ASSIGN(ProxyMainThreadedSetNeedsUpdateLayers);
 };
 
-THREAD_PROXY_TEST_F(ThreadProxyTestSetNeedsUpdateLayers);
+PROXY_MAIN_THREADED_TEST_F(ProxyMainThreadedSetNeedsUpdateLayers);
 
-class ThreadProxyTestSetNeedsUpdateLayersWhileAnimating
-    : public ThreadProxyTest {
+class ProxyMainThreadedSetNeedsUpdateLayersWhileAnimating
+    : public ProxyMainThreaded {
  protected:
-  ThreadProxyTestSetNeedsUpdateLayersWhileAnimating() {}
-  ~ThreadProxyTestSetNeedsUpdateLayersWhileAnimating() override {}
+  ProxyMainThreadedSetNeedsUpdateLayersWhileAnimating() {}
+  ~ProxyMainThreadedSetNeedsUpdateLayersWhileAnimating() override {}
 
   void BeginTest() override { proxy()->SetNeedsAnimate(); }
 
   void WillBeginMainFrame() override {
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
-    EXPECT_EQ(ThreadProxy::ANIMATE_PIPELINE_STAGE,
-              ThreadProxyMainOnly().current_pipeline_stage);
-    EXPECT_EQ(ThreadProxy::ANIMATE_PIPELINE_STAGE,
-              ThreadProxyMainOnly().final_pipeline_stage);
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
+    EXPECT_EQ(ProxyMain::ANIMATE_PIPELINE_STAGE,
+              GetProxyMain()->current_pipeline_stage());
+    EXPECT_EQ(ProxyMain::ANIMATE_PIPELINE_STAGE,
+              GetProxyMain()->final_pipeline_stage());
 
     proxy()->SetNeedsUpdateLayers();
 
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
-    EXPECT_EQ(ThreadProxy::UPDATE_LAYERS_PIPELINE_STAGE,
-              ThreadProxyMainOnly().final_pipeline_stage);
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
+    EXPECT_EQ(ProxyMain::UPDATE_LAYERS_PIPELINE_STAGE,
+              GetProxyMain()->final_pipeline_stage());
   }
 
   void DidBeginMainFrame() override {
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().current_pipeline_stage);
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->current_pipeline_stage());
   }
 
   void DidCommit() override {
     EXPECT_EQ(1, update_check_layer_->update_count());
     EndTest();
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ThreadProxyTestSetNeedsUpdateLayersWhileAnimating);
+  DISALLOW_COPY_AND_ASSIGN(ProxyMainThreadedSetNeedsUpdateLayersWhileAnimating);
 };
 
-THREAD_PROXY_TEST_F(ThreadProxyTestSetNeedsUpdateLayersWhileAnimating);
+PROXY_MAIN_THREADED_TEST_F(ProxyMainThreadedSetNeedsUpdateLayersWhileAnimating);
 
-class ThreadProxyTestSetNeedsCommitWhileAnimating : public ThreadProxyTest {
+class ProxyMainThreadedSetNeedsCommitWhileAnimating : public ProxyMainThreaded {
  protected:
-  ThreadProxyTestSetNeedsCommitWhileAnimating() {}
-  ~ThreadProxyTestSetNeedsCommitWhileAnimating() override {}
+  ProxyMainThreadedSetNeedsCommitWhileAnimating() {}
+  ~ProxyMainThreadedSetNeedsCommitWhileAnimating() override {}
 
   void BeginTest() override { proxy()->SetNeedsAnimate(); }
 
   void WillBeginMainFrame() override {
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
-    EXPECT_EQ(ThreadProxy::ANIMATE_PIPELINE_STAGE,
-              ThreadProxyMainOnly().current_pipeline_stage);
-    EXPECT_EQ(ThreadProxy::ANIMATE_PIPELINE_STAGE,
-              ThreadProxyMainOnly().final_pipeline_stage);
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
+    EXPECT_EQ(ProxyMain::ANIMATE_PIPELINE_STAGE,
+              GetProxyMain()->current_pipeline_stage());
+    EXPECT_EQ(ProxyMain::ANIMATE_PIPELINE_STAGE,
+              GetProxyMain()->final_pipeline_stage());
 
     proxy()->SetNeedsCommit();
 
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
-    EXPECT_EQ(ThreadProxy::COMMIT_PIPELINE_STAGE,
-              ThreadProxyMainOnly().final_pipeline_stage);
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
+    EXPECT_EQ(ProxyMain::COMMIT_PIPELINE_STAGE,
+              GetProxyMain()->final_pipeline_stage());
   }
 
   void DidBeginMainFrame() override {
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().max_requested_pipeline_stage);
-    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
-              ThreadProxyMainOnly().current_pipeline_stage);
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->max_requested_pipeline_stage());
+    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
+              GetProxyMain()->current_pipeline_stage());
   }
 
   void DidCommit() override {
     EXPECT_EQ(1, update_check_layer_->update_count());
     EndTest();
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ThreadProxyTestSetNeedsCommitWhileAnimating);
+  DISALLOW_COPY_AND_ASSIGN(ProxyMainThreadedSetNeedsCommitWhileAnimating);
 };
 
-THREAD_PROXY_TEST_F(ThreadProxyTestSetNeedsCommitWhileAnimating);
+PROXY_MAIN_THREADED_TEST_F(ProxyMainThreadedSetNeedsCommitWhileAnimating);
 
-class ThreadProxyTestCommitWaitsForActivation : public ThreadProxyTest {
+class ProxyMainThreadedCommitWaitsForActivation : public ProxyMainThreaded {
  protected:
-  ThreadProxyTestCommitWaitsForActivation() : commits_completed_(0) {}
-  ~ThreadProxyTestCommitWaitsForActivation() override {}
+  ProxyMainThreadedCommitWaitsForActivation() : commits_completed_(0) {}
+  ~ProxyMainThreadedCommitWaitsForActivation() override {}
 
   void BeginTest() override { proxy()->SetNeedsCommit(); }
 
   void ScheduledActionCommit() override {
     switch (commits_completed_) {
       case 0:
         // The first commit does not wait for activation. Verify that the
         // completion event is cleared.
-        EXPECT_FALSE(ThreadProxyImplOnly().commit_completion_event);
-        EXPECT_FALSE(ThreadProxyImplOnly().next_commit_waits_for_activation);
+        EXPECT_FALSE(GetProxyImpl()->HasCommitCompletionEvent());
+        EXPECT_FALSE(GetProxyImpl()->next_commit_waits_for_activation());
         break;
       case 1:
         // The second commit should be held until activation.
-        EXPECT_TRUE(ThreadProxyImplOnly().commit_completion_event);
-        EXPECT_TRUE(ThreadProxyImplOnly().next_commit_waits_for_activation);
+        EXPECT_TRUE(GetProxyImpl()->HasCommitCompletionEvent());
+        EXPECT_TRUE(GetProxyImpl()->next_commit_waits_for_activation());
         break;
       case 2:
         // The third commit should not wait for activation.
-        EXPECT_FALSE(ThreadProxyImplOnly().commit_completion_event);
-        EXPECT_FALSE(ThreadProxyImplOnly().next_commit_waits_for_activation);
+        EXPECT_FALSE(GetProxyImpl()->HasCommitCompletionEvent());
+        EXPECT_FALSE(GetProxyImpl()->next_commit_waits_for_activation());
     }
   }
 
   void DidActivateSyncTree() override {
     // The next_commit_waits_for_activation should have been cleared after the
     // sync tree is activated.
-    EXPECT_FALSE(ThreadProxyImplOnly().next_commit_waits_for_activation);
+    EXPECT_FALSE(GetProxyImpl()->next_commit_waits_for_activation());
   }
 
   void DidCommit() override {
     switch (commits_completed_) {
       case 0:
         // The first commit has been completed. Set next commit waits for
         // activation and start another commit.
         commits_completed_++;
         proxy()->SetNextCommitWaitsForActivation();
         proxy()->SetNeedsCommit();
       case 1:
         // Start another commit to verify that this is not held until
         // activation.
         commits_completed_++;
         proxy()->SetNeedsCommit();
       case 2:
         commits_completed_++;
         EndTest();
     }
   }
 
   void AfterTest() override { EXPECT_EQ(3, commits_completed_); }
 
  private:
   int commits_completed_;
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadProxyTestCommitWaitsForActivation);
+  DISALLOW_COPY_AND_ASSIGN(ProxyMainThreadedCommitWaitsForActivation);
 };
 
-THREAD_PROXY_TEST_F(ThreadProxyTestCommitWaitsForActivation);
+PROXY_MAIN_THREADED_TEST_F(ProxyMainThreadedCommitWaitsForActivation);
 
 }  // namespace cc