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(),
-                            delegated_rendering) {}
+        : FakeOutputSurface(
+              base::MakeUnique<TestContextProvider::DeferredCreate>(),
+              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 {
  public:
@@ skipping 3650 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 {
+    std::unique_ptr<TestContextProvider::DeferredCreate> create(
+        new TestContextProvider::DeferredCreate);
+    bool first = !first_context_provider_;
+    if (first)
+      create->created_context = &first_context_provider_;
+    else
+      create->created_context = &second_context_provider_;
 
-  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<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 SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
@@ skipping 24 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;

[piman, 2016/05/17 03:41:41]

This one is only used to get the TestWGC3D, so maybe same thing, inject it to
the TestContextProvider::DeferredCreate and use it in SwapBuffersOnThread?

[danakj, 2016/05/17 19:53:33]

I don't want to build things about the TestWGC3D cuz that will just make it
harder to get rid of later, so I want to just work with TestContextProvider and
treat it like a member/implementation detail as much as possible.

+  TestContextProvider* second_context_provider_ = nullptr;

[piman, 2016/05/17 03:41:41]

this one is not used any more.

[danakj, 2016/05/17 19:53:35]

Done.

+  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