Revert of Re-land: cc: Use worker context for one-copy tile initialization.

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 <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
@@ skipping 14 matching lines @@
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrTextureProvider.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/vector2d.h"
+#include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gl/trace_util.h"
 
 using gpu::gles2::GLES2Interface;
 
 namespace cc {
 
 class IdAllocator {
  public:
   virtual ~IdAllocator() {}
 
@@ skipping 64 matching lines @@
       return kBGRA_8888_GrPixelConfig;
     case RGBA_4444:
       return kRGBA_4444_GrPixelConfig;
     default:
       break;
   }
   DCHECK(false) << "Unsupported resource format.";
   return kSkia8888_GrPixelConfig;
 }
 
+gfx::BufferFormat ToGpuMemoryBufferFormat(ResourceFormat format) {
+  switch (format) {
+    case RGBA_8888:
+      return gfx::BufferFormat::RGBA_8888;
+    case BGRA_8888:
+      return gfx::BufferFormat::BGRA_8888;
+    case RGBA_4444:
+      return gfx::BufferFormat::RGBA_4444;
+    case ALPHA_8:
+    case LUMINANCE_8:
+    case RGB_565:
+    case ETC1:
+    case RED_8:
+      break;
+  }
+  NOTREACHED();
+  return gfx::BufferFormat::RGBA_8888;
+}
+
 class ScopedSetActiveTexture {
  public:
   ScopedSetActiveTexture(GLES2Interface* gl, GLenum unit)
       : gl_(gl), unit_(unit) {
     DCHECK_EQ(GL_TEXTURE0, ResourceProvider::GetActiveTextureUnit(gl_));
 
     if (unit_ != GL_TEXTURE0)
       gl_->ActiveTexture(unit_);
   }
 
@@ skipping 50 matching lines @@
       next_id_index_ = 0;
     }
 
     return ids_[next_id_index_++];
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BufferIdAllocator);
 };
 
+// Query object based fence implementation used to detect completion of copy
+// texture operations. Fence has passed when query result is available.
+class CopyTextureFence : public ResourceProvider::Fence {
+ public:
+  CopyTextureFence(gpu::gles2::GLES2Interface* gl, unsigned query_id)
+      : gl_(gl), query_id_(query_id) {}
+
+  // Overridden from ResourceProvider::Fence:
+  void Set() override {}
+  bool HasPassed() override {
+    unsigned available = 1;
+    gl_->GetQueryObjectuivEXT(
+        query_id_, GL_QUERY_RESULT_AVAILABLE_EXT, &available);
+    if (!available)
+      return false;
+
+    ProcessResult();
+    return true;
+  }
+  void Wait() override {
+    // ProcessResult() will wait for result to become available.
+    ProcessResult();
+  }
+
+ private:
+  ~CopyTextureFence() override {}
+
+  void ProcessResult() {
+    unsigned time_elapsed_us = 0;
+    gl_->GetQueryObjectuivEXT(query_id_, GL_QUERY_RESULT_EXT, &time_elapsed_us);
+    UMA_HISTOGRAM_CUSTOM_COUNTS("Renderer4.CopyTextureLatency", time_elapsed_us,
+                                0, 256000, 50);
+  }
+
+  gpu::gles2::GLES2Interface* gl_;
+  unsigned query_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(CopyTextureFence);
+};
+
 }  // namespace
 
 ResourceProvider::Resource::~Resource() {}
 
 ResourceProvider::Resource::Resource(GLuint texture_id,
                                      const gfx::Size& size,
                                      Origin origin,
                                      GLenum target,
                                      GLenum filter,
                                      GLenum texture_pool,
@@ skipping 131 matching lines @@
 ResourceProvider::Child::~Child() {}
 
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     bool use_rgba_4444_texture_format,
     size_t id_allocation_chunk_size,
+    bool use_persistent_map_for_gpu_memory_buffers,
     const std::vector<unsigned>& use_image_texture_targets) {
   scoped_ptr<ResourceProvider> resource_provider(new ResourceProvider(
       output_surface, shared_bitmap_manager, gpu_memory_buffer_manager,
       blocking_main_thread_task_runner, highp_threshold_min,
       use_rgba_4444_texture_format, id_allocation_chunk_size,
-      use_image_texture_targets));
+      use_persistent_map_for_gpu_memory_buffers, use_image_texture_targets));
   resource_provider->Initialize();
   return resource_provider;
 }
 
 ResourceProvider::~ResourceProvider() {
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 
   while (!children_.empty())
     DestroyChildInternal(children_.begin(), FOR_SHUTDOWN);
@@ skipping 570 matching lines @@
   // GpuMemoryBuffer provides direct access to the memory used by the GPU.
   // Read lock fences are required to ensure that we're not trying to map a
   // buffer that is currently in-use by the GPU.
   resource_->read_lock_fences_enabled = true;
 }
 
 gfx::GpuMemoryBuffer*
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() {
   if (gpu_memory_buffer_)
     return gpu_memory_buffer_;
+  gfx::BufferUsage usage =
+      resource_provider_->use_persistent_map_for_gpu_memory_buffers()
+          ? gfx::BufferUsage::PERSISTENT_MAP
+          : gfx::BufferUsage::MAP;
   scoped_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer =
       gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
-          size_, BufferFormat(format_), gfx::BufferUsage::MAP);
+          size_, ToGpuMemoryBufferFormat(format_), usage);
   gpu_memory_buffer_ = gpu_memory_buffer.release();
   return gpu_memory_buffer_;
 }
 
 ResourceProvider::ScopedWriteLockGr::ScopedWriteLockGr(
     ResourceProvider* resource_provider,
     ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_(resource_provider->LockForWrite(resource_id)) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 71 matching lines @@
 }
 
 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,
     bool use_rgba_4444_texture_format,
     size_t id_allocation_chunk_size,
