Roll Chrome into Mojo.

cc/resources/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/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/frame_viewer_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/resources/raster_buffer.h"
+#include "cc/resources/rasterizer.h"
 #include "cc/resources/tile.h"
 #include "cc/resources/tile_task_runner.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 namespace {
 
 // Flag to indicate whether we should try and detect that
 // a tile is of solid color.
 const bool kUseColorEstimator = true;
@@ skipping 163 matching lines @@
   state->SetInteger("canceled_count", stats.canceled_count);
   return state;
 }
 
 // static
 scoped_ptr<TileManager> TileManager::Create(
     TileManagerClient* client,
     base::SequencedTaskRunner* task_runner,
     ResourcePool* resource_pool,
     TileTaskRunner* tile_task_runner,
+    Rasterizer* rasterizer,
     size_t scheduled_raster_task_limit) {
   return make_scoped_ptr(new TileManager(client, task_runner, resource_pool,
-                                         tile_task_runner,
+                                         tile_task_runner, rasterizer,
                                          scheduled_raster_task_limit));
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
     ResourcePool* resource_pool,
     TileTaskRunner* tile_task_runner,
+    Rasterizer* rasterizer,
     size_t scheduled_raster_task_limit)
     : client_(client),
       task_runner_(task_runner),
       resource_pool_(resource_pool),
       tile_task_runner_(tile_task_runner),
+      rasterizer_(rasterizer),
       scheduled_raster_task_limit_(scheduled_raster_task_limit),
       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),
+      ready_to_activate_notifier_(
+          task_runner_.get(),
+          base::Bind(&TileManager::NotifyReadyToActivate,
+                     base::Unretained(this))),
+      ready_to_draw_notifier_(
+          task_runner_.get(),
+          base::Bind(&TileManager::NotifyReadyToDraw, base::Unretained(this))),
       ready_to_activate_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToActivate,
                      base::Unretained(this))),
       ready_to_draw_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToDraw, base::Unretained(this))),
       more_tiles_need_prepare_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfMoreTilesNeedToBePrepared,
                      base::Unretained(this))),
+      eviction_priority_queue_is_up_to_date_(false),
       did_notify_ready_to_activate_(false),
       did_notify_ready_to_draw_(false) {
   tile_task_runner_->SetClient(this);
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
 
@@ skipping 84 matching lines @@
 
   NOTREACHED();
 }
 
 void TileManager::PrepareTiles(
     const GlobalStateThatImpactsTilePriority& state) {
   TRACE_EVENT0("cc", "TileManager::PrepareTiles");
 
   global_state_ = state;
 
-  // We need to call CheckForCompletedTasks() once in-between each call
-  // to ScheduleTasks() to prevent canceled tasks from being scheduled.
-  if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
-    tile_task_runner_->CheckForCompletedTasks();
-    did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
+  PrepareTilesMode prepare_tiles_mode = rasterizer_->GetPrepareTilesMode();
+
+  // TODO(hendrikw): Consider moving some of this code to the rasterizer.
+  if (prepare_tiles_mode != PrepareTilesMode::PREPARE_NONE) {
+    // We need to call CheckForCompletedTasks() once in-between each call
+    // to ScheduleTasks() to prevent canceled tasks from being scheduled.
+    if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
+      tile_task_runner_->CheckForCompletedTasks();
+      did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
+    }
+
+    FreeResourcesForReleasedTiles();
+    CleanUpReleasedTiles();
+
+    TileVector tiles_that_need_to_be_rasterized;
+    AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized,
+                           scheduled_raster_task_limit_, false);
+
+    // Schedule tile tasks.
+    ScheduleTasks(tiles_that_need_to_be_rasterized);
+
+    did_notify_ready_to_activate_ = false;
+    did_notify_ready_to_draw_ = false;
+  } else {
+    if (global_state_.hard_memory_limit_in_bytes == 0) {
+      TileVector tiles_that_need_to_be_rasterized;
+      AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized,
+                             scheduled_raster_task_limit_, false);
+      DCHECK(tiles_that_need_to_be_rasterized.empty());
+    }
+
+    did_notify_ready_to_activate_ = false;
+    did_notify_ready_to_draw_ = false;
+    ready_to_activate_notifier_.Schedule();
+    ready_to_draw_notifier_.Schedule();
   }
 
