Defer compositor context creation to the thread.

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 <stddef.h>
 
 #include "base/memory/ptr_util.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
@@ skipping 110 matching lines @@
     callbacks_[id] = result->size();
   }
 
   void AfterTest() override { EXPECT_EQ(4u, callbacks_.size()); }
 
   std::unique_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     if (!use_gl_renderer_) {
       return FakeOutputSurface::CreateSoftware(
           base::WrapUnique(new SoftwareOutputDevice));
     }
-    std::unique_ptr<FakeOutputSurface> output_surface =
-        FakeOutputSurface::Create3d();
-    TestContextSupport* context_support = static_cast<TestContextSupport*>(
-        output_surface->context_provider()->ContextSupport());
-    context_support->set_out_of_order_callbacks(out_of_order_callbacks_);
-    return output_surface;
+    return FakeOutputSurface::Create3d(
+        base::MakeUnique<TestContextProvider::Factory>());
+  }
+
+  void InitializedRendererOnThread(LayerTreeHostImpl* impl,
+                                   bool success) override {
+    ASSERT_TRUE(success);
+    if (use_gl_renderer_) {
+      auto* context_provider = static_cast<TestContextProvider*>(
+          impl->output_surface()->context_provider());
+      context_provider->support()->set_out_of_order_callbacks(
+          out_of_order_callbacks_);
+    }
   }
 
   bool use_gl_renderer_;
   bool out_of_order_callbacks_ = false;
   std::map<size_t, gfx::Size> callbacks_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root;
   scoped_refptr<FakePictureLayer> child;
   scoped_refptr<FakePictureLayer> grand_child;
 };
@@ skipping 553 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostTestAsyncTwoReadbacksWithoutDraw);
 
 class LayerTreeHostCopyRequestTestLostOutputSurface
     : public LayerTreeHostCopyRequestTest {
  protected:
   std::unique_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     if (!first_context_provider_) {
-      first_context_provider_ = TestContextProvider::Create();
-      return FakeOutputSurface::Create3d(first_context_provider_);
+      return FakeOutputSurface::Create3d(
+          base::MakeUnique<TestContextProvider::Factory>());
     }
+    EXPECT_FALSE(second_context_provider_);
+    return FakeOutputSurface::Create3d(
+        base::MakeUnique<TestContextProvider::Factory>());
+  }
 
-    EXPECT_FALSE(second_context_provider_);
-    second_context_provider_ = TestContextProvider::Create();
-    return FakeOutputSurface::Create3d(second_context_provider_);
+  void InitializedRendererOnThread(LayerTreeHostImpl* impl,
+                                   bool success) override {
+    ASSERT_TRUE(success);
+    if (!first_context_provider_) {
+      first_context_provider_ = static_cast<TestContextProvider*>(
+          impl->output_surface()->context_provider());
+    } else {
+      second_context_provider_ = static_cast<TestContextProvider*>(
+          impl->output_surface()->context_provider());
+    }
   }
 
   void SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
     copy_layer_ = FakePictureLayer::Create(&client_);
     copy_layer_->SetBounds(gfx::Size(10, 10));
     root_->AddChild(copy_layer_);
 
@@ skipping 33 matching lines @@
         FROM_HERE, base::Bind(&LayerTreeHostCopyRequestTestLostOutputSurface::
                                   CheckNumTexturesAfterReadbackDestroyed,
                               base::Unretained(this)));
   }
 
   void CheckNumTexturesAfterReadbackDestroyed() {
     // After the loss we had |num_textures_after_loss_| many textures, but
     // releasing the copy output request will cause the texture in the request
     // to be released, so we should have 1 less by now.
     EXPECT_EQ(num_textures_after_loss_ - 1,
-              first_context_provider_->TestContext3d()->NumTextures());
+              saved_first_context_provider_->TestContext3d()->NumTextures());
+    // Drop the saved reference on the compositor thread.
+    saved_first_context_provider_ = nullptr;
     EndTest();
   }
 
   void SwapBuffersOnThread(LayerTreeHostImpl* impl, bool result) override {
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
+        EXPECT_TRUE(first_context_provider_);
+        EXPECT_FALSE(second_context_provider_);
+
         // The layers have been drawn, so their textures have been allocated.
         EXPECT_FALSE(result_);
         num_textures_without_readback_ =
             first_context_provider_->TestContext3d()->NumTextures();
 
         // Request a copy of the layer. This will use another texture.
         MainThreadTaskRunner()->PostTask(
             FROM_HERE,
             base::Bind(&LayerTreeHostCopyRequestTestLostOutputSurface::
                            InsertCopyRequest,
                        base::Unretained(this)));
         break;
       case 1:
+        EXPECT_TRUE(first_context_provider_);
+        EXPECT_FALSE(second_context_provider_);
+
         // We did a readback, so there will be a readback texture around now.
         EXPECT_LT(num_textures_without_readback_,
                   first_context_provider_->TestContext3d()->NumTextures());
 
         // The copy request will be serviced and the result sent to
         // ReceiveCopyRequestOutputAndCommit, which posts a new commit causing
         // the test to advance to the next case.
         break;
       case 2:
+        EXPECT_TRUE(first_context_provider_);
+        EXPECT_FALSE(second_context_provider_);
+
         // The readback texture is collected.
         EXPECT_TRUE(result_);
 
+        saved_first_context_provider_ =
+            make_scoped_refptr(first_context_provider_);
+
         // Lose the output surface.
         first_context_provider_->TestContext3d()->loseContextCHROMIUM(
             GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
         break;
       case 3:
         // The output surface has been recreated.
         EXPECT_TRUE(second_context_provider_);
 
         num_textures_after_loss_ =
-            first_context_provider_->TestContext3d()->NumTextures();
+            saved_first_context_provider_->TestContext3d()->NumTextures();
 
         // Now destroy the CopyOutputResult, releasing the texture inside back
         // to the compositor. Then check the resulting number of allocated
         // textures.
         MainThreadTaskRunner()->PostTask(
             FROM_HERE,
             base::Bind(&LayerTreeHostCopyRequestTestLostOutputSurface::
                            DestroyCopyResultAndCheckNumTextures,
                        base::Unretained(this)));
         break;
     }
   }
 
   void AfterTest() override {}
 
