Remove the concept of OutputSurface from ResourceProvider.

cc/resources/resource_provider_unittest.cc

 // Copyright 2012 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/resources/resource_provider.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 28 matching lines @@
 
 using testing::Mock;
 using testing::NiceMock;
 using testing::Return;
 using testing::StrictMock;
 using testing::_;
 
 namespace cc {
 namespace {
 
+static const bool kUseGpuMemoryBufferResources = false;
+static const bool kDelegatedSyncPointsRequired = true;
+static const std::vector<unsigned> kUseImageTextureTargets(
+    static_cast<size_t>(gfx::BufferFormat::LAST) + 1,
+    GL_TEXTURE_2D);
+
 MATCHER_P(MatchesSyncToken, sync_token, "") {
   gpu::SyncToken other;
   memcpy(&other, arg, sizeof(other));
   return other == sync_token;
 }
 
 static void EmptyReleaseCallback(const gpu::SyncToken& sync_token,
                                  bool lost_resource,
                                  BlockingTaskRunner* main_thread_task_runner) {}
 
@@ skipping 393 matching lines @@
         break;
     }
     CHECK(output_surface_->BindToClient(&output_surface_client_));
     CHECK(child_output_surface_->BindToClient(&child_output_surface_client_));
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager);
     gpu_memory_buffer_manager_.reset(new TestGpuMemoryBufferManager);
     child_gpu_memory_buffer_manager_ =
         gpu_memory_buffer_manager_->CreateClientGpuMemoryBufferManager();
 
-    resource_provider_ = ResourceProvider::Create(
-        output_surface_.get(), shared_bitmap_manager_.get(),
+    resource_provider_ = base::MakeUnique<ResourceProvider>(
+        output_surface_->context_provider(), shared_bitmap_manager_.get(),
         gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0, 1,
-        use_gpu_memory_buffer_resources_, use_image_texture_targets_);
-    child_resource_provider_ = ResourceProvider::Create(
-        child_output_surface_.get(), shared_bitmap_manager_.get(),
+        kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+        kUseImageTextureTargets);
+    child_resource_provider_ = base::MakeUnique<ResourceProvider>(
+        child_output_surface_->context_provider(), shared_bitmap_manager_.get(),
         child_gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(),
-        0, 1, use_gpu_memory_buffer_resources_, use_image_texture_targets_);
+        0, 1,
+        child_output_surface_->capabilities().delegated_sync_points_required,
+        kUseGpuMemoryBufferResources, kUseImageTextureTargets);
   }
 
   ResourceProviderTest() : ResourceProviderTest(true) {}
 
   static void CollectResources(ReturnedResourceArray* array,
                                const ReturnedResourceArray& returned,
                                BlockingTaskRunner* main_thread_task_runner) {
     array->insert(array->end(), returned.begin(), returned.end());
   }
 
@@ skipping 40 matching lines @@
       SharedBitmap* shared_bitmap_ptr = shared_bitmap.get();
       std::unique_ptr<SingleReleaseCallbackImpl> callback =
           SingleReleaseCallbackImpl::Create(base::Bind(
               ReleaseSharedBitmapCallback, base::Passed(&shared_bitmap),
               release_called, release_sync_token, lost_resource));
       return child_resource_provider_->CreateResourceFromTextureMailbox(
           TextureMailbox(shared_bitmap_ptr, size), std::move(callback));
     }
   }
 
- public:
-  static bool use_gpu_memory_buffer_resources() {
-    return use_gpu_memory_buffer_resources_;
-  }
-  static std::vector<unsigned> use_image_texture_targets() {
-    return use_image_texture_targets_;
-  }
-
  protected:
