[NOT LANDED] Revert of 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/proxy_impl.h"
-#include "cc/trees/proxy_main.h"
+#include "cc/trees/thread_proxy.h"
 
-#define PROXY_MAIN_THREADED_TEST_F(TEST_FIXTURE_NAME) \
+#define THREAD_PROXY_TEST_F(TEST_FIXTURE_NAME) \
   TEST_F(TEST_FIXTURE_NAME, MultiThread) { Run(true); }
 
-// Do common tests for single thread proxy and proxy main in threaded mode.
+// Do common tests for single thread proxy and thread proxy.
 // TODO(simonhong): Add SINGLE_THREAD_PROXY_TEST_F
 #define PROXY_TEST_SCHEDULED_ACTION(TEST_FIXTURE_NAME) \
-  PROXY_MAIN_THREADED_TEST_F(TEST_FIXTURE_NAME);
+  THREAD_PROXY_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 37 matching lines @@
   ~ProxyTestScheduledActionsBasic() override {}
 
  private:
   int action_phase_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyTestScheduledActionsBasic);
 };
 
 PROXY_TEST_SCHEDULED_ACTION(ProxyTestScheduledActionsBasic);
 
-class ProxyMainThreaded : public ProxyTest {
+class ThreadProxyTest : public ProxyTest {
  protected:
-  ProxyMainThreaded()
+  ThreadProxyTest()
       : update_check_layer_(
             FakePictureLayer::Create(layer_settings(), &client_)) {}
-  ~ProxyMainThreaded() override {}
+  ~ThreadProxyTest() override {}
 
   void SetupTree() override {
     layer_tree_host()->SetRootLayer(update_check_layer_);
     ProxyTest::SetupTree();
     client_.set_bounds(update_check_layer_->bounds());
   }
 
+  const ThreadProxy::MainThreadOnly& ThreadProxyMainOnly() const {
+    DCHECK(task_runner_provider());
+    DCHECK(task_runner_provider()->HasImplThread());
+    DCHECK(proxy());
+    return static_cast<const ThreadProxy*>(proxy())->main();
+  }
+
+  const ThreadProxy::CompositorThreadOnly& ThreadProxyImplOnly() const {
+    DCHECK(task_runner_provider());
+    DCHECK(task_runner_provider()->HasImplThread());
+    DCHECK(proxy());
+    return static_cast<const ThreadProxy*>(proxy())->impl();
+  }
+
  protected:
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> update_check_layer_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ProxyMainThreaded);
+  DISALLOW_COPY_AND_ASSIGN(ThreadProxyTest);
 };
 
-class ProxyMainThreadedSetNeedsCommit : public ProxyMainThreaded {
+class ThreadProxyTestSetNeedsCommit : public ThreadProxyTest {
  protected:
-  ProxyMainThreadedSetNeedsCommit() {}
-  ~ProxyMainThreadedSetNeedsCommit() override {}
+  ThreadProxyTestSetNeedsCommit() {}
+  ~ThreadProxyTestSetNeedsCommit() override {}
 
   void BeginTest() override {
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().max_requested_pipeline_stage);
 
     proxy()->SetNeedsCommit();
 
-    EXPECT_EQ(ProxyMain::COMMIT_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
+    EXPECT_EQ(ThreadProxy::COMMIT_PIPELINE_STAGE,
+              ThreadProxyMainOnly().max_requested_pipeline_stage);
   }
 
   void DidBeginMainFrame() override {
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->current_pipeline_stage());
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().max_requested_pipeline_stage);
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().current_pipeline_stage);
   }
 
   void DidCommit() override {
     EXPECT_EQ(1, update_check_layer_->update_count());
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->current_pipeline_stage());
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().current_pipeline_stage);
     EndTest();
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ProxyMainThreadedSetNeedsCommit);
+  DISALLOW_COPY_AND_ASSIGN(ThreadProxyTestSetNeedsCommit);
 };
 
-PROXY_MAIN_THREADED_TEST_F(ProxyMainThreadedSetNeedsCommit);
+THREAD_PROXY_TEST_F(ThreadProxyTestSetNeedsCommit);
 
-class ProxyMainThreadedSetNeedsAnimate : public ProxyMainThreaded {
+class ThreadProxyTestSetNeedsAnimate : public ThreadProxyTest {
  protected:
-  ProxyMainThreadedSetNeedsAnimate() {}
-  ~ProxyMainThreadedSetNeedsAnimate() override {}
+  ThreadProxyTestSetNeedsAnimate() {}
+  ~ThreadProxyTestSetNeedsAnimate() override {}
 
   void BeginTest() override {
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().max_requested_pipeline_stage);
 
     proxy()->SetNeedsAnimate();
 
-    EXPECT_EQ(ProxyMain::ANIMATE_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
+    EXPECT_EQ(ThreadProxy::ANIMATE_PIPELINE_STAGE,
+              ThreadProxyMainOnly().max_requested_pipeline_stage);
   }
 
   void DidBeginMainFrame() override {
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->current_pipeline_stage());
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().max_requested_pipeline_stage);
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().current_pipeline_stage);
   }
 
   void DidCommit() override {
     EXPECT_EQ(0, update_check_layer_->update_count());
     EndTest();
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ProxyMainThreadedSetNeedsAnimate);
+  DISALLOW_COPY_AND_ASSIGN(ThreadProxyTestSetNeedsAnimate);
 };
 