+  TRACE_EVENT_INSTANT1("cc", "DidPrepareTiles", TRACE_EVENT_SCOPE_THREAD,
+                       "state", BasicStateAsValue());
+
+  TRACE_COUNTER_ID1("cc", "unused_memory_bytes", this,
+                    resource_pool_->total_memory_usage_bytes() -
+                        resource_pool_->acquired_memory_usage_bytes());
+}
+
+void TileManager::SynchronouslyRasterizeTiles(
+    const GlobalStateThatImpactsTilePriority& state) {
+  TRACE_EVENT0("cc", "TileManager::SynchronouslyRasterizeTiles");
+
+  DCHECK(rasterizer_->GetPrepareTilesMode() !=
+         PrepareTilesMode::RASTERIZE_PRIORITIZED_TILES);
+
+  global_state_ = state;
+
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
 
   TileVector tiles_that_need_to_be_rasterized;
-  AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
+  AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized,
+                         std::numeric_limits<size_t>::max(), true);
 
-  // Schedule tile tasks.
-  ScheduleTasks(tiles_that_need_to_be_rasterized);
+  // We must reduce the amount of unused resources before calling
+  // RunTasks to prevent usage from rising above limits.
+  resource_pool_->ReduceResourceUsage();
 
-  did_notify_ready_to_activate_ = false;
-  did_notify_ready_to_draw_ = false;
+  // Run and complete all raster task synchronously.
+  rasterizer_->RasterizeTiles(
+      tiles_that_need_to_be_rasterized, resource_pool_,
+      base::Bind(&TileManager::UpdateTileDrawInfo, base::Unretained(this)));
 
-  TRACE_EVENT_INSTANT1("cc", "DidPrepare", TRACE_EVENT_SCOPE_THREAD, "state",
+  // Use on-demand raster for any required-for-activation tiles that have not
+  // been been assigned memory after reaching a steady memory state. This
+  // ensures that we activate even when OOM. Note that we have to rebuilt the
+  // queue in case the last AssignGpuMemoryToTiles evicted some tiles that would
+  // otherwise not be picked up by the old raster queue.
+  client_->BuildRasterQueue(&raster_priority_queue_,
+                            global_state_.tree_priority);
+
+  // Use on-demand raster for any tiles that have not been been assigned
+  // memory. This ensures that we draw even when OOM.
+  while (!raster_priority_queue_.IsEmpty()) {
+    Tile* tile = raster_priority_queue_.Top();
+    TileDrawInfo& draw_info = tile->draw_info();
+
+    if (tile->required_for_draw() && !draw_info.IsReadyToDraw()) {
+      draw_info.set_rasterize_on_demand();
+      client_->NotifyTileStateChanged(tile);
+    }
+    raster_priority_queue_.Pop();
+  }
+  raster_priority_queue_.Reset();
+
+  TRACE_EVENT_INSTANT1("cc", "DidRasterize", TRACE_EVENT_SCOPE_THREAD, "state",
                        BasicStateAsValue());
 
-  TRACE_COUNTER_ID1("cc",
-                    "unused_memory_bytes",
-                    this,
+  TRACE_COUNTER_ID1("cc", "unused_memory_bytes", this,
                     resource_pool_->total_memory_usage_bytes() -
                         resource_pool_->acquired_memory_usage_bytes());
 }
 
-void TileManager::UpdateVisibleTiles() {
+void TileManager::UpdateVisibleTiles(
+    const GlobalStateThatImpactsTilePriority& state) {
   TRACE_EVENT0("cc", "TileManager::UpdateVisibleTiles");
 
   tile_task_runner_->CheckForCompletedTasks();
+
+  DCHECK(rasterizer_);
+  PrepareTilesMode prepare_tiles_mode = rasterizer_->GetPrepareTilesMode();
+  if (prepare_tiles_mode != PrepareTilesMode::RASTERIZE_PRIORITIZED_TILES)
+    SynchronouslyRasterizeTiles(state);
+
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   TRACE_EVENT_INSTANT1(
       "cc",
       "DidUpdateVisibleTiles",
       TRACE_EVENT_SCOPE_THREAD,
       "stats",
       RasterTaskCompletionStatsAsValue(update_visible_tiles_stats_));
   update_visible_tiles_stats_ = RasterTaskCompletionStats();
 }
@@ skipping 75 matching lines @@
       return priority.priority_bin > TilePriority::SOON;
     case ALLOW_ANYTHING:
       return priority.distance_to_visible ==
              std::numeric_limits<float>::infinity();
   }
   NOTREACHED();
   return true;
 }
 
 void TileManager::AssignGpuMemoryToTiles(
-    TileVector* tiles_that_need_to_be_rasterized) {
+    TileVector* tiles_that_need_to_be_rasterized,
+    size_t scheduled_raster_task_limit,
+    bool required_for_draw_only) {
   TRACE_EVENT_BEGIN0("cc", "TileManager::AssignGpuMemoryToTiles");
 
   // Maintain the list of released resources that can potentially be re-used
   // or deleted.
   // If this operation becomes expensive too, only do this after some
   // resource(s) was returned. Note that in that case, one also need to
   // invalidate when releasing some resource from the pool.
   resource_pool_->CheckBusyResources(false);
 
   // Now give memory out to the tiles until we're out, and build
   // the needs-to-be-rasterized queue.
   unsigned schedule_priority = 1u;
   all_tiles_that_need_to_be_rasterized_are_scheduled_ = true;
   bool had_enough_memory_to_schedule_tiles_needed_now = true;
 
   MemoryUsage hard_memory_limit(global_state_.hard_memory_limit_in_bytes,
                                 global_state_.num_resources_limit);
   MemoryUsage soft_memory_limit(global_state_.soft_memory_limit_in_bytes,
                                 global_state_.num_resources_limit);
   MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(),
                            resource_pool_->acquired_resource_count());
 
   eviction_priority_queue_is_up_to_date_ = false;
   client_->BuildRasterQueue(&raster_priority_queue_,
                             global_state_.tree_priority);
 
   while (!raster_priority_queue_.IsEmpty()) {
     Tile* tile = raster_priority_queue_.Top();
+
+    // TODO(vmpstr): Remove this when the iterator returns the correct tiles
+    // to draw for GPU rasterization.
+    if (required_for_draw_only) {
+      if (!tile->required_for_draw()) {
+        raster_priority_queue_.Pop();
+        continue;
+      }
+    }
     TilePriority priority = tile->combined_priority();
 
     if (TilePriorityViolatesMemoryPolicy(priority)) {
       TRACE_EVENT_INSTANT0(
-          "cc",
-          "TileManager::AssignGpuMemory tile violates memory policy",
+          "cc", "TileManager::AssignGpuMemory tile violates memory policy",
           TRACE_EVENT_SCOPE_THREAD);
       break;
     }
 
     // We won't be able to schedule this tile, so break out early.
     if (tiles_that_need_to_be_rasterized->size() >=
-        scheduled_raster_task_limit_) {
+        scheduled_raster_task_limit) {
       all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
       break;
     }
 
     TileDrawInfo& draw_info = tile->draw_info();
     tile->scheduled_priority_ = schedule_priority++;
 
     DCHECK(draw_info.mode() == TileDrawInfo::PICTURE_PILE_MODE ||
            !draw_info.IsReadyToDraw());
 
     // If the tile already has a raster_task, then the memory used by it is
     // already accounted for in memory_usage. Otherwise, we'll have to acquire
     // more memory to create a raster task.
     MemoryUsage memory_required_by_tile_to_be_scheduled;
     if (!tile->raster_task_.get()) {
       memory_required_by_tile_to_be_scheduled = MemoryUsage::FromConfig(
-          tile->size(), resource_pool_->resource_format());
+          tile->desired_texture_size(), resource_pool_->resource_format());
     }
 
     bool tile_is_needed_now = priority.priority_bin == TilePriority::NOW;
 
     // This is the memory limit that will be used by this tile. Depending on
     // the tile priority, it will be one of hard_memory_limit or
     // soft_memory_limit.
     MemoryUsage& tile_memory_limit =
         tile_is_needed_now ? hard_memory_limit : soft_memory_limit;
 
     bool memory_usage_is_within_limit =
         FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
             tile_memory_limit - memory_required_by_tile_to_be_scheduled,
-            priority,
-            &memory_usage);
+            priority, &memory_usage);
 
     // If we couldn't fit the tile into our current memory limit, then we're
     // done.
     if (!memory_usage_is_within_limit) {
       if (tile_is_needed_now)
         had_enough_memory_to_schedule_tiles_needed_now = false;
       all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
       break;
     }
 
@@ skipping 12 matching lines @@
   did_oom_on_last_assign_ = !had_enough_memory_to_schedule_tiles_needed_now;
 
   memory_stats_from_last_assign_.total_budget_in_bytes =
       global_state_.hard_memory_limit_in_bytes;
   memory_stats_from_last_assign_.total_bytes_used = memory_usage.memory_bytes();
   memory_stats_from_last_assign_.had_enough_memory =
       had_enough_memory_to_schedule_tiles_needed_now;
 
   raster_priority_queue_.Reset();
 
-  TRACE_EVENT_END2("cc",
-                   "TileManager::AssignGpuMemoryToTiles",
+  TRACE_EVENT_END2("cc", "TileManager::AssignGpuMemoryToTiles",
                    "all_tiles_that_need_to_be_rasterized_are_scheduled",
                    all_tiles_that_need_to_be_rasterized_are_scheduled_,
                    "had_enough_memory_to_schedule_tiles_needed_now",
                    had_enough_memory_to_schedule_tiles_needed_now);
 }
 
 void TileManager::FreeResourcesForTile(Tile* tile) {
   TileDrawInfo& draw_info = tile->draw_info();
   if (draw_info.resource_)
     resource_pool_->ReleaseResource(draw_info.resource_.Pass());
@@ skipping 66 matching lines @@
       pixel_ref,
       tile->layer_id(),
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
                  base::Unretained(this),
                  tile->layer_id(),
                  base::Unretained(pixel_ref))));
 }
 
 scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) {
   scoped_ptr<ScopedResource> resource =
-      resource_pool_->AcquireResource(tile->size());
+      resource_pool_->AcquireResource(tile->desired_texture_size());
   const ScopedResource* const_resource = resource.get();
 
   // Create and queue all image decode tasks that this tile depends on.
   ImageDecodeTask::Vector decode_tasks;
   PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()];
   std::vector<SkPixelRef*> pixel_refs;
   tile->raster_source()->GatherPixelRefs(
       tile->content_rect(), tile->contents_scale(), &pixel_refs);
   for (SkPixelRef* pixel_ref : pixel_refs) {
     uint32_t id = pixel_ref->getGenerationID();
@@ skipping 43 matching lines @@
 }
 
 void TileManager::OnRasterTaskCompleted(
     Tile::Id tile_id,
     scoped_ptr<ScopedResource> resource,
     const RasterSource::SolidColorAnalysis& analysis,
     bool was_canceled) {
   DCHECK(tiles_.find(tile_id) != tiles_.end());
 
   Tile* tile = tiles_[tile_id];
-  TileDrawInfo& draw_info = tile->draw_info();
   DCHECK(tile->raster_task_.get());
   orphan_raster_tasks_.push_back(tile->raster_task_);
-  tile->raster_task_ = NULL;
+  tile->raster_task_ = nullptr;
 
   if (was_canceled) {
     ++update_visible_tiles_stats_.canceled_count;
     resource_pool_->ReleaseResource(resource.Pass());
     return;
   }
 
+  UpdateTileDrawInfo(tile, resource.Pass(), analysis);
+}
+
+void TileManager::UpdateTileDrawInfo(
+    Tile* tile,
+    scoped_ptr<ScopedResource> resource,
+    const RasterSource::SolidColorAnalysis& analysis) {
+  TileDrawInfo& draw_info = tile->draw_info();
+
   ++update_visible_tiles_stats_.completed_count;
 
   if (analysis.is_solid_color) {
     draw_info.set_solid_color(analysis.solid_color);
     resource_pool_->ReleaseResource(resource.Pass());
   } else {
     draw_info.set_use_resource();
     draw_info.resource_ = resource.Pass();
   }
 
   client_->NotifyTileStateChanged(tile);
 }
 
-scoped_refptr<Tile> TileManager::CreateTile(RasterSource* raster_source,
-                                            const gfx::Size& tile_size,
-                                            const gfx::Rect& content_rect,
-                                            float contents_scale,
-                                            int layer_id,
-                                            int source_frame_number,
-                                            int flags) {
-  scoped_refptr<Tile> tile = make_scoped_refptr(new Tile(this,
-                                                         raster_source,
-                                                         tile_size,
-                                                         content_rect,
-                                                         contents_scale,
-                                                         layer_id,
-                                                         source_frame_number,
-                                                         flags));
+scoped_refptr<Tile> TileManager::CreateTile(
+    RasterSource* raster_source,
+    const gfx::Size& desired_texture_size,
+    const gfx::Rect& content_rect,
+    float contents_scale,
+    int layer_id,
+    int source_frame_number,
+    int flags) {
+  scoped_refptr<Tile> tile = make_scoped_refptr(
+      new Tile(this, raster_source, desired_texture_size, content_rect,
+               contents_scale, layer_id, source_frame_number, flags));
   DCHECK(tiles_.find(tile->id()) == tiles_.end());
 
   tiles_[tile->id()] = tile.get();
   used_layer_counts_[tile->layer_id()]++;
   return tile;
 }
 
 void TileManager::SetTileTaskRunnerForTesting(
     TileTaskRunner* tile_task_runner) {
   tile_task_runner_ = tile_task_runner;
@@ skipping 16 matching lines @@
   const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
 
   for (const auto& layer : layers) {
     if (!layer->AllTilesRequiredForDrawAreReadyToDraw())
       return false;
   }
 
   return true;
 }
 
+void TileManager::NotifyReadyToActivate() {
+  TRACE_EVENT0("cc", "TileManager::NotifyReadyToActivate");
+  if (did_notify_ready_to_activate_)
+    return;
+  client_->NotifyReadyToActivate();
+  did_notify_ready_to_activate_ = true;
+}
+
+void TileManager::NotifyReadyToDraw() {
+  TRACE_EVENT0("cc", "TileManager::NotifyReadyToDraw");
+  if (did_notify_ready_to_draw_)
+    return;
+  client_->NotifyReadyToDraw();
+  did_notify_ready_to_draw_ = true;
+}
+
 void TileManager::CheckIfReadyToActivate() {
   TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate");
 
   tile_task_runner_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   if (did_notify_ready_to_activate_)
     return;
   if (!IsReadyToActivate())
     return;
 
-  client_->NotifyReadyToActivate();
-  did_notify_ready_to_activate_ = true;
+  NotifyReadyToActivate();
 }
 
 void TileManager::CheckIfReadyToDraw() {
   TRACE_EVENT0("cc", "TileManager::CheckIfReadyToDraw");
 
   tile_task_runner_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   if (did_notify_ready_to_draw_)
     return;
   if (!IsReadyToDraw())
     return;
 
-  client_->NotifyReadyToDraw();
-  did_notify_ready_to_draw_ = true;
+  NotifyReadyToDraw();
 }
 
 void TileManager::CheckIfMoreTilesNeedToBePrepared() {
   tile_task_runner_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   // When OOM, keep re-assigning memory until we reach a steady state
   // where top-priority tiles are initialized.
   TileVector tiles_that_need_to_be_rasterized;
-  AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
+  AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized,
+                         scheduled_raster_task_limit_, false);
 
   // |tiles_that_need_to_be_rasterized| will be empty when we reach a
   // steady memory state. Keep scheduling tasks until we reach this state.
   if (!tiles_that_need_to_be_rasterized.empty()) {
     ScheduleTasks(tiles_that_need_to_be_rasterized);
     return;
   }
 
   FreeResourcesForReleasedTiles();
 
@@ skipping 52 matching lines @@
 TileManager::MemoryUsage TileManager::MemoryUsage::FromConfig(
     const gfx::Size& size,
     ResourceFormat format) {
   return MemoryUsage(Resource::MemorySizeBytes(size, format), 1);
 }
 
 // static
 TileManager::MemoryUsage TileManager::MemoryUsage::FromTile(const Tile* tile) {
   const TileDrawInfo& draw_info = tile->draw_info();
   if (draw_info.resource_) {
-    return MemoryUsage::FromConfig(tile->size(), draw_info.resource_->format());
+    return MemoryUsage::FromConfig(draw_info.resource_->size(),
+                                   draw_info.resource_->format());
   }
   return MemoryUsage();
 }
 
 TileManager::MemoryUsage& TileManager::MemoryUsage::operator+=(
     const MemoryUsage& other) {
   memory_bytes_ += other.memory_bytes_;
   resource_count_ += other.resource_count_;
   return *this;
 }
@@ skipping 11 matching lines @@
   result -= other;
   return result;
 }
 
 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
   return memory_bytes_ > limit.memory_bytes_ ||
          resource_count_ > limit.resource_count_;
 }
 
 }  // namespace cc