-  static bool use_gpu_memory_buffer_resources_;
-  static std::vector<unsigned> use_image_texture_targets_;
   std::unique_ptr<ContextSharedData> shared_data_;
   ResourceProviderContext* context3d_;
   ResourceProviderContext* child_context_;
   FakeOutputSurfaceClient output_surface_client_;
   FakeOutputSurfaceClient child_output_surface_client_;
   std::unique_ptr<OutputSurface> output_surface_;
   std::unique_ptr<OutputSurface> child_output_surface_;
   std::unique_ptr<BlockingTaskRunner> main_thread_task_runner_;
   std::unique_ptr<TestGpuMemoryBufferManager> gpu_memory_buffer_manager_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   std::unique_ptr<TestGpuMemoryBufferManager> child_gpu_memory_buffer_manager_;
   std::unique_ptr<ResourceProvider> child_resource_provider_;
   std::unique_ptr<TestSharedBitmapManager> shared_bitmap_manager_;
 };
 
-bool ResourceProviderTest::use_gpu_memory_buffer_resources_ = false;
-
-std::vector<unsigned> ResourceProviderTest::use_image_texture_targets_ =
-    std::vector<unsigned>(static_cast<size_t>(gfx::BufferFormat::LAST) + 1,
-                          GL_TEXTURE_2D);
-
 void CheckCreateResource(ResourceProvider::ResourceType expected_default_type,
                          ResourceProvider* resource_provider,
                          ResourceProviderContext* context) {
   DCHECK_EQ(expected_default_type, resource_provider->default_resource_type());
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
@@ skipping 887 matching lines @@
 
   std::unique_ptr<ResourceProviderContext> child_context_owned(
       ResourceProviderContext::Create(shared_data_.get()));
 
   FakeOutputSurfaceClient child_output_surface_client;
   std::unique_ptr<OutputSurface> child_output_surface(
       FakeOutputSurface::Create3d(std::move(child_context_owned)));
   CHECK(child_output_surface->BindToClient(&child_output_surface_client));
 
   std::unique_ptr<ResourceProvider> child_resource_provider(
-      ResourceProvider::Create(
-          child_output_surface.get(), shared_bitmap_manager_.get(),
-          gpu_memory_buffer_manager_.get(), NULL, 0, 1,
-          use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+      base::MakeUnique<ResourceProvider>(
+          child_output_surface->context_provider(),
+          shared_bitmap_manager_.get(), gpu_memory_buffer_manager_.get(),
+          nullptr, 0, 1, kDelegatedSyncPointsRequired,
+          kUseGpuMemoryBufferResources, kUseImageTextureTargets));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceId id1 = child_resource_provider->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
   child_resource_provider->CopyToResource(id1, data1, size);
@@ skipping 497 matching lines @@
     TextureStateTrackingContext* child_context = child_context_owned.get();
 
     FakeOutputSurfaceClient child_output_surface_client;
     std::unique_ptr<OutputSurface> child_output_surface(
         FakeOutputSurface::Create3d(std::move(child_context_owned)));
     CHECK(child_output_surface->BindToClient(&child_output_surface_client));
     std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
         new TestSharedBitmapManager());
 
     std::unique_ptr<ResourceProvider> child_resource_provider(
-        ResourceProvider::Create(child_output_surface.get(),
-                                 shared_bitmap_manager.get(), NULL, NULL, 0, 1,
-                                 use_gpu_memory_buffer_resources_,
-                                 use_image_texture_targets_));
+        base::MakeUnique<ResourceProvider>(
+            child_output_surface->context_provider(),
+            shared_bitmap_manager.get(), nullptr, nullptr, 0, 1,
+            kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+            kUseImageTextureTargets));
 
     std::unique_ptr<TextureStateTrackingContext> parent_context_owned(
         new TextureStateTrackingContext);
     TextureStateTrackingContext* parent_context = parent_context_owned.get();
 
     FakeOutputSurfaceClient parent_output_surface_client;
     std::unique_ptr<OutputSurface> parent_output_surface(
         FakeOutputSurface::Create3d(std::move(parent_context_owned)));
     CHECK(parent_output_surface->BindToClient(&parent_output_surface_client));
 
     std::unique_ptr<ResourceProvider> parent_resource_provider(
-        ResourceProvider::Create(parent_output_surface.get(),
-                                 shared_bitmap_manager.get(), NULL, NULL, 0, 1,
-                                 use_gpu_memory_buffer_resources_,
-                                 use_image_texture_targets_));
+        base::MakeUnique<ResourceProvider>(
+            parent_output_surface->context_provider(),
+            shared_bitmap_manager.get(), nullptr, nullptr, 0, 1,
+            kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+            kUseImageTextureTargets));
 
     gfx::Size size(1, 1);
     ResourceFormat format = RGBA_8888;
     int child_texture_id = 1;
     int parent_texture_id = 2;
 
     size_t pixel_size = TextureSizeBytes(size, format);
     ASSERT_EQ(4U, pixel_size);
 
     ResourceId id = child_resource_provider->CreateResource(
@@ skipping 146 matching lines @@
   context()->produceTextureDirectCHROMIUM(texture, GL_TEXTURE_2D, mailbox.name);
   gpu::SyncToken sync_token;
   context()->genSyncToken(context()->insertFenceSync(), sync_token.GetData());
   EXPECT_TRUE(sync_token.HasData());
 
   // All the logic below assumes that the sync token releases are all positive.
   EXPECT_LT(0u, sync_token.release_count());
 
   gpu::SyncToken release_sync_token;
   bool lost_resource = false;
-  BlockingTaskRunner* main_thread_task_runner = NULL;
+  BlockingTaskRunner* main_thread_task_runner = nullptr;
   ReleaseCallbackImpl callback =
       base::Bind(ReleaseCallback, &release_sync_token, &lost_resource,
                  &main_thread_task_runner);
   ResourceId resource = resource_provider_->CreateResourceFromTextureMailbox(
       TextureMailbox(mailbox, sync_token, GL_TEXTURE_2D),
       SingleReleaseCallbackImpl::Create(callback));
   EXPECT_EQ(1u, context()->NumTextures());
   EXPECT_FALSE(release_sync_token.HasData());
   {
     // Transfer the resource, expect the sync points to be consistent.
@@ skipping 414 matching lines @@
   gpu::Mailbox mailbox;
   context()->genMailboxCHROMIUM(mailbox.name);
   context()->produceTextureDirectCHROMIUM(texture, GL_TEXTURE_2D, mailbox.name);
   gpu::SyncToken sync_token;
   context()->genSyncToken(context()->insertFenceSync(), sync_token.GetData());
 
   EXPECT_TRUE(sync_token.HasData());
 
   gpu::SyncToken release_sync_token;
   bool lost_resource = false;
-  BlockingTaskRunner* main_thread_task_runner = NULL;
+  BlockingTaskRunner* main_thread_task_runner = nullptr;
   std::unique_ptr<SingleReleaseCallbackImpl> callback =
       SingleReleaseCallbackImpl::Create(
           base::Bind(ReleaseCallback, &release_sync_token, &lost_resource,
                      &main_thread_task_runner));
   resource_provider_->CreateResourceFromTextureMailbox(
       TextureMailbox(mailbox, sync_token, GL_TEXTURE_2D), std::move(callback));
 
   EXPECT_FALSE(release_sync_token.HasData());
   EXPECT_FALSE(lost_resource);
-  EXPECT_EQ(NULL, main_thread_task_runner);
+  EXPECT_FALSE(main_thread_task_runner);
 
   resource_provider_->DidLoseOutputSurface();
   resource_provider_ = nullptr;
 
   EXPECT_LE(sync_token.release_count(), release_sync_token.release_count());
   EXPECT_TRUE(lost_resource);
   EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
 }
 
 TEST_P(ResourceProviderTest, ScopedSampler) {
   // Sampling is only supported for GL textures.
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
 
   std::unique_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
-  std::unique_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, 1,
-      use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          output_surface->context_provider(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kUseImageTextureTargets));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   int texture_id = 1;
 
   ResourceId id = resource_provider->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
 
   // Check that the texture gets created with the right sampler settings.
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id))
@@ skipping 55 matching lines @@
 
   std::unique_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