-PROXY_MAIN_THREADED_TEST_F(ProxyMainThreadedSetNeedsAnimate);
+THREAD_PROXY_TEST_F(ThreadProxyTestSetNeedsAnimate);
 
-class ProxyMainThreadedSetNeedsUpdateLayers : public ProxyMainThreaded {
+class ThreadProxyTestSetNeedsUpdateLayers : public ThreadProxyTest {
  protected:
-  ProxyMainThreadedSetNeedsUpdateLayers() {}
-  ~ProxyMainThreadedSetNeedsUpdateLayers() override {}
+  ThreadProxyTestSetNeedsUpdateLayers() {}
+  ~ThreadProxyTestSetNeedsUpdateLayers() override {}
 
   void BeginTest() override {
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().max_requested_pipeline_stage);
 
     proxy()->SetNeedsUpdateLayers();
 
-    EXPECT_EQ(ProxyMain::UPDATE_LAYERS_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
+    EXPECT_EQ(ThreadProxy::UPDATE_LAYERS_PIPELINE_STAGE,
+              ThreadProxyMainOnly().max_requested_pipeline_stage);
   }
 
   void DidBeginMainFrame() override {
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->current_pipeline_stage());
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().max_requested_pipeline_stage);
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().current_pipeline_stage);
   }
 
   void DidCommit() override {
     EXPECT_EQ(1, update_check_layer_->update_count());
     EndTest();
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ProxyMainThreadedSetNeedsUpdateLayers);
+  DISALLOW_COPY_AND_ASSIGN(ThreadProxyTestSetNeedsUpdateLayers);
 };
 
-PROXY_MAIN_THREADED_TEST_F(ProxyMainThreadedSetNeedsUpdateLayers);
+THREAD_PROXY_TEST_F(ThreadProxyTestSetNeedsUpdateLayers);
 
-class ProxyMainThreadedSetNeedsUpdateLayersWhileAnimating
-    : public ProxyMainThreaded {
+class ThreadProxyTestSetNeedsUpdateLayersWhileAnimating
+    : public ThreadProxyTest {
  protected:
-  ProxyMainThreadedSetNeedsUpdateLayersWhileAnimating() {}
-  ~ProxyMainThreadedSetNeedsUpdateLayersWhileAnimating() override {}
+  ThreadProxyTestSetNeedsUpdateLayersWhileAnimating() {}
+  ~ThreadProxyTestSetNeedsUpdateLayersWhileAnimating() override {}
 
   void BeginTest() override { proxy()->SetNeedsAnimate(); }
 
   void WillBeginMainFrame() override {
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
-    EXPECT_EQ(ProxyMain::ANIMATE_PIPELINE_STAGE,
-              GetProxyMainForTest()->current_pipeline_stage());
-    EXPECT_EQ(ProxyMain::ANIMATE_PIPELINE_STAGE,
-              GetProxyMainForTest()->final_pipeline_stage());
+    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);
 
     proxy()->SetNeedsUpdateLayers();
 
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
-    EXPECT_EQ(ProxyMain::UPDATE_LAYERS_PIPELINE_STAGE,
-              GetProxyMainForTest()->final_pipeline_stage());
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().max_requested_pipeline_stage);
+    EXPECT_EQ(ThreadProxy::UPDATE_LAYERS_PIPELINE_STAGE,
+              ThreadProxyMainOnly().final_pipeline_stage);
   }
 
   void DidBeginMainFrame() override {
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->current_pipeline_stage());
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().max_requested_pipeline_stage);
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().current_pipeline_stage);
   }
 
   void DidCommit() override {
     EXPECT_EQ(1, update_check_layer_->update_count());
     EndTest();
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ProxyMainThreadedSetNeedsUpdateLayersWhileAnimating);
+  DISALLOW_COPY_AND_ASSIGN(ThreadProxyTestSetNeedsUpdateLayersWhileAnimating);
 };
 
-PROXY_MAIN_THREADED_TEST_F(ProxyMainThreadedSetNeedsUpdateLayersWhileAnimating);
+THREAD_PROXY_TEST_F(ThreadProxyTestSetNeedsUpdateLayersWhileAnimating);
 
-class ProxyMainThreadedSetNeedsCommitWhileAnimating : public ProxyMainThreaded {
+class ThreadProxyTestSetNeedsCommitWhileAnimating : public ThreadProxyTest {
  protected:
-  ProxyMainThreadedSetNeedsCommitWhileAnimating() {}
-  ~ProxyMainThreadedSetNeedsCommitWhileAnimating() override {}
+  ThreadProxyTestSetNeedsCommitWhileAnimating() {}
+  ~ThreadProxyTestSetNeedsCommitWhileAnimating() override {}
 
   void BeginTest() override { proxy()->SetNeedsAnimate(); }
 
   void WillBeginMainFrame() override {
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
-    EXPECT_EQ(ProxyMain::ANIMATE_PIPELINE_STAGE,
-              GetProxyMainForTest()->current_pipeline_stage());
-    EXPECT_EQ(ProxyMain::ANIMATE_PIPELINE_STAGE,
-              GetProxyMainForTest()->final_pipeline_stage());
+    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);
 
     proxy()->SetNeedsCommit();
 
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
-    EXPECT_EQ(ProxyMain::COMMIT_PIPELINE_STAGE,
-              GetProxyMainForTest()->final_pipeline_stage());
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().max_requested_pipeline_stage);
+    EXPECT_EQ(ThreadProxy::COMMIT_PIPELINE_STAGE,
+              ThreadProxyMainOnly().final_pipeline_stage);
   }
 
   void DidBeginMainFrame() override {
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->max_requested_pipeline_stage());
-    EXPECT_EQ(ProxyMain::NO_PIPELINE_STAGE,
-              GetProxyMainForTest()->current_pipeline_stage());
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().max_requested_pipeline_stage);
+    EXPECT_EQ(ThreadProxy::NO_PIPELINE_STAGE,
+              ThreadProxyMainOnly().current_pipeline_stage);
   }
 
   void DidCommit() override {
     EXPECT_EQ(1, update_check_layer_->update_count());
     EndTest();
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ProxyMainThreadedSetNeedsCommitWhileAnimating);
+  DISALLOW_COPY_AND_ASSIGN(ThreadProxyTestSetNeedsCommitWhileAnimating);
 };
 
-PROXY_MAIN_THREADED_TEST_F(ProxyMainThreadedSetNeedsCommitWhileAnimating);
+THREAD_PROXY_TEST_F(ThreadProxyTestSetNeedsCommitWhileAnimating);
 
-class ProxyMainThreadedCommitWaitsForActivation : public ProxyMainThreaded {
+class ThreadProxyTestCommitWaitsForActivation : public ThreadProxyTest {
  protected:
-  ProxyMainThreadedCommitWaitsForActivation() : commits_completed_(0) {}
-  ~ProxyMainThreadedCommitWaitsForActivation() override {}
+  ThreadProxyTestCommitWaitsForActivation() : commits_completed_(0) {}
+  ~ThreadProxyTestCommitWaitsForActivation() 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(GetProxyImplForTest()->HasCommitCompletionEvent());
-        EXPECT_FALSE(GetProxyImplForTest()->GetNextCommitWaitsForActivation());
+        EXPECT_FALSE(ThreadProxyImplOnly().commit_completion_event);
+        EXPECT_FALSE(ThreadProxyImplOnly().next_commit_waits_for_activation);
         break;
       case 1:
         // The second commit should be held until activation.
-        EXPECT_TRUE(GetProxyImplForTest()->HasCommitCompletionEvent());
-        EXPECT_TRUE(GetProxyImplForTest()->GetNextCommitWaitsForActivation());
+        EXPECT_TRUE(ThreadProxyImplOnly().commit_completion_event);
+        EXPECT_TRUE(ThreadProxyImplOnly().next_commit_waits_for_activation);
         break;
       case 2:
         // The third commit should not wait for activation.
-        EXPECT_FALSE(GetProxyImplForTest()->HasCommitCompletionEvent());
-        EXPECT_FALSE(GetProxyImplForTest()->GetNextCommitWaitsForActivation());
+        EXPECT_FALSE(ThreadProxyImplOnly().commit_completion_event);
+        EXPECT_FALSE(ThreadProxyImplOnly().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(GetProxyImplForTest()->GetNextCommitWaitsForActivation());
+    EXPECT_FALSE(ThreadProxyImplOnly().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(ProxyMainThreadedCommitWaitsForActivation);
+  DISALLOW_COPY_AND_ASSIGN(ThreadProxyTestCommitWaitsForActivation);
 };
 
-PROXY_MAIN_THREADED_TEST_F(ProxyMainThreadedCommitWaitsForActivation);
+THREAD_PROXY_TEST_F(ThreadProxyTestCommitWaitsForActivation);
 
 }  // namespace cc