cc: Use CHROMIUM_copy_image for one-copy tile updates.

cc/raster/one_copy_raster_buffer_provider.cc

 // Copyright 2014 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/one_copy_raster_buffer_provider.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/histograms.h"
 #include "cc/base/math_util.h"
 #include "cc/resources/platform_color.h"
 #include "cc/resources/resource_format.h"
 #include "cc/resources/resource_util.h"
 #include "cc/resources/scoped_resource.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "ui/gfx/buffer_format_util.h"
+#include "ui/gfx/gpu_fence.h"
 
 namespace cc {
 namespace {
 
 // 4MiB is the size of 4 512x512 tiles, which has proven to be a good
 // default batch size for copy operations.
 const int kMaxBytesPerCopyOperation = 1024 * 1024 * 4;
 
 }  // namespace
 
@@ skipping 181 matching lines @@
   // Allocate GpuMemoryBuffer if necessary. If using partial raster, we
   // must allocate a buffer with BufferUsage CPU_READ_WRITE_PERSISTENT.
   if (!staging_buffer->gpu_memory_buffer) {
     staging_buffer->gpu_memory_buffer =
         resource_provider_->gpu_memory_buffer_manager()
             ->AllocateGpuMemoryBuffer(
                 staging_buffer->size, BufferFormat(resource->format()),
                 StagingBufferUsage(), gpu::kNullSurfaceHandle);
   }
 
+  // Allocate GpuFence if necessary.
+  if (!staging_buffer->gpu_fence) {
+    staging_buffer->gpu_fence =
+        resource_provider_->gpu_memory_buffer_manager()->CreateGpuFence();
+  }
+
   gfx::Rect playback_rect = raster_full_rect;
   if (use_partial_raster_ && previous_content_id) {
     // Reduce playback rect to dirty region if the content id of the staging
     // buffer matches the prevous content id.
     if (previous_content_id == staging_buffer->content_id)
       playback_rect.Intersect(raster_dirty_rect);
   }
 
   // Log a histogram of the percentage of pixels that were saved due to
   // partial raster.
@@ skipping 38 matching lines @@
     uint64_t new_content_id) {
   ContextProvider::ScopedContextLock scoped_context(worker_context_provider_);
   gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
   DCHECK(gl);
 
   // Create texture after synchronizing with compositor.
   ResourceProvider::ScopedTextureProvider scoped_texture(
       gl, resource_lock, async_worker_context_enabled_);
 
   unsigned resource_texture_id = scoped_texture.texture_id();
-  unsigned image_target = resource_provider_->GetImageTextureTarget(
-      StagingBufferUsage(), staging_buffer->format);
 
-  // Create and bind staging texture.
-  if (!staging_buffer->texture_id) {
-    gl->GenTextures(1, &staging_buffer->texture_id);
-    gl->BindTexture(image_target, staging_buffer->texture_id);
-    gl->TexParameteri(image_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    gl->TexParameteri(image_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    gl->TexParameteri(image_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    gl->TexParameteri(image_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  } else {
-    gl->BindTexture(image_target, staging_buffer->texture_id);
-  }
-
-  // Create and bind image.
+  // Create image.
   if (!staging_buffer->image_id) {
     if (staging_buffer->gpu_memory_buffer) {
       staging_buffer->image_id = gl->CreateImageCHROMIUM(
           staging_buffer->gpu_memory_buffer->AsClientBuffer(),
           staging_buffer->size.width(), staging_buffer->size.height(),
           GLInternalFormat(resource_lock->format()));
-      gl->BindTexImage2DCHROMIUM(image_target, staging_buffer->image_id, 0);
     }
-  } else {
-    gl->ReleaseTexImage2DCHROMIUM(image_target, staging_buffer->image_id);
-    gl->BindTexImage2DCHROMIUM(image_target, staging_buffer->image_id, 0);
   }
 
-  // Unbind staging texture.
-  gl->BindTexture(image_target, 0);
+  // GpuFence must be reset.
+  DCHECK(!staging_buffer->gpu_fence ||
+         !staging_buffer->gpu_fence->IsSignaled());
 
-  if (resource_provider_->use_sync_query()) {
-    if (!staging_buffer->query_id)
-      gl->GenQueriesEXT(1, &staging_buffer->query_id);
-
-#if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
-    // TODO(reveman): This avoids a performance problem on ARM ChromeOS
-    // devices. crbug.com/580166
-    gl->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM, staging_buffer->query_id);
-#else
-    gl->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM, staging_buffer->query_id);
-#endif
+  // Create fence.
+  if (!staging_buffer->fence_id) {
+    if (staging_buffer->gpu_fence) {
+      staging_buffer->fence_id =
+          gl->CreateFenceCHROMIUM(staging_buffer->gpu_fence->AsClientFence());
+    }
   }
 
   // Since compressed texture's cannot be pre-allocated we might have an
   // unallocated resource in which case we need to perform a full size copy.
   if (IsResourceFormatCompressed(resource_lock->format())) {
-    gl->CompressedCopyTextureCHROMIUM(staging_buffer->texture_id,
-                                      resource_texture_id);
+    gl->CopyImageSubDataCHROMIUM(staging_buffer->image_id, resource_texture_id,

[ericrk, 2017/01/10 03:50:31]

Internally (if I traced through the code correctly), it looks like we end up
issuing a glCompressedTexSubImage2D rather than the previous
glCompressedTexImage2D. I assume this is fine, but after reading the above
comment I wanted to double check that calling SubImage with the full image rect
is fine wrt/ dealing with an unallocated resource.

[reveman, 2017/01/10 19:37:55]

We might need to add some special code for this on the service side or do an
initial CompressedTexImage2D call here to make this work. I'll make sure this
works correctly before we get to a point where this can land.

+                                 0, 0, 0, 0, resource_lock->size().width(),
+                                 resource_lock->size().height(), 0,
+                                 staging_buffer->fence_id);
   } else {
     int bytes_per_row = ResourceUtil::UncheckedWidthInBytes<int>(
         resource_lock->size().width(), resource_lock->format());
     int chunk_size_in_rows =
         std::max(1, max_bytes_per_copy_operation_ / bytes_per_row);
     // Align chunk size to 4. Required to support compressed texture formats.
     chunk_size_in_rows = MathUtil::UncheckedRoundUp(chunk_size_in_rows, 4);
     int y = 0;
     int height = resource_lock->size().height();
     while (y < height) {
       // Copy at most |chunk_size_in_rows|.
       int rows_to_copy = std::min(chunk_size_in_rows, height - y);
       DCHECK_GT(rows_to_copy, 0);
 
-      gl->CopySubTextureCHROMIUM(
-          staging_buffer->texture_id, resource_texture_id, 0, y, 0, y,
-          resource_lock->size().width(), rows_to_copy, false, false, false);
+      gl->CopyImageSubDataCHROMIUM(staging_buffer->image_id,
+                                   resource_texture_id, 0, y, 0, y,
+                                   resource_lock->size().width(), rows_to_copy,
+                                   0, staging_buffer->fence_id);
+
       y += rows_to_copy;
 
       // Increment |bytes_scheduled_since_last_flush_| by the amount of memory
       // used for this copy operation.
       bytes_scheduled_since_last_flush_ += rows_to_copy * bytes_per_row;
 
       if (bytes_scheduled_since_last_flush_ >= max_bytes_per_copy_operation_) {
         gl->ShallowFlushCHROMIUM();
         bytes_scheduled_since_last_flush_ = 0;
       }
     }
   }
 
-  if (resource_provider_->use_sync_query()) {
-#if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
-    gl->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
-#else
-    gl->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM);
-#endif
-  }
-
   const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
 
   // Barrier to sync worker context output to cc context.
   gl->OrderingBarrierCHROMIUM();
 
   // Generate sync token after the barrier for cross context synchronization.
   gpu::SyncToken resource_sync_token;
   gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, resource_sync_token.GetData());
   resource_lock->set_sync_token(resource_sync_token);
   resource_lock->set_synchronized(!async_worker_context_enabled_);
 }
 
 gfx::BufferUsage OneCopyRasterBufferProvider::StagingBufferUsage() const {
   return use_partial_raster_
              ? gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT
              : gfx::BufferUsage::GPU_READ_CPU_READ_WRITE;
 }
 
 }  // namespace cc