-  std::unique_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, 1,
-      use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          output_surface->context_provider(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kUseImageTextureTargets));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   int texture_id = 1;
 
   // Check that the texture gets created with the right sampler settings.
   ResourceId id = resource_provider->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
   EXPECT_CALL(*context,
@@ skipping 19 matching lines @@
 
   std::unique_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
-  std::unique_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, 1,
-      use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          output_surface->context_provider(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kUseImageTextureTargets));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
 
   for (int texture_id = 1; texture_id <= 2; ++texture_id) {
     // Check that the texture gets created with the right sampler settings.
     ResourceId id = resource_provider->CreateResource(
         size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
     EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
     EXPECT_CALL(*context,
@@ skipping 20 matching lines @@
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
   context->set_support_texture_storage(true);
   context->set_support_texture_usage(true);
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
-  std::unique_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, 1,
-      use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          output_surface->context_provider(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kUseImageTextureTargets));
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
 
   const ResourceProvider::TextureHint hints[4] = {
       ResourceProvider::TEXTURE_HINT_DEFAULT,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE,
       ResourceProvider::TEXTURE_HINT_FRAMEBUFFER,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER,
   };
@@ skipping 35 matching lines @@
   const uint32_t kBadBeef = 0xbadbeef;
   std::unique_ptr<SharedBitmap> shared_bitmap(
       CreateAndFillSharedBitmap(shared_bitmap_manager_.get(), size, kBadBeef));
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::CreateSoftware(
           base::WrapUnique(new SoftwareOutputDevice)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
-  std::unique_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0, 1,
-      use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          output_surface->context_provider(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0,
+          1, kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kUseImageTextureTargets));
 
   gpu::SyncToken release_sync_token;
   bool lost_resource = false;
-  BlockingTaskRunner* main_thread_task_runner = NULL;
+  BlockingTaskRunner* main_thread_task_runner = nullptr;
   std::unique_ptr<SingleReleaseCallbackImpl> callback =
       SingleReleaseCallbackImpl::Create(
           base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource,
                      &main_thread_task_runner));
   TextureMailbox mailbox(shared_bitmap.get(), size);
 
   ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
       mailbox, std::move(callback));
   EXPECT_NE(0u, id);
 
@@ skipping 22 matching lines @@
     std::unique_ptr<TextureStateTrackingContext> context_owned(
         new TextureStateTrackingContext);
     TextureStateTrackingContext* context = context_owned.get();
 
     FakeOutputSurfaceClient output_surface_client;
     std::unique_ptr<OutputSurface> output_surface(
         FakeOutputSurface::Create3d(std::move(context_owned)));
     CHECK(output_surface->BindToClient(&output_surface_client));
 
     std::unique_ptr<ResourceProvider> resource_provider(
-        ResourceProvider::Create(
-            output_surface.get(), shared_bitmap_manager,
+        base::MakeUnique<ResourceProvider>(
+            output_surface->context_provider(), shared_bitmap_manager,
             gpu_memory_buffer_manager, main_thread_task_runner, 0, 1,
-            use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+            kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+            kUseImageTextureTargets));
 
     unsigned texture_id = 1;
     gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0,
                               gpu::CommandBufferId::FromUnsafeValue(0x12),
                               0x34);
     unsigned target = GL_TEXTURE_2D;
     const GLuint64 current_fence_sync = context->GetNextFenceSync();
 
     EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
     EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
     EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
     EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
 
     gpu::Mailbox gpu_mailbox;
     memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
     gpu::SyncToken release_sync_token;
     bool lost_resource = false;
-    BlockingTaskRunner* mailbox_task_runner = NULL;
+    BlockingTaskRunner* mailbox_task_runner = nullptr;
     std::unique_ptr<SingleReleaseCallbackImpl> callback =
         SingleReleaseCallbackImpl::Create(
             base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource,
                        &mailbox_task_runner));
 
     TextureMailbox mailbox(gpu_mailbox, sync_token, target);
     mailbox.set_nearest_neighbor(mailbox_nearest_neighbor);
 
     ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
         mailbox, std::move(callback));
