Defer compositor context creation to the thread.

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 453 matching lines @@
     // Expectations handled via mock.
   }
 
  private:
   class MockSetWorkerContextShouldAggressivelyFreeResourcesOutputSurface
       : public FakeOutputSurface {
    public:
     ~MockSetWorkerContextShouldAggressivelyFreeResourcesOutputSurface() {}
     explicit MockSetWorkerContextShouldAggressivelyFreeResourcesOutputSurface(
         bool delegated_rendering)
-        : FakeOutputSurface(TestContextProvider::Create(),
-                            TestContextProvider::CreateWorker(),
+        : FakeOutputSurface(base::MakeUnique<TestContextProvider::Factory>(),
+                            TestContextProvider::Create(),
                             delegated_rendering) {}
     MOCK_METHOD1(SetWorkerContextShouldAggressivelyFreeResources,
                  void(bool is_visible));
   };
 };
 
 // Test if the LTH successfully frees resources on the worker context when
 // visibility is set to false.
 class LayerTreeHostFreeWorkerContextResourcesOnInvisible
     : public LayerTreeHostFreeWorkerContextResourcesTest {
@@ skipping 3651 matching lines @@
   ScrollElasticityHelper* scroll_elasticity_helper_;
   int content_layer_id_;
   int num_draws_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestElasticOverscroll);
 
 class LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface
     : public LayerTreeHostTest {
  protected:
-  LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface()
-      : first_output_surface_memory_limit_(4321234),
-        second_output_surface_memory_limit_(1234321) {}
-
   std::unique_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
-    if (!first_context_provider_.get()) {
-      first_context_provider_ = TestContextProvider::Create();
-    } else {
-      EXPECT_FALSE(second_context_provider_.get());
-      second_context_provider_ = TestContextProvider::Create();
-    }
-
-    scoped_refptr<TestContextProvider> provider(second_context_provider_.get()
-                                                    ? second_context_provider_
-                                                    : first_context_provider_);
+    std::unique_ptr<TestContextProvider::Factory> create(
+        new TestContextProvider::Factory);
+    const bool first = !first_context_provider_;
     std::unique_ptr<FakeOutputSurface> output_surface;
     if (delegating_renderer())
-      output_surface = FakeOutputSurface::CreateDelegating3d(provider);
+      output_surface = FakeOutputSurface::CreateDelegating3d(std::move(create));
     else
-      output_surface = FakeOutputSurface::Create3d(provider);
+      output_surface = FakeOutputSurface::Create3d(std::move(create));
     output_surface->SetMemoryPolicyToSetAtBind(
         base::WrapUnique(new ManagedMemoryPolicy(
-            second_context_provider_.get() ? second_output_surface_memory_limit_
-                                           : first_output_surface_memory_limit_,
+            first ? first_output_surface_memory_limit_
+                  : second_output_surface_memory_limit_,
             gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
             ManagedMemoryPolicy::kDefaultNumResourcesLimit)));
     return output_surface;
   }
 
+  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());
+    }
+  }
+
   void SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 19 matching lines @@
         break;
       case 4:
         EXPECT_EQ(second_output_surface_memory_limit_,
                   impl->memory_allocation_limit_bytes());
         break;
     }
   }
 
   void AfterTest() override {}
 
-  scoped_refptr<TestContextProvider> first_context_provider_;
-  scoped_refptr<TestContextProvider> second_context_provider_;
-  size_t first_output_surface_memory_limit_;
-  size_t second_output_surface_memory_limit_;
+  TestContextProvider* first_context_provider_ = nullptr;
+  size_t first_output_surface_memory_limit_ = 4321234;
+  size_t second_output_surface_memory_limit_ = 1234321;
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface);
 
 struct TestSwapPromiseResult {
   TestSwapPromiseResult()
       : did_activate_called(false),
@@ skipping 1236 matching lines @@
 // This test does pinching on the impl side which is not supported in single
 // thread.
 MULTI_THREAD_TEST_F(LayerTreeHostTestCrispUpAfterPinchEnds);
 
 class LayerTreeHostTestCrispUpAfterPinchEndsWithOneCopy
     : public LayerTreeHostTestCrispUpAfterPinchEnds {
  protected:
   std::unique_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     std::unique_ptr<TestWebGraphicsContext3D> context3d =
         TestWebGraphicsContext3D::Create();
-    context3d->set_support_image(true);
     context3d->set_support_sync_query(true);
 #if defined(OS_MACOSX)
     context3d->set_support_texture_rectangle(true);
 #endif
 
     if (delegating_renderer())
       return FakeOutputSurface::CreateDelegating3d(std::move(context3d));
     else
       return FakeOutputSurface::Create3d(std::move(context3d));
   }
@@ skipping 1113 matching lines @@
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPaintedDeviceScaleFactor);
 
 }  // namespace
 }  // namespace cc