cc::ResourcePool - Re-use larger resources for smaller requests

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>
@@ skipping 222 matching lines @@
 
   std::unique_ptr<StagingBuffer> staging_buffer =
       staging_pool_.AcquireStagingBuffer(resource, previous_content_id);
 
   PlaybackToStagingBuffer(
       staging_buffer.get(), resource, raster_source, raster_full_rect,
       raster_dirty_rect, transform, resource_lock->color_space_for_raster(),
       playback_settings, previous_content_id, new_content_id);
 
   CopyOnWorkerThread(staging_buffer.get(), resource_lock, sync_token,
-                     raster_source, previous_content_id, new_content_id);
+                     raster_source, raster_full_rect);
 
   staging_pool_.ReleaseStagingBuffer(std::move(staging_buffer));
 }
 
 void OneCopyRasterBufferProvider::PlaybackToStagingBuffer(
     StagingBuffer* staging_buffer,
     const Resource* resource,
     const RasterSource* raster_source,
     const gfx::Rect& raster_full_rect,
     const gfx::Rect& raster_dirty_rect,
@@ skipping 51 matching lines @@
     buffer->Unmap();
     staging_buffer->content_id = new_content_id;
   }
 }
 
 void OneCopyRasterBufferProvider::CopyOnWorkerThread(
     StagingBuffer* staging_buffer,
     ResourceProvider::ScopedWriteLockGL* resource_lock,
     const gpu::SyncToken& sync_token,
     const RasterSource* raster_source,
-    uint64_t previous_content_id,
-    uint64_t new_content_id) {
+    const gfx::Rect& rect_to_copy) {
   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(
@@ skipping 41 matching lines @@
 #endif
   }
 
   // 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);
   } else {
     int bytes_per_row = ResourceUtil::UncheckedWidthInBytes<int>(
-        resource_lock->size().width(), resource_lock->format());
+        rect_to_copy.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();
+    int height = rect_to_copy.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, 0, GL_TEXTURE_2D,
-                                 resource_texture_id, 0, 0, y, 0, y,
-                                 resource_lock->size().width(), rows_to_copy,
-                                 false, false, false);
+      gl->CopySubTextureCHROMIUM(
+          staging_buffer->texture_id, 0, GL_TEXTURE_2D, resource_texture_id, 0,
+          0, y, 0, y, rect_to_copy.width(), rows_to_copy, false, false, false);
       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;
       }
@@ skipping 20 matching lines @@
   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