Snapshot of all changes to get jumbo in blink and content.

cc/raster/zero_copy_raster_buffer_provider.cc

 // Copyright 2013 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/zero_copy_raster_buffer_provider.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/resource.h"
 #include "components/viz/common/resources/platform_color.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
 namespace cc {
 namespace {
 
-class RasterBufferImpl : public RasterBuffer {
+class ZeroCopyRasterBufferImpl : public RasterBuffer {
  public:
-  RasterBufferImpl(ResourceProvider* resource_provider,
+  ZeroCopyRasterBufferImpl(ResourceProvider* resource_provider,
                    const Resource* resource)
       : lock_(resource_provider, resource->id()), resource_(resource) {}
 
   // Overridden from RasterBuffer:
   void Playback(
       const RasterSource* raster_source,
       const gfx::Rect& raster_full_rect,
       const gfx::Rect& raster_dirty_rect,
       uint64_t new_content_id,
       const gfx::AxisTransform2d& transform,
@@ skipping 15 matching lines @@
         buffer->memory(0), resource_->format(), resource_->size(),
         buffer->stride(0), raster_source, raster_full_rect, raster_full_rect,
         transform, lock_.color_space_for_raster(), playback_settings);
     buffer->Unmap();
   }
 
  private:
   ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock_;
   const Resource* resource_;
 
-  DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
+  DISALLOW_COPY_AND_ASSIGN(ZeroCopyRasterBufferImpl);
 };
 
 }  // namespace
 
 // static
 std::unique_ptr<RasterBufferProvider> ZeroCopyRasterBufferProvider::Create(
     ResourceProvider* resource_provider,
     viz::ResourceFormat preferred_tile_format) {
   return base::WrapUnique<RasterBufferProvider>(
       new ZeroCopyRasterBufferProvider(resource_provider,
                                        preferred_tile_format));
 }
 
 ZeroCopyRasterBufferProvider::ZeroCopyRasterBufferProvider(
     ResourceProvider* resource_provider,
     viz::ResourceFormat preferred_tile_format)
     : resource_provider_(resource_provider),
       preferred_tile_format_(preferred_tile_format) {}
 
 ZeroCopyRasterBufferProvider::~ZeroCopyRasterBufferProvider() {}
 
 std::unique_ptr<RasterBuffer>
 ZeroCopyRasterBufferProvider::AcquireBufferForRaster(
     const Resource* resource,
     uint64_t resource_content_id,
     uint64_t previous_content_id) {
   return base::WrapUnique<RasterBuffer>(
-      new RasterBufferImpl(resource_provider_, resource));
+      new ZeroCopyRasterBufferImpl(resource_provider_, resource));
 }
 
 void ZeroCopyRasterBufferProvider::ReleaseBufferForRaster(
     std::unique_ptr<RasterBuffer> buffer) {
-  // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
+  // Nothing to do here. ZeroCopyRasterBufferImpl destructor cleans up
+  // after itself.
 }
 
 void ZeroCopyRasterBufferProvider::OrderingBarrier() {
   // No need to sync resources as this provider does not use GL context.
 }
 
 void ZeroCopyRasterBufferProvider::Flush() {}
 
 viz::ResourceFormat ZeroCopyRasterBufferProvider::GetResourceFormat(
     bool must_support_alpha) const {
@@ skipping 26 matching lines @@
     const ResourceProvider::ResourceIdArray& resource_ids,
     const base::Closure& callback,
     uint64_t pending_callback_id) const {
   // Zero-copy resources are immediately ready to draw.
   return 0;
 }
 
 void ZeroCopyRasterBufferProvider::Shutdown() {}
 
 }  // namespace cc