cc: Split Proxy and TaskRunnerProvider for the LayerTreeHost

cc/trees/layer_tree_host_unittest_copyrequest.cc

 // Copyright 2013 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/layers/layer_iterator.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_picture_layer.h"
@@ skipping 85 matching lines @@
         // The |root| was copied to a bitmap and passed back also in Case 2.
         EXPECT_EQ(gfx::Size(20, 20).ToString(), callbacks_[2].ToString());
         // The |grand_child| was copied to a bitmap and passed back in Case 2.
         EXPECT_EQ(gfx::Size(5, 5).ToString(), callbacks_[3].ToString());
         EndTest();
         break;
     }
   }
 
   void CopyOutputCallback(size_t id, scoped_ptr<CopyOutputResult> result) {
-    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     EXPECT_TRUE(result->HasBitmap());
     scoped_ptr<SkBitmap> bitmap = result->TakeBitmap().Pass();
     EXPECT_EQ(result->size().ToString(),
               gfx::Size(bitmap->width(), bitmap->height()).ToString());
     callbacks_[id] = result->size();
   }
 
   void AfterTest() override { EXPECT_EQ(4u, callbacks_.size()); }
 
   scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
@@ skipping 126 matching lines @@
         break;
       case 5:
         // We should get another callback with a NULL bitmap.
         EXPECT_EQ(2, callback_count_);
         EndTest();
         break;
     }
   }
 
   void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
-    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     EXPECT_TRUE(result->IsEmpty());
     ++callback_count_;
   }
 
   void AfterTest() override {}
 
   int callback_count_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> main_destroyed_;
@@ skipping 36 matching lines @@
 
   void BeginTest() override {
     callback_count_ = 0;
     PostSetNeedsCommitToMainThread();
 
     AddCopyRequest(copy_layer_.get());
   }
 
   void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
     ++callback_count_;
-    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     EXPECT_EQ(copy_layer_->bounds().ToString(), result->size().ToString())
         << callback_count_;
     switch (callback_count_) {
       case 1:
         // Hide the copy request layer.
         grand_parent_layer_->SetHideLayerAndSubtree(false);
         parent_layer_->SetHideLayerAndSubtree(false);
         copy_layer_->SetHideLayerAndSubtree(true);
         AddCopyRequest(copy_layer_.get());
         break;
@@ skipping 75 matching lines @@
     PostSetNeedsCommitToMainThread();
 
     copy_layer_->RequestCopyOfOutput(
         CopyOutputRequest::CreateBitmapRequest(base::Bind(
             &LayerTreeHostTestHiddenSurfaceNotAllocatedForSubtreeCopyRequest::
                  CopyOutputCallback,
             base::Unretained(this))));
   }
 
   void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
-    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     EXPECT_EQ(copy_layer_->bounds().ToString(), result->size().ToString());
     EndTest();
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     Renderer* renderer = host_impl->renderer();
 
     LayerImpl* root = host_impl->active_tree()->root_layer();
     LayerImpl* grand_parent = root->children()[0];
     LayerImpl* parent = grand_parent->children()[0];
@@ skipping 51 matching lines @@
     PostSetNeedsCommitToMainThread();
 
     copy_layer_->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
         base::Bind(&LayerTreeHostCopyRequestTestClippedOut::CopyOutputCallback,
                    base::Unretained(this))));
   }
 
   void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
     // We should still get the content even if the copy requested layer was
     // completely clipped away.
-    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     EXPECT_EQ(gfx::Size(10, 10).ToString(), result->size().ToString());
     EndTest();
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> parent_layer_;
   scoped_refptr<FakePictureLayer> copy_layer_;
@@ skipping 46 matching lines @@
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
       // Allow drawing.
       layer_tree_host()->SetViewportSize(gfx::Size(root_->bounds()));
 
       AddCopyRequest(copy_layer_.get());
     }
   }
 
   void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
-    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
 
     // The first frame can't be drawn.
     switch (callback_count_) {
       case 0:
         EXPECT_TRUE(result->IsEmpty());
         EXPECT_EQ(gfx::Size(), result->size());
         break;
       case 1:
         EXPECT_FALSE(result->IsEmpty());
         EXPECT_EQ(copy_layer_->bounds().ToString(), result->size().ToString());
@@ skipping 41 matching lines @@
     copy_layer_->SetBounds(gfx::Size(10, 10));
     root_->AddChild(copy_layer_);
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
-    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    EXPECT_TRUE(layer_tree_host()->task_runner_provider()->IsMainThread());
     EXPECT_EQ(gfx::Size(10, 10).ToString(), result->size().ToString());
     EXPECT_TRUE(result->HasTexture());
 
     // Save the result for later.
     EXPECT_FALSE(result_);
     result_ = result.Pass();
 
     // Post a commit to lose the output surface.
     layer_tree_host()->SetNeedsCommit();
   }
@@ skipping 505 matching lines @@
   int num_draws_;
   bool copy_happened_;
   bool draw_happened_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostCopyRequestTestMultipleDrawsHiddenCopyRequest);
 
 }  // namespace
 }  // namespace cc