+    bool use_persistent_map_for_gpu_memory_buffers,
     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_(RESOURCE_TYPE_BITMAP),
       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),
       use_rgba_4444_texture_format_(use_rgba_4444_texture_format),
       id_allocation_chunk_size_(id_allocation_chunk_size),
+      use_sync_query_(false),
+      use_persistent_map_for_gpu_memory_buffers_(
+          use_persistent_map_for_gpu_memory_buffers),
       use_image_texture_targets_(use_image_texture_targets) {
   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.
@@ skipping 714 matching lines @@
   DCHECK(resource->image_id);
 
   // Release image currently bound to texture.
   if (resource->bound_image_id)
     gl->ReleaseTexImage2DCHROMIUM(resource->target, resource->bound_image_id);
   gl->BindTexImage2DCHROMIUM(resource->target, resource->image_id);
   resource->bound_image_id = resource->image_id;
   resource->dirty_image = false;
 }
 
+void ResourceProvider::CopyResource(ResourceId source_id,
+                                    ResourceId dest_id,
+                                    const gfx::Rect& rect) {
+  TRACE_EVENT0("cc", "ResourceProvider::CopyResource");
+
+  Resource* source_resource = GetResource(source_id);
+  DCHECK(!source_resource->lock_for_read_count);
+  DCHECK(source_resource->origin == Resource::INTERNAL);
+  DCHECK_EQ(source_resource->exported_count, 0);
+  DCHECK_EQ(RESOURCE_TYPE_GL_TEXTURE, source_resource->type);
+  LazyAllocate(source_resource);
+
+  Resource* dest_resource = GetResource(dest_id);
+  DCHECK(!dest_resource->locked_for_write);
+  DCHECK(!dest_resource->lock_for_read_count);
+  DCHECK(dest_resource->origin == Resource::INTERNAL);
+  DCHECK_EQ(dest_resource->exported_count, 0);
+  DCHECK_EQ(RESOURCE_TYPE_GL_TEXTURE, dest_resource->type);
+  LazyAllocate(dest_resource);
+
+  DCHECK_EQ(source_resource->type, dest_resource->type);
+  DCHECK_EQ(source_resource->format, dest_resource->format);
+  DCHECK(source_resource->size == dest_resource->size);
+  DCHECK(gfx::Rect(dest_resource->size).Contains(rect));
+
+  GLES2Interface* gl = ContextGL();
+  DCHECK(gl);
+  if (source_resource->image_id && source_resource->dirty_image) {
+    gl->BindTexture(source_resource->target, source_resource->gl_id);
+    BindImageForSampling(source_resource);
+  }
+  if (use_sync_query_) {
+    if (!source_resource->gl_read_lock_query_id)
+      gl->GenQueriesEXT(1, &source_resource->gl_read_lock_query_id);
+#if defined(OS_CHROMEOS)
+    // TODO(reveman): This avoids a performance problem on some ChromeOS
+    // devices. This needs to be removed to support native GpuMemoryBuffer
+    // implementations. crbug.com/436314
+    gl->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM,
+                      source_resource->gl_read_lock_query_id);
+#else
+    gl->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM,
+                      source_resource->gl_read_lock_query_id);
+#endif
+  }
+  DCHECK(!dest_resource->image_id);
+  dest_resource->allocated = true;
+  gl->CopySubTextureCHROMIUM(dest_resource->target, source_resource->gl_id,
+                             dest_resource->gl_id, rect.x(), rect.y(), rect.x(),
+                             rect.y(), rect.width(), rect.height(),
+                             false, false, false);
+  if (source_resource->gl_read_lock_query_id) {
+    // End query and create a read lock fence that will prevent access to
+// source resource until CopySubTextureCHROMIUM command has completed.
+#if defined(OS_CHROMEOS)
+    gl->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
+#else
+    gl->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM);
+#endif
+    source_resource->read_lock_fence = make_scoped_refptr(
+        new CopyTextureFence(gl, source_resource->gl_read_lock_query_id));
+  } else {
+    // Create a SynchronousFence when CHROMIUM_sync_query extension is missing.
+    // Try to use one synchronous fence for as many CopyResource operations as
+    // possible as that reduce the number of times we have to synchronize with
+    // the GL.
+    if (!synchronous_fence_.get() || synchronous_fence_->has_synchronized())
+      synchronous_fence_ = make_scoped_refptr(new SynchronousFence(gl));
+    source_resource->read_lock_fence = synchronous_fence_;
+    source_resource->read_lock_fence->Set();
+  }
+}
+
 void ResourceProvider::WaitSyncPointIfNeeded(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(resource->allocated);
   if (resource->type != RESOURCE_TYPE_GL_TEXTURE || resource->gl_id)
     return;
   if (!resource->mailbox.sync_point())
     return;
   DCHECK(resource->mailbox.IsValid());
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
   gl->WaitSyncPointCHROMIUM(resource->mailbox.sync_point());
   resource->mailbox.set_sync_point(0);
 }
 
+void ResourceProvider::WaitReadLockIfNeeded(ResourceId id) {
+  Resource* resource = GetResource(id);
+  DCHECK_EQ(resource->exported_count, 0);
+  if (!resource->read_lock_fence.get())
+    return;
+
+  resource->read_lock_fence->Wait();
+}
+
 GLint ResourceProvider::GetActiveTextureUnit(GLES2Interface* gl) {
   GLint active_unit = 0;
   gl->GetIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 GLenum ResourceProvider::GetImageTextureTarget(ResourceFormat format) {
-  gfx::BufferFormat buffer_format = BufferFormat(format);
+  gfx::BufferFormat buffer_format = ToGpuMemoryBufferFormat(format);
   DCHECK_GT(use_image_texture_targets_.size(),
             static_cast<size_t>(buffer_format));
   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());
 }
@@ skipping 52 matching lines @@
       const int kImportance = 2;
       pmd->CreateSharedGlobalAllocatorDump(guid);
       pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
     }
   }
 
   return true;
 }
 
 }  // namespace cc