Remove the concept of OutputSurface from ResourceProvider.

cc/resources/resource_provider.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 365 matching lines @@
 
 ResourceProvider::Child::Child()
     : gpu_memory_buffer_client_id(-1),
       marked_for_deletion(false),
       needs_sync_tokens(true) {}
 
 ResourceProvider::Child::Child(const Child& other) = default;
 
 ResourceProvider::Child::~Child() {}
 
-std::unique_ptr<ResourceProvider> ResourceProvider::Create(
-    OutputSurface* output_surface,
+ResourceProvider::ResourceProvider(
+    ContextProvider* compositor_context_provider,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     size_t id_allocation_chunk_size,
+    bool delegated_sync_points_required,
     bool use_gpu_memory_buffer_resources,
-    const std::vector<unsigned>& use_image_texture_targets) {
-  std::unique_ptr<ResourceProvider> resource_provider(new ResourceProvider(
-      output_surface, shared_bitmap_manager, gpu_memory_buffer_manager,
-      blocking_main_thread_task_runner, highp_threshold_min,
-      id_allocation_chunk_size, use_gpu_memory_buffer_resources,
-      use_image_texture_targets));
-  resource_provider->Initialize();
-  return resource_provider;
+    const std::vector<unsigned>& use_image_texture_targets)
+    : compositor_context_provider_(compositor_context_provider),
+      shared_bitmap_manager_(shared_bitmap_manager),
+      gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
+      blocking_main_thread_task_runner_(blocking_main_thread_task_runner),
+      lost_output_surface_(false),
+      highp_threshold_min_(highp_threshold_min),
+      next_id_(1),
+      next_child_(1),
+      delegated_sync_points_required_(delegated_sync_points_required),
+      default_resource_type_(use_gpu_memory_buffer_resources
+                                 ? RESOURCE_TYPE_GPU_MEMORY_BUFFER
+                                 : RESOURCE_TYPE_GL_TEXTURE),
+      use_texture_storage_ext_(false),
+      use_texture_format_bgra_(false),
+      use_texture_usage_hint_(false),
+      use_compressed_texture_etc1_(false),
+      yuv_resource_format_(LUMINANCE_8),
+      max_texture_size_(0),
+      best_texture_format_(RGBA_8888),
+      best_render_buffer_format_(RGBA_8888),
+      id_allocation_chunk_size_(id_allocation_chunk_size),
+      use_sync_query_(false),
+      use_image_texture_targets_(use_image_texture_targets),
+      tracing_id_(g_next_resource_provider_tracing_id.GetNext()) {
+  DCHECK(id_allocation_chunk_size_);
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // In certain cases, ThreadTaskRunnerHandle isn't set (Android Webview).
+  // Don't register a dump provider in these cases.
+  // TODO(ericrk): Get this working in Android Webview. crbug.com/517156
+  if (base::ThreadTaskRunnerHandle::IsSet()) {
+    base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+        this, "cc::ResourceProvider", base::ThreadTaskRunnerHandle::Get());
+  }
+
+  if (!compositor_context_provider_) {
+    default_resource_type_ = RESOURCE_TYPE_BITMAP;
+    // Pick an arbitrary limit here similar to what hardware might.
+    max_texture_size_ = 16 * 1024;
+    best_texture_format_ = RGBA_8888;
+    return;
+  }
+
+  DCHECK(!texture_id_allocator_);
+  DCHECK(!buffer_id_allocator_);
+
+  const auto& caps = compositor_context_provider_->ContextCapabilities();
+
+  DCHECK(IsGpuResourceType(default_resource_type_));
+  use_texture_storage_ext_ = caps.texture_storage;
+  use_texture_format_bgra_ = caps.texture_format_bgra8888;
+  use_texture_usage_hint_ = caps.texture_usage;
+  use_compressed_texture_etc1_ = caps.texture_format_etc1;
+  yuv_resource_format_ = caps.texture_rg ? RED_8 : LUMINANCE_8;
+  yuv_highbit_resource_format_ = yuv_resource_format_;
+  if (caps.texture_half_float_linear)
+    yuv_highbit_resource_format_ = LUMINANCE_F16;
+  use_sync_query_ = caps.sync_query;
+
+  GLES2Interface* gl = ContextGL();
+
+  max_texture_size_ = 0;  // Context expects cleared value.
+  gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size_);
+  best_texture_format_ =
+      PlatformColor::BestSupportedTextureFormat(use_texture_format_bgra_);
+
+  best_render_buffer_format_ = PlatformColor::BestSupportedTextureFormat(
+      caps.render_buffer_format_bgra8888);
+
+  texture_id_allocator_.reset(
+      new TextureIdAllocator(gl, id_allocation_chunk_size_));
+  buffer_id_allocator_.reset(
+      new BufferIdAllocator(gl, id_allocation_chunk_size_));
 }
 
 ResourceProvider::~ResourceProvider() {
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 
   while (!children_.empty())
     DestroyChildInternal(children_.begin(), FOR_SHUTDOWN);
   while (!resources_.empty())
     DeleteResourceInternal(resources_.begin(), FOR_SHUTDOWN);
@@ skipping 14 matching lines @@
   }
 #endif  // DCHECK_IS_ON()
 
   texture_id_allocator_ = nullptr;
   buffer_id_allocator_ = nullptr;
   gl->Finish();
 }
 
 bool ResourceProvider::IsResourceFormatSupported(ResourceFormat format) const {
   gpu::Capabilities caps;
-  if (output_surface_->context_provider())
-    caps = output_surface_->context_provider()->ContextCapabilities();
+  if (compositor_context_provider_)
+    caps = compositor_context_provider_->ContextCapabilities();
 
   switch (format) {
     case ALPHA_8:
     case RGBA_4444:
     case RGBA_8888:
     case RGB_565:
     case LUMINANCE_8:
       return true;
     case BGRA_8888:
       return caps.texture_format_bgra8888;
@@ skipping 703 matching lines @@
 ResourceProvider::ScopedWriteLockGr::~ScopedWriteLockGr() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(resource_->locked_for_write);
   if (set_sync_token_)
     resource_->UpdateSyncToken(sync_token_);
 
   resource_provider_->UnlockForWrite(resource_);
 }
 
 void ResourceProvider::ScopedWriteLockGr::InitSkSurface(
+    GrContext* gr_context,
     bool use_distance_field_text,
     bool can_use_lcd_text,
     int msaa_sample_count) {
   DCHECK(resource_->locked_for_write);
 
   GrGLTextureInfo texture_info;
   texture_info.fID = resource_->gl_id;
   texture_info.fTarget = resource_->target;
   GrBackendTextureDesc desc;
   desc.fFlags = kRenderTarget_GrBackendTextureFlag;
   desc.fWidth = resource_->size.width();
   desc.fHeight = resource_->size.height();
   desc.fConfig = ToGrPixelConfig(resource_->format);
   desc.fOrigin = kTopLeft_GrSurfaceOrigin;
   desc.fTextureHandle = skia::GrGLTextureInfoToGrBackendObject(texture_info);
   desc.fSampleCnt = msaa_sample_count;
 
-  bool use_worker_context = true;
-  class GrContext* gr_context =
-      resource_provider_->GrContext(use_worker_context);
   uint32_t flags =
       use_distance_field_text ? SkSurfaceProps::kUseDistanceFieldFonts_Flag : 0;
   // Use unknown pixel geometry to disable LCD text.
   SkSurfaceProps surface_props(flags, kUnknown_SkPixelGeometry);
   if (can_use_lcd_text) {
     // LegacyFontHost will get LCD text and skia figures out what type to use.
     surface_props =
         SkSurfaceProps(flags, SkSurfaceProps::kLegacyFontHost_InitType);
   }
   sk_surface_ = SkSurface::MakeFromBackendTextureAsRenderTarget(
@@ skipping 28 matching lines @@
 
 void ResourceProvider::SynchronousFence::Wait() {
   HasPassed();
 }
 
 void ResourceProvider::SynchronousFence::Synchronize() {
   TRACE_EVENT0("cc", "ResourceProvider::SynchronousFence::Synchronize");
   gl_->Finish();
 }
 
-ResourceProvider::ResourceProvider(
-    OutputSurface* output_surface,
-    SharedBitmapManager* shared_bitmap_manager,
-    gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-    BlockingTaskRunner* blocking_main_thread_task_runner,
-    int highp_threshold_min,
-    size_t id_allocation_chunk_size,
-    bool use_gpu_memory_buffer_resources,
-    const std::vector<unsigned>& use_image_texture_targets)
-    : output_surface_(output_surface),
-      shared_bitmap_manager_(shared_bitmap_manager),
-      gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
-      blocking_main_thread_task_runner_(blocking_main_thread_task_runner),
-      lost_output_surface_(false),
-      highp_threshold_min_(highp_threshold_min),
-      next_id_(1),
-      next_child_(1),
-      default_resource_type_(use_gpu_memory_buffer_resources
-                                 ? RESOURCE_TYPE_GPU_MEMORY_BUFFER
-                                 : RESOURCE_TYPE_GL_TEXTURE),
-      use_texture_storage_ext_(false),
-      use_texture_format_bgra_(false),
-      use_texture_usage_hint_(false),
-      use_compressed_texture_etc1_(false),
-      yuv_resource_format_(LUMINANCE_8),
-      max_texture_size_(0),
-      best_texture_format_(RGBA_8888),
-      best_render_buffer_format_(RGBA_8888),
-      id_allocation_chunk_size_(id_allocation_chunk_size),
-      use_sync_query_(false),
-      use_image_texture_targets_(use_image_texture_targets),
-      tracing_id_(g_next_resource_provider_tracing_id.GetNext()) {
-  DCHECK(output_surface_->HasClient());
-  DCHECK(id_allocation_chunk_size_);
-}
-
-void ResourceProvider::Initialize() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  // In certain cases, ThreadTaskRunnerHandle isn't set (Android Webview).
-  // Don't register a dump provider in these cases.
-  // TODO(ericrk): Get this working in Android Webview. crbug.com/517156
-  if (base::ThreadTaskRunnerHandle::IsSet()) {
-    base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
-        this, "cc::ResourceProvider", base::ThreadTaskRunnerHandle::Get());
-  }
-
-  GLES2Interface* gl = ContextGL();
-  if (!gl) {
-    default_resource_type_ = RESOURCE_TYPE_BITMAP;
-    // Pick an arbitrary limit here similar to what hardware might.
-    max_texture_size_ = 16 * 1024;
-    best_texture_format_ = RGBA_8888;
-    return;
-  }
-
-  DCHECK(!texture_id_allocator_);
-  DCHECK(!buffer_id_allocator_);
-
-  const gpu::Capabilities& caps =
-      output_surface_->context_provider()->ContextCapabilities();
-
-  DCHECK(IsGpuResourceType(default_resource_type_));
-  use_texture_storage_ext_ = caps.texture_storage;
-  use_texture_format_bgra_ = caps.texture_format_bgra8888;
-  use_texture_usage_hint_ = caps.texture_usage;
-  use_compressed_texture_etc1_ = caps.texture_format_etc1;
-  yuv_resource_format_ = caps.texture_rg ? RED_8 : LUMINANCE_8;
-  yuv_highbit_resource_format_ = yuv_resource_format_;
-  if (caps.texture_half_float_linear)
-    yuv_highbit_resource_format_ = LUMINANCE_F16;
-  use_sync_query_ = caps.sync_query;
-
-  max_texture_size_ = 0;  // Context expects cleared value.
-  gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size_);
-  best_texture_format_ =
-      PlatformColor::BestSupportedTextureFormat(use_texture_format_bgra_);
-
-  best_render_buffer_format_ = PlatformColor::BestSupportedTextureFormat(
-      caps.render_buffer_format_bgra8888);
-
-  texture_id_allocator_.reset(
-      new TextureIdAllocator(gl, id_allocation_chunk_size_));
-  buffer_id_allocator_.reset(
-      new BufferIdAllocator(gl, id_allocation_chunk_size_));
-}
-
 int ResourceProvider::CreateChild(const ReturnCallback& return_callback,
                                   int gpu_memory_buffer_client_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   Child child_info;
   child_info.return_callback = return_callback;
   child_info.gpu_memory_buffer_client_id = gpu_memory_buffer_client_id;
 
   int child = next_child_++;
   children_[child] = child_info;
@@ skipping 50 matching lines @@
   // This function goes through the array multiple times, store the resources
   // as pointers so we don't have to look up the resource id multiple times.
   std::vector<Resource*> resources;
   resources.reserve(resource_ids.size());
   for (const ResourceId id : resource_ids) {
     Resource* resource = GetResource(id);
     // Check the synchronization and sync token state when delegated sync points
     // are required. The only case where we allow a sync token to not be set is
     // the case where the image is dirty. In that case we will bind the image
     // lazily and generate a sync token at that point.
-    DCHECK(!output_surface_->capabilities().delegated_sync_points_required ||
-           resource->dirty_image || !resource->needs_sync_token());
+    DCHECK(!delegated_sync_points_required_ || resource->dirty_image ||
+           !resource->needs_sync_token());
 
     // If we are validating the resource to be sent, the resource cannot be
     // in a LOCALLY_USED state. It must have been properly synchronized.
-    DCHECK(!output_surface_->capabilities().delegated_sync_points_required ||
+    DCHECK(!delegated_sync_points_required_ ||
            Resource::LOCALLY_USED != resource->synchronization_state());
 
     resources.push_back(resource);
   }
 
   // Lazily create any mailboxes and verify all unverified sync tokens.
   std::vector<GLbyte*> unverified_sync_tokens;
   std::vector<Resource*> need_synchronization_resources;
   for (Resource* resource : resources) {
     CreateMailboxAndBindResource(gl, resource);
 
-    if (output_surface_->capabilities().delegated_sync_points_required &&
-        resource->needs_sync_token()) {
+    if (delegated_sync_points_required_ && resource->needs_sync_token()) {
       need_synchronization_resources.push_back(resource);
     } else if (resource->mailbox().HasSyncToken() &&
                !resource->mailbox().sync_token().verified_flush()) {
       unverified_sync_tokens.push_back(resource->GetSyncTokenData());
     }
   }
 
   // Insert sync point to synchronize the mailbox creation or bound textures.
   gpu::SyncToken new_sync_token;
   if (gl) {
@@ skipping 13 matching lines @@
     resource->UpdateSyncToken(new_sync_token);
     resource->SetSynchronized();
   }
 
   // Transfer Resources
   DCHECK_EQ(resources.size(), resource_ids.size());
   for (size_t i = 0; i < resources.size(); ++i) {
     Resource* source = resources[i];
     const ResourceId id = resource_ids[i];
 
-    DCHECK(!output_surface_->capabilities().delegated_sync_points_required ||
-           !source->needs_sync_token());
-    DCHECK(!output_surface_->capabilities().delegated_sync_points_required ||
+    DCHECK(!delegated_sync_points_required_ || !source->needs_sync_token());
+    DCHECK(!delegated_sync_points_required_ ||
            Resource::LOCALLY_USED != source->synchronization_state());
 
     TransferableResource resource;
     TransferResource(source, id, &resource);
 
     source->exported_count++;
     list->push_back(resource);
   }
 }
 
@@ skipping 476 matching lines @@
   return use_image_texture_targets_[static_cast<size_t>(buffer_format)];
 }
 
 void ResourceProvider::ValidateResource(ResourceId id) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(id);
   DCHECK(resources_.find(id) != resources_.end());
 }
 
 GLES2Interface* ResourceProvider::ContextGL() const {
-  ContextProvider* context_provider = output_surface_->context_provider();
+  ContextProvider* context_provider = compositor_context_provider_;
   return context_provider ? context_provider->ContextGL() : nullptr;
 }
 
-class GrContext* ResourceProvider::GrContext(bool worker_context) const {
-  ContextProvider* context_provider =
-      worker_context ? output_surface_->worker_context_provider()
-                     : output_surface_->context_provider();
-  return context_provider ? context_provider->GrContext() : nullptr;
-}
-
 bool ResourceProvider::IsGLContextLost() const {
   return ContextGL()->GetGraphicsResetStatusKHR() != GL_NO_ERROR;
 }
 
 bool ResourceProvider::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const uint64_t tracing_process_id =
@@ skipping 39 matching lines @@
     // prevent double counting the memory.
     base::trace_event::MemoryAllocatorDumpGuid guid;
     switch (resource.type) {
       case RESOURCE_TYPE_GPU_MEMORY_BUFFER:
         guid = gfx::GetGpuMemoryBufferGUIDForTracing(
             tracing_process_id, resource.gpu_memory_buffer->GetHandle().id);
         break;
       case RESOURCE_TYPE_GL_TEXTURE:
         DCHECK(resource.gl_id);
         guid = gfx::GetGLTextureClientGUIDForTracing(
-            output_surface_->context_provider()
-                ->ContextSupport()
+            compositor_context_provider_->ContextSupport()
                 ->ShareGroupTracingGUID(),
             resource.gl_id);
         break;
       case RESOURCE_TYPE_BITMAP:
         DCHECK(resource.has_shared_bitmap_id);
         guid = GetSharedBitmapGUIDForTracing(resource.shared_bitmap_id);
         break;
     }
 
     DCHECK(!guid.empty());
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc