cc: Add checker-imaging support to TileManager.

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 329 matching lines @@
   state->SetInteger("canceled_count",
                     base::saturated_cast<int>(stats.canceled_count));
   return std::move(state);
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     base::SequencedTaskRunner* origin_task_runner,
     scoped_refptr<base::SequencedTaskRunner> image_worker_task_runner,
     size_t scheduled_raster_task_limit,
-    bool use_partial_raster,
-    bool check_tile_priority_inversion)
+    const TileManagerSettings& tile_manager_settings)
     : client_(client),
       task_runner_(origin_task_runner),
       resource_pool_(nullptr),
       tile_task_manager_(nullptr),
       scheduled_raster_task_limit_(scheduled_raster_task_limit),
-      use_partial_raster_(use_partial_raster),
+      tile_manager_settings_(tile_manager_settings),
       use_gpu_rasterization_(false),
       all_tiles_that_need_to_be_rasterized_are_scheduled_(true),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
       did_oom_on_last_assign_(false),
       image_controller_(origin_task_runner,
                         std::move(image_worker_task_runner)),
+      checker_image_tracker_(&image_controller_,
+                             this,
+                             tile_manager_settings_.enable_checker_imaging),
       more_tiles_need_prepare_check_notifier_(
           task_runner_,
           base::Bind(&TileManager::CheckIfMoreTilesNeedToBePrepared,
                      base::Unretained(this))),
       signals_check_notifier_(task_runner_,
                               base::Bind(&TileManager::CheckAndIssueSignals,
                                          base::Unretained(this))),
       has_scheduled_tile_tasks_(false),
       prepare_tiles_count_(0u),
       next_tile_id_(0u),
-      check_tile_priority_inversion_(check_tile_priority_inversion),
       task_set_finished_weak_ptr_factory_(this),
       ready_to_draw_callback_weak_ptr_factory_(this) {}
 
 TileManager::~TileManager() {
   FinishTasksAndCleanUp();
 }
 
 void TileManager::FinishTasksAndCleanUp() {
   if (!tile_task_manager_)
     return;
@@ skipping 356 matching lines @@
 
   // Debugging to check that remaining tiles in the priority queue are not in
   // the NOW bin and are required for neither activation nor draw.
   // This runs if the following conditions hold:
   //  - check_tile_priority_inversion has been enabled.
   //  - the loop above has processed all tiles that would be needed for any
   //    signals to fire (that is,
   //    all_tiles_that_need_to_be_rasterized_are_scheduled_ is true)
   //  - Memory limit policy allows for any tiles to be scheduled at all (ie it's
   //    not ALLOW_NOTHING).
-  if (check_tile_priority_inversion_ &&
+  if (tile_manager_settings_.check_tile_priority_inversion &&
       all_tiles_that_need_to_be_rasterized_are_scheduled_ &&
       global_state_.memory_limit_policy != ALLOW_NOTHING) {
     TilePriority::PriorityBin highest_bin_found = TilePriority::NOW;
     for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
       const PrioritizedTile& prioritized_tile = raster_priority_queue->Top();
       Tile* tile = prioritized_tile.tile();
       TilePriority priority = prioritized_tile.priority();
 
       if (priority.priority_bin > highest_bin_found)
         highest_bin_found = priority.priority_bin;
@@ skipping 134 matching lines @@
     InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++,
                              use_foreground_category);
   }
 
   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/686267.

[vmpstr, 2017/02/10 19:25:43]

Can you file a different crbug for this? We also need to file a bug to make the
CheckerImageTracker have a queue inside of it which can be reprioritized before
we can do this.

[Khushal, 2017/02/10 22:09:19]

Done.

     std::vector<DrawImage> images;
     prioritized_tile.raster_source()->GetDiscardableImagesInRect(
         tile->enclosing_layer_rect(), tile->contents_scale(), &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).
@@ skipping 82 matching lines @@
   }
 
   // For LOW_RESOLUTION tiles, we don't draw or predecode images.
   RasterSource::PlaybackSettings playback_settings;
   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()];
+  std::unordered_set<ImageId>& images_to_skip =
+      playback_settings.images_to_skip;
+  images_to_skip.clear();

[vmpstr, 2017/02/10 19:25:43]