@@ skipping 103 matching lines @@
 
   std::unique_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
-  std::unique_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, 1,
-      use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          output_surface->context_provider(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kUseImageTextureTargets));
 
   gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0,
                             gpu::CommandBufferId::FromUnsafeValue(0x12), 0x34);
   const GLuint64 current_fence_sync = context->GetNextFenceSync();
   unsigned target = GL_TEXTURE_EXTERNAL_OES;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
   EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
   EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
   EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
@@ skipping 46 matching lines @@
 
   std::unique_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
-  std::unique_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, 1,
-      use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          output_surface->context_provider(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kUseImageTextureTargets));
 
   gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0,
                             gpu::CommandBufferId::FromUnsafeValue(0x12), 0x34);
   const GLuint64 current_fence_sync = context->GetNextFenceSync();
   unsigned target = GL_TEXTURE_2D;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
   EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
   EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
   EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
@@ skipping 32 matching lines @@
 
   std::unique_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
-  std::unique_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, 1,
-      use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          output_surface->context_provider(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kUseImageTextureTargets));
 
   gpu::SyncToken sync_token;
   const GLuint64 current_fence_sync = context->GetNextFenceSync();
   unsigned target = GL_TEXTURE_2D;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
   EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
   EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
   EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
 
@@ skipping 98 matching lines @@
     return;
   std::unique_ptr<AllocationTrackingContext3D> context_owned(
       new StrictMock<AllocationTrackingContext3D>);
   AllocationTrackingContext3D* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
-  std::unique_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, 1,
-      use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          output_surface->context_provider(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kUseImageTextureTargets));
 
   gfx::Size size(2, 2);
   gfx::Vector2d offset(0, 0);
   ResourceFormat format = RGBA_8888;
   ResourceId id = 0;
   uint8_t pixels[16] = { 0 };
   int texture_id = 123;
 
   // Lazy allocation. Don't allocate when creating the resource.
   id = resource_provider->CreateResource(
@@ skipping 32 matching lines @@
       new StrictMock<AllocationTrackingContext3D>);
   AllocationTrackingContext3D* context = context_owned.get();
   context->set_support_texture_storage(true);
   context->set_support_texture_usage(true);
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
-  std::unique_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, 1,
-      use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          output_surface->context_provider(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kUseImageTextureTargets));
 
   gfx::Size size(2, 2);
 
   const ResourceFormat formats[2] = {RGBA_8888, BGRA_8888};
   const ResourceProvider::TextureHint hints[4] = {
       ResourceProvider::TEXTURE_HINT_DEFAULT,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE,
       ResourceProvider::TEXTURE_HINT_FRAMEBUFFER,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER,
   };
@@ skipping 32 matching lines @@
   AllocationTrackingContext3D* context = context_owned.get();
   context->set_support_texture_format_bgra8888(true);
   context->set_support_texture_storage(true);
   context->set_support_texture_usage(true);
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
-  std::unique_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, 1,
-      use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          output_surface->context_provider(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kUseImageTextureTargets));
 
   gfx::Size size(2, 2);
   const ResourceFormat formats[2] = {RGBA_8888, BGRA_8888};
 
   const ResourceProvider::TextureHint hints[4] = {
       ResourceProvider::TEXTURE_HINT_DEFAULT,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE,
       ResourceProvider::TEXTURE_HINT_FRAMEBUFFER,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER,
   };
@@ skipping 35 matching lines @@
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   const int kWidth = 2;
   const int kHeight = 2;
   gfx::Size size(kWidth, kHeight);
   ResourceFormat format = RGBA_8888;
   ResourceId id = 0;
   const unsigned kTextureId = 123u;
   const unsigned kImageId = 234u;
 
