Raster PictureLayerTiling with fractional translation

cc/raster/gpu_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/gpu_raster_buffer_provider.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
@@ skipping 16 matching lines @@
 
 namespace cc {
 namespace {
 
 static void RasterizeSource(
     const RasterSource* raster_source,
     bool resource_has_previous_content,
     const gfx::Size& resource_size,
     const gfx::Rect& raster_full_rect,
     const gfx::Rect& raster_dirty_rect,
-    float scale,
+    const ScaleTranslate2d& transform,
     const RasterSource::PlaybackSettings& playback_settings,
     ContextProvider* context_provider,
     ResourceProvider::ScopedWriteLockGL* resource_lock,
     bool async_worker_context_enabled,
     bool use_distance_field_text,
     int msaa_sample_count) {
   ScopedGpuRaster gpu_raster(context_provider);
 
   ResourceProvider::ScopedSkSurfaceProvider scoped_surface(
       context_provider, resource_lock, async_worker_context_enabled,
@@ skipping 24 matching lines @@
         static_cast<float>(playback_rect.size().GetArea()) / full_rect_size;
     float fraction_saved = 1.0f - fraction_partial_rastered;
     UMA_HISTOGRAM_PERCENTAGE(
         base::StringPrintf("Renderer4.%s.PartialRasterPercentageSaved.Gpu",
                            client_name),
         100.0f * fraction_saved);
   }
 
   raster_source->PlaybackToCanvas(
       sk_surface->getCanvas(), resource_lock->color_space_for_raster(),
-      raster_full_rect, playback_rect, scale, playback_settings);
+      raster_full_rect, playback_rect, transform, playback_settings);
 }
 
 }  // namespace
 
 GpuRasterBufferProvider::RasterBufferImpl::RasterBufferImpl(
     GpuRasterBufferProvider* client,
     ResourceProvider* resource_provider,
     ResourceId resource_id,
     bool async_worker_context_enabled,
     bool resource_has_previous_content)
     : client_(client),
       lock_(resource_provider, resource_id, async_worker_context_enabled),
       resource_has_previous_content_(resource_has_previous_content) {
   client_->pending_raster_buffers_.insert(this);
 }
 
 GpuRasterBufferProvider::RasterBufferImpl::~RasterBufferImpl() {
   client_->pending_raster_buffers_.erase(this);
 }
 
 void GpuRasterBufferProvider::RasterBufferImpl::Playback(
     const RasterSource* raster_source,
     const gfx::Rect& raster_full_rect,
     const gfx::Rect& raster_dirty_rect,
     uint64_t new_content_id,
-    float scale,
+    const ScaleTranslate2d& transform,
     const RasterSource::PlaybackSettings& playback_settings) {
   TRACE_EVENT0("cc", "GpuRasterBuffer::Playback");
   client_->PlaybackOnWorkerThread(&lock_, sync_token_,
                                   resource_has_previous_content_, raster_source,
                                   raster_full_rect, raster_dirty_rect,
-                                  new_content_id, scale, playback_settings);
+                                  new_content_id, transform, playback_settings);
 }
 
 GpuRasterBufferProvider::GpuRasterBufferProvider(
     ContextProvider* compositor_context_provider,
     ContextProvider* worker_context_provider,
     ResourceProvider* resource_provider,
     bool use_distance_field_text,
     int gpu_rasterization_msaa_sample_count,
     ResourceFormat preferred_tile_format,
     bool async_worker_context_enabled)
@@ skipping 120 matching lines @@
 }
 
 void GpuRasterBufferProvider::PlaybackOnWorkerThread(
     ResourceProvider::ScopedWriteLockGL* resource_lock,
     const gpu::SyncToken& sync_token,
     bool resource_has_previous_content,
     const RasterSource* raster_source,
     const gfx::Rect& raster_full_rect,
     const gfx::Rect& raster_dirty_rect,
     uint64_t new_content_id,
-    float scale,
+    const ScaleTranslate2d& transform,
     const RasterSource::PlaybackSettings& playback_settings) {
   ContextProvider::ScopedContextLock scoped_context(worker_context_provider_);
   gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
   DCHECK(gl);
 
   if (async_worker_context_enabled_) {
     // Early out if sync token is invalid. This happens if the compositor
     // context was lost before ScheduleTasks was called.
     if (!sync_token.HasData())
       return;
     // Synchronize with compositor.
     gl->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
   }
 
   RasterizeSource(raster_source, resource_has_previous_content,
                   resource_lock->size(), raster_full_rect, raster_dirty_rect,
-                  scale, playback_settings, worker_context_provider_,
+                  transform, playback_settings, worker_context_provider_,
                   resource_lock, async_worker_context_enabled_,
                   use_distance_field_text_, msaa_sample_count_);
 
   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_);
 }
 
 }  // namespace cc