It better be empty already since we just created playback_settings :) In fact,
just remove this variable and use playback_settings.images_to_skip wherever.. Or
create an empty variable, populated it, move it into the settings. The fact that
this is a reference is just a bit subtle (ie it's hard to track where we
actually pass it in to the task)

[Khushal, 2017/02/10 22:09:19]

Empty variable it is.

While we're here, why do we re-populate the scheduled_draw_images_ for a tile
each time? Can it actually change? I thought if stuff gets invalidated then the
tile will be replaced by a different tile. And everything else (rect, scale) on
the tile is also const.

   images.clear();
   if (!playback_settings.skip_images) {
     prioritized_tile.raster_source()->GetDiscardableImagesInRect(
         tile->enclosing_layer_rect(), tile->contents_scale(), &images);
+    checker_image_tracker_.FilterImagesForCheckeringForTile(

[vmpstr, 2017/02/10 19:25:43]

Hey cool, this is like std::partition... kind of.

[Khushal, 2017/02/10 22:09:19]

Yeah. Much neat now.

+        &images, &images_to_skip, prioritized_tile.tile()->tiling()->tree());
   }
 
-  // We can skip the image hijack canvas if we have no images.
-  playback_settings.use_image_hijack_canvas = !images.empty();
+  // 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();
 
   // Get the tasks for the required images.
   ImageDecodeCache::TracingInfo tracing_info(
       prepare_tiles_count_, prioritized_tile.priority().priority_bin);
   image_controller_.GetTasksForImagesAndRef(&images, &decode_tasks,
                                             tracing_info);
 
   std::unique_ptr<RasterBuffer> raster_buffer =
       raster_buffer_provider_->AcquireBufferForRaster(
           resource, resource_content_id, tile->invalidated_id());
@@ skipping 246 matching lines @@
   // Mark required tiles as OOM so that we can activate/draw without them.
   for (; !queue->IsEmpty(); queue->Pop()) {
     Tile* tile = queue->Top().tile();
     if (tile->draw_info().IsReadyToDraw())
       continue;
     tile->draw_info().set_oom();
     client_->NotifyTileStateChanged(tile);
   }
 }
 
+const std::unordered_set<ImageId>&
+TileManager::TakeImagesToInvalidateOnSyncTree() {
+  return checker_image_tracker_.TakeImagesToInvalidateOnSyncTree();
+}
+
+void TileManager::DidActivateSyncTree() {
+  checker_image_tracker_.DidActivateSyncTree();
+}
+
+void TileManager::NeedsInvalidationForCheckerImagedTiles() {
+  client_->RequestImplSideInvalidation();
+}
+
 ResourceFormat TileManager::DetermineResourceFormat(const Tile* tile) const {
   return raster_buffer_provider_->GetResourceFormat(!tile->is_opaque());
 }
 
 bool TileManager::DetermineResourceRequiresSwizzle(const Tile* tile) const {
   return raster_buffer_provider_->IsResourceSwizzleRequired(!tile->is_opaque());
 }
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 TileManager::ScheduledTasksStateAsValue() const {
   std::unique_ptr<base::trace_event::TracedValue> state(
       new base::trace_event::TracedValue());
   state->BeginDictionary("tasks_pending");
   state->SetBoolean("ready_to_activate", signals_.ready_to_activate);
   state->SetBoolean("ready_to_draw", signals_.ready_to_draw);
   state->SetBoolean("all_tile_tasks_completed",
                     signals_.all_tile_tasks_completed);
   state->EndDictionary();
   return std::move(state);
 }
 
 bool TileManager::UsePartialRaster() const {
-  return use_partial_raster_ &&
+  return tile_manager_settings_.use_partial_raster &&
          raster_buffer_provider_->CanPartialRasterIntoProvidedResource();
 }
 
 void TileManager::CheckPendingGpuWorkTiles(bool issue_signals) {
   ResourceProvider::ResourceIdArray required_for_activation_ids;
   ResourceProvider::ResourceIdArray required_for_draw_ids;
 
   for (auto it = pending_gpu_work_tiles_.begin();
        it != pending_gpu_work_tiles_.end();) {
     Tile* tile = *it;
@@ skipping 140 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