-  std::unique_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, 1,
-      use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          output_surface->context_provider(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kUseImageTextureTargets));
 
   id = resource_provider->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
 
   EXPECT_CALL(*context, NextTextureId())
       .WillOnce(Return(kTextureId))
       .RetiresOnSaturation();
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId))
       .Times(3)
       .RetiresOnSaturation();
@@ skipping 54 matching lines @@
       new AllocationTrackingContext3D);
   AllocationTrackingContext3D* context = context_owned.get();
   context_owned->set_support_compressed_texture_etc1(true);
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   gfx::Size size(4, 4);
-  std::unique_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, 1,
-      use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          output_surface->context_provider(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kUseImageTextureTargets));
   int texture_id = 123;
 
   ResourceId id = resource_provider->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, ETC1);
   EXPECT_NE(0u, id);
   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
   resource_provider->AllocateForTesting(id);
 
   EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 }
 
 TEST_P(ResourceProviderTest, CompressedTextureETC1Upload) {
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
 
   std::unique_ptr<AllocationTrackingContext3D> context_owned(
       new AllocationTrackingContext3D);
   AllocationTrackingContext3D* context = context_owned.get();
   context_owned->set_support_compressed_texture_etc1(true);
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   gfx::Size size(4, 4);
-  std::unique_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
-      output_surface.get(), shared_bitmap_manager_.get(),
-      gpu_memory_buffer_manager_.get(), NULL, 0, 1,
-      use_gpu_memory_buffer_resources_, use_image_texture_targets_));
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          output_surface->context_provider(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 0, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kUseImageTextureTargets));
   int texture_id = 123;
   uint8_t pixels[8];
 
   ResourceId id = resource_provider->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, ETC1);
   EXPECT_NE(0u, id);
   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
   EXPECT_CALL(*context,
               compressedTexImage2D(
@@ skipping 34 matching lines @@
   CHECK(output_surface->BindToClient(&output_surface_client));
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
 
   {
     size_t kTextureAllocationChunkSize = 1;
     std::unique_ptr<ResourceProvider> resource_provider(
-        ResourceProvider::Create(
-            output_surface.get(), shared_bitmap_manager.get(), NULL, NULL, 0,
-            kTextureAllocationChunkSize,
-            ResourceProviderTest::use_gpu_memory_buffer_resources(),
-            ResourceProviderTest::use_image_texture_targets()));
+        base::MakeUnique<ResourceProvider>(
+            output_surface->context_provider(), shared_bitmap_manager.get(),
+            nullptr, nullptr, 0, kTextureAllocationChunkSize,
+            kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+            kUseImageTextureTargets));
 
     ResourceId id = resource_provider->CreateResource(
         size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
     resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(context);
 
     DCHECK_EQ(2u, context->PeekTextureId());
     resource_provider->DeleteResource(id);
   }
 
   {
     size_t kTextureAllocationChunkSize = 8;
     std::unique_ptr<ResourceProvider> resource_provider(
-        ResourceProvider::Create(
-            output_surface.get(), shared_bitmap_manager.get(), NULL, NULL, 0,
-            kTextureAllocationChunkSize,
-            ResourceProviderTest::use_gpu_memory_buffer_resources(),
-            ResourceProviderTest::use_image_texture_targets()));
+        base::MakeUnique<ResourceProvider>(
+            output_surface->context_provider(), shared_bitmap_manager.get(),
+            nullptr, nullptr, 0, kTextureAllocationChunkSize,
+            kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+            kUseImageTextureTargets));
 
     ResourceId id = resource_provider->CreateResource(
         size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
     resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(context);
 
     DCHECK_EQ(10u, context->PeekTextureId());
     resource_provider->DeleteResource(id);
   }
 }
@@ skipping 152 matching lines @@
     resource_provider_->DeclareUsedResourcesFromChild(child_id,
                                                       resource_ids_to_receive);
   }
   resource_provider_->DestroyChild(child_id);
 
   EXPECT_EQ(0u, resource_provider_->num_resources());
 }
 
 }  // namespace
 }  // namespace cc