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>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/histograms.h"
+#include "cc/base/scale_translate2d.h"
 #include "cc/playback/image_hijack_canvas.h"
 #include "cc/playback/raster_source.h"
 #include "cc/raster/scoped_gpu_raster.h"
 #include "cc/resources/resource.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/skia/include/core/SkMultiPictureDraw.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 
 namespace cc {
 namespace {
 
 static sk_sp<SkPicture> PlaybackToPicture(
     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) {
   // GPU raster doesn't do low res tiles, so should always include images.
   DCHECK(!playback_settings.skip_images);
 
   gfx::Rect playback_rect = raster_full_rect;
   if (resource_has_previous_content) {
     playback_rect.Intersect(raster_dirty_rect);
   }
   DCHECK(!playback_rect.IsEmpty())
       << "Why are we rastering a tile that's not dirty?";
@@ skipping 10 matching lines @@
         base::StringPrintf("Renderer4.%s.PartialRasterPercentageSaved.Gpu",
                            client_name),
         100.0f * fraction_saved);
   }
 
   // Play back raster_source into temp SkPicture.
   SkPictureRecorder recorder;
   sk_sp<SkCanvas> canvas = sk_ref_sp(
       recorder.beginRecording(resource_size.width(), resource_size.height()));
   canvas->save();
+  canvas->translate(-raster_full_rect.x(), -raster_full_rect.y());
+  canvas->clipRect(gfx::RectToSkRect(playback_rect));
+  transform.ApplyToCanvas(canvas.get());
 
   // The GPU image decode controller assumes that Skia is done with an image
   // when playback is complete. However, in this case, where we play back to a
   // picture, we don't actually finish with the images until the picture is
   // rasterized later. This can cause lifetime issues in the GPU image decode
   // controller. To avoid this, we disable the image hijack canvas (and image
   // decode controller) for this playback step, instead enabling it for the
   // later picture rasterization.
   RasterSource::PlaybackSettings settings = playback_settings;
   settings.use_image_hijack_canvas = false;
   raster_source->PlaybackToCanvas(canvas.get(), raster_full_rect, playback_rect,
-                                  scale, settings);
+                                  transform, settings);
   canvas->restore();
   return recorder.finishRecordingAsPicture();
 }
 
 static void RasterizePicture(SkPicture* picture,
                              ContextProvider* context_provider,
                              ResourceProvider::ScopedWriteLockGL* resource_lock,
                              bool async_worker_context_enabled,
                              bool use_distance_field_text,
                              bool can_use_lcd_text,
@@ skipping 51 matching lines @@
 
 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,
     bool async_worker_context_enabled)
     : compositor_context_provider_(compositor_context_provider),
@@ skipping 71 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());
   }
 
   sk_sp<SkPicture> picture = PlaybackToPicture(
       raster_source, resource_has_previous_content, resource_lock->size(),
-      raster_full_rect, raster_dirty_rect, scale, playback_settings);
+      raster_full_rect, raster_dirty_rect, transform, playback_settings);
 
   // Turn on distance fields for layers that have ever animated.
   bool use_distance_field_text =
       use_distance_field_text_ ||
       raster_source->ShouldAttemptToUseDistanceFieldText();
 
   RasterizePicture(picture.get(), worker_context_provider_, resource_lock,
                    async_worker_context_enabled_, use_distance_field_text,
                    raster_source->CanUseLCDText(), msaa_sample_count_,
                    raster_source->image_decode_controller(),
                    playback_settings.use_image_hijack_canvas);
 
   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