-  scoped_refptr<TestContextProvider> first_context_provider_;
-  scoped_refptr<TestContextProvider> second_context_provider_;
+  TestContextProvider* first_context_provider_ = nullptr;
+  TestContextProvider* second_context_provider_ = nullptr;
+  // Keep the first_context_provider_ alive past this compositor instance being
+  // done with it.
+  scoped_refptr<TestContextProvider> saved_first_context_provider_;
   size_t num_textures_without_readback_ = 0;
   size_t num_textures_after_loss_ = 0;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> copy_layer_;
   std::unique_ptr<CopyOutputResult> result_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostCopyRequestTestLostOutputSurface);
 
 class LayerTreeHostCopyRequestTestCountTextures
     : public LayerTreeHostCopyRequestTest {
  protected:
   std::unique_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
-    context_provider_ = TestContextProvider::Create();
-    return FakeOutputSurface::Create3d(context_provider_);
+    return FakeOutputSurface::Create3d(
+        base::MakeUnique<TestContextProvider::Factory>());
   }
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
 
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
     copy_layer_ = FakePictureLayer::Create(&client_);
     copy_layer_->SetBounds(gfx::Size(10, 10));
@@ skipping 17 matching lines @@
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // The layers have been pushed to the impl side. The layer textures have
         // been allocated.
         RequestCopy(copy_layer_.get());
         break;
     }
   }
 
   void SwapBuffersOnThread(LayerTreeHostImpl* impl, bool result) override {
+    auto* context_provider = static_cast<TestContextProvider*>(
+        impl->output_surface()->context_provider());
+
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         // The layers have been drawn, so their textures have been allocated.
         num_textures_without_readback_ =
-            context_provider_->TestContext3d()->NumTextures();
+            context_provider->TestContext3d()->NumTextures();
         break;
       case 1:
         // We did a readback, so there will be a readback texture around now.
         num_textures_with_readback_ =
-            context_provider_->TestContext3d()->NumTextures();
+            context_provider->TestContext3d()->NumTextures();
         waited_sync_token_after_readback_ =
-            context_provider_->TestContext3d()->last_waited_sync_token();
+            context_provider->TestContext3d()->last_waited_sync_token();
 
         MainThreadTaskRunner()->PostTask(
             FROM_HERE,
             base::Bind(&LayerTreeHostCopyRequestTestCountTextures::DoEndTest,
                        base::Unretained(this)));
         break;
     }
   }
 
   virtual void DoEndTest() { EndTest(); }
 
-  scoped_refptr<TestContextProvider> context_provider_;
   size_t num_textures_without_readback_;
   size_t num_textures_with_readback_;
   gpu::SyncToken waited_sync_token_after_readback_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> copy_layer_;
 };
 
 class LayerTreeHostCopyRequestTestCreatesTexture
     : public LayerTreeHostCopyRequestTestCountTextures {
@@ skipping 27 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostCopyRequestTestCreatesTexture);
 
 class LayerTreeHostCopyRequestTestProvideTexture
     : public LayerTreeHostCopyRequestTestCountTextures {
  protected:
   void BeginTest() override {
     external_context_provider_ = TestContextProvider::Create();
-    EXPECT_TRUE(external_context_provider_->BindToCurrentThread());
     LayerTreeHostCopyRequestTestCountTextures::BeginTest();
   }
 
   void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {
     EXPECT_FALSE(result->IsEmpty());
     EXPECT_TRUE(result->HasTexture());
 
     TextureMailbox mailbox;
     std::unique_ptr<SingleReleaseCallback> release;
     result->TakeTexture(&mailbox, &release);
@@ skipping 299 matching lines @@
   int num_draws_;
   bool copy_happened_;
   bool draw_happened_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostCopyRequestTestMultipleDrawsHiddenCopyRequest);
 
 }  // namespace
 }  // namespace cc