[4/5] Add translated rasterization support for PictureLayerTilingSet & below

cc/tiles/tile_manager.cc

 // Copyright 2012 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/tiles/tile_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 81 matching lines @@
                  std::unique_ptr<RasterBuffer> raster_buffer,
                  TileTask::Vector* dependencies,
                  bool is_gpu_rasterization)
       : TileTask(!is_gpu_rasterization, dependencies),
         tile_manager_(tile_manager),
         tile_id_(tile->id()),
         resource_(resource),
         raster_source_(std::move(raster_source)),
         content_rect_(tile->content_rect()),
         invalid_content_rect_(invalidated_rect),
-        raster_scale_(tile->contents_scale()),
+        raster_transform_(tile->raster_transform()),
         playback_settings_(playback_settings),
         tile_resolution_(tile_resolution),
         layer_id_(tile->layer_id()),
         source_prepare_tiles_id_(source_prepare_tiles_id),
         tile_tracing_id_(static_cast<void*>(tile)),
         new_content_id_(tile->id()),
         source_frame_number_(tile->source_frame_number()),
         is_gpu_rasterization_(is_gpu_rasterization),
         raster_buffer_(std::move(raster_buffer)) {
     DCHECK(origin_thread_checker_.CalledOnValidThread());
   }
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT1("cc", "RasterizerTaskImpl::RunOnWorkerThread",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
 
     DCHECK(raster_source_.get());
     DCHECK(raster_buffer_);
 
     frame_viewer_instrumentation::ScopedRasterTask raster_task(
         tile_tracing_id_, tile_resolution_, source_frame_number_, layer_id_);
     ScopedRasterTaskTimer timer(is_gpu_rasterization_);
     timer.SetArea(content_rect_.size().GetArea());
 
     DCHECK(raster_source_);
 
-    raster_buffer_->Playback(
-        raster_source_.get(), content_rect_, invalid_content_rect_,
-        new_content_id_, gfx::AxisTransform2d(raster_scale_, gfx::Vector2dF()),
-        playback_settings_);
+    raster_buffer_->Playback(raster_source_.get(), content_rect_,
+                             invalid_content_rect_, new_content_id_,
+                             raster_transform_, playback_settings_);
   }
 
   // Overridden from TileTask:
   void OnTaskCompleted() override {
     DCHECK(origin_thread_checker_.CalledOnValidThread());
 
     // Here calling state().IsCanceled() is thread-safe, because this task is
     // already concluded as FINISHED or CANCELLED and no longer will be worked
     // upon by task graph runner.
     tile_manager_->OnRasterTaskCompleted(std::move(raster_buffer_), tile_id_,
@@ skipping 13 matching lines @@
   // origin thread. These are not thread-safe and should be accessed only in
   // origin thread. Ensure their access by checking CalledOnValidThread().
   TileManager* tile_manager_;
   Tile::Id tile_id_;
   Resource* resource_;
 
   // The following members should be used for running the task.
   scoped_refptr<RasterSource> raster_source_;
   gfx::Rect content_rect_;
   gfx::Rect invalid_content_rect_;
-  float raster_scale_;
+  gfx::AxisTransform2d raster_transform_;
   RasterSource::PlaybackSettings playback_settings_;
   TileResolution tile_resolution_;
   int layer_id_;
   uint64_t source_prepare_tiles_id_;
   void* tile_tracing_id_;
   uint64_t new_content_id_;
   int source_frame_number_;
   bool is_gpu_rasterization_;
   std::unique_ptr<RasterBuffer> raster_buffer_;
 
@@ skipping 481 matching lines @@
 
     bool tile_is_needed_now = priority.priority_bin == TilePriority::NOW;
     if (!tile->is_solid_color_analysis_performed() &&
         tile->use_picture_analysis() && kUseColorEstimator) {
       // We analyze for solid color here, to decide to continue
       // or drop the tile for scheduling and raster.
       // TODO(sohanjg): Check if we could use a shared analysis
       // canvas which is reset between tiles.
       tile->set_solid_color_analysis_performed(true);
       SkColor color = SK_ColorTRANSPARENT;
+      gfx::RectF layer_rect = tile->raster_transform().InverseMapRect(
+          gfx::RectF(tile->content_rect()));
       bool is_solid_color =
           prioritized_tile.raster_source()->PerformSolidColorAnalysis(
-              tile->content_rect(), tile->contents_scale(), &color);
+              gfx::ToEnclosingRect(layer_rect), 1.f, &color);
       if (is_solid_color) {
         tile->draw_info().set_solid_color(color);
         client_->NotifyTileStateChanged(tile);
         continue;
       }
     }
 
     // Prepaint tiles that are far away are only processed for images.
     if (!tile->required_for_activation() && !tile->required_for_draw() &&
         prioritized_tile.is_process_for_images_only()) {
@@ skipping 176 matching lines @@
   const std::vector<PrioritizedTile>& tiles_to_process_for_images =
       work_to_schedule.tiles_to_process_for_images;
   std::vector<DrawImage> new_locked_images;
   for (const PrioritizedTile& prioritized_tile : tiles_to_process_for_images) {
     Tile* tile = prioritized_tile.tile();
 
     // TODO(khushalsagar): Send these images to the ImageDecodeService, through
     // the CheckerImageTracker as well. See crbug.com/691087.
     std::vector<DrawImage> images;
     prioritized_tile.raster_source()->GetDiscardableImagesInRect(
-        tile->enclosing_layer_rect(), tile->contents_scale(),
+        tile->enclosing_layer_rect(), tile->raster_transform().scale(),
         raster_color_space, &images);
     new_locked_images.insert(new_locked_images.end(), images.begin(),
                              images.end());
   }
 
   // TODO(vmpstr): SOON is misleading here, but these images can come from
   // several diffent tiles. Rethink what we actually want to trace here. Note
   // that I'm using SOON, since it can't be NOW (these are prepaint).
   ImageDecodeCache::TracingInfo tracing_info(prepare_tiles_count_,
                                              TilePriority::SOON);
@@ skipping 84 matching lines @@
   playback_settings.skip_images =
       prioritized_tile.priority().resolution == LOW_RESOLUTION;
 
   // Create and queue all image decode tasks that this tile depends on.
   TileTask::Vector decode_tasks;
   std::vector<DrawImage>& images = scheduled_draw_images_[tile->id()];
   ImageIdFlatSet images_to_skip;
   images.clear();
   if (!playback_settings.skip_images) {
     prioritized_tile.raster_source()->GetDiscardableImagesInRect(
-        tile->enclosing_layer_rect(), tile->contents_scale(), color_space,
-        &images);
+        tile->enclosing_layer_rect(), tile->raster_transform().scale(),
+        color_space, &images);
     checker_image_tracker_.FilterImagesForCheckeringForTile(
         &images, &images_to_skip, prioritized_tile.tile()->tiling()->tree());
   }
 
   // We can skip the image hijack canvas if we have no images, or no images to
   // skip during raster.
   playback_settings.use_image_hijack_canvas =
       !images.empty() || !images_to_skip.empty();
   playback_settings.images_to_skip = std::move(images_to_skip);
 
@@ skipping 392 matching lines @@
 
   // Use a custom tile_as_value, instead of Tile::AsValueInto, since we don't
   // need all of the state that would be captured by other functions.
   auto tile_as_value = [](const PrioritizedTile& prioritized_tile,
                           base::trace_event::TracedValue* value) {
     Tile* tile = prioritized_tile.tile();
     TilePriority priority = prioritized_tile.priority();
 
     value->SetInteger("id", tile->id());
     value->SetString("content_rect", tile->content_rect().ToString());
-    value->SetDouble("contents_scale", tile->contents_scale());
+    value->SetDouble("contents_scale", tile->contents_scale_key());
     value->SetBoolean("is_ready_to_draw", tile->draw_info().IsReadyToDraw());
     value->SetString("resolution", TileResolutionToString(priority.resolution));
     value->SetString("priority_bin",
                      TilePriorityBinToString(priority.priority_bin));
     value->SetDouble("distance_to_visible", priority.distance_to_visible);
     value->SetBoolean("required_for_activation",
                       tile->required_for_activation());
     value->SetBoolean("required_for_draw", tile->required_for_draw());
   };
 
@@ skipping 99 matching lines @@
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default;
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule(
     PrioritizedWorkToSchedule&& other) = default;
 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default;
 
 }  // namespace cc