Defer compositor context creation to the thread.

cc/raster/raster_buffer_provider_unittest.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/raster/raster_buffer_provider.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 112 matching lines @@
   struct RasterTaskResult {
     unsigned id;
     bool canceled;
   };
 
   typedef std::vector<scoped_refptr<TileTask>> RasterTaskVector;
 
   enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL };
 
   RasterBufferProviderTest()
-      : context_provider_(TestContextProvider::Create()),
-        worker_context_provider_(TestContextProvider::CreateWorker()),
-        all_tile_tasks_finished_(
+      : all_tile_tasks_finished_(
             base::ThreadTaskRunnerHandle::Get().get(),
             base::Bind(&RasterBufferProviderTest::AllTileTasksFinished,
                        base::Unretained(this))),
         timeout_seconds_(5),
         timed_out_(false) {}
 
   // Overridden from testing::Test:
   void SetUp() override {
     std::unique_ptr<RasterBufferProvider> raster_buffer_provider;
     switch (GetParam()) {
       case RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY:
         Create3dOutputSurfaceAndResourceProvider();
         raster_buffer_provider = ZeroCopyRasterBufferProvider::Create(
             resource_provider_.get(), PlatformColor::BestTextureFormat());
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY:
         Create3dOutputSurfaceAndResourceProvider();
         raster_buffer_provider = OneCopyRasterBufferProvider::Create(
-            base::ThreadTaskRunnerHandle::Get().get(), context_provider_.get(),
-            resource_provider_.get(), kMaxBytesPerCopyOperation, false,
-            kMaxStagingBuffers, PlatformColor::BestTextureFormat());
+            base::ThreadTaskRunnerHandle::Get().get(),
+            output_surface_->context_provider(), resource_provider_.get(),
+            kMaxBytesPerCopyOperation, false, kMaxStagingBuffers,
+            PlatformColor::BestTextureFormat());
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_GPU:
         Create3dOutputSurfaceAndResourceProvider();
-        raster_buffer_provider = GpuRasterBufferProvider::Create(
-            context_provider_.get(), resource_provider_.get(), false, 0);
+        raster_buffer_provider =
+            GpuRasterBufferProvider::Create(output_surface_->context_provider(),
+                                            resource_provider_.get(), false, 0);
         break;
       case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
         CreateSoftwareOutputSurfaceAndResourceProvider();
         raster_buffer_provider =
             BitmapRasterBufferProvider::Create(resource_provider_.get());
         break;
     }
 
     DCHECK(raster_buffer_provider);
 
@@ skipping 71 matching lines @@
   void LoseContext(ContextProvider* context_provider) {
     if (!context_provider)
       return;
     context_provider->ContextGL()->LoseContextCHROMIUM(
         GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
     context_provider->ContextGL()->Flush();
   }
 
  private:
   void Create3dOutputSurfaceAndResourceProvider() {
-    output_surface_ = FakeOutputSurface::Create3d(context_provider_,
-                                                  worker_context_provider_);
+    gpu::Capabilities capabilities;
+    capabilities.sync_query = true;
+    output_surface_ = FakeOutputSurface::Create3d(
+        base::MakeUnique<TestContextProvider::Factory>(capabilities),
+        TestContextProvider::Create());
     CHECK(output_surface_->BindToClient(&output_surface_client_));
-    TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d();
-    context3d->set_support_sync_query(true);
+    context_provider_ =
+        static_cast<TestContextProvider*>(output_surface_->context_provider());
     resource_provider_ = FakeResourceProvider::Create(
         output_surface_.get(), nullptr, &gpu_memory_buffer_manager_);
   }
 
   void CreateSoftwareOutputSurfaceAndResourceProvider() {
     output_surface_ = FakeOutputSurface::CreateSoftware(
         base::WrapUnique(new SoftwareOutputDevice));
     CHECK(output_surface_->BindToClient(&output_surface_client_));
     resource_provider_ = FakeResourceProvider::Create(
         output_surface_.get(), &shared_bitmap_manager_, nullptr);
   }
 
   void OnTaskCompleted(std::unique_ptr<ScopedResource> resource,
                        unsigned id,
                        bool was_canceled) {
     RasterTaskResult result;
     result.id = id;
     result.canceled = was_canceled;
     completed_tasks_.push_back(result);
   }
 
   void OnTimeout() {
     timed_out_ = true;
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
  protected:
-  scoped_refptr<TestContextProvider> context_provider_;
-  scoped_refptr<TestContextProvider> worker_context_provider_;
   FakeOutputSurfaceClient output_surface_client_;
+  TestContextProvider* context_provider_ = nullptr;
   std::unique_ptr<FakeOutputSurface> output_surface_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   std::unique_ptr<TileTaskManager> tile_task_manager_;
   TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
   TestSharedBitmapManager shared_bitmap_manager_;
   SynchronousTaskGraphRunner task_graph_runner_;
   base::CancelableClosure timeout_;
   UniqueNotifier all_tile_tasks_finished_;
   int timeout_seconds_;
   bool timed_out_;
@@ skipping 70 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(RasterBufferProviderTests,
                         RasterBufferProviderTest,
                         ::testing::Values(RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY,
                                           RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY,
                                           RASTER_BUFFER_PROVIDER_TYPE_GPU,
                                           RASTER_BUFFER_PROVIDER_TYPE_BITMAP));
 
 }  // namespace
 }  // namespace cc