Update from https://crrev.com/312398

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>
 
@@ skipping 117 matching lines @@
   const base::Callback<void(const RasterSource::SolidColorAnalysis&, bool)>
       reply_;
   scoped_ptr<RasterBuffer> raster_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
 };
 
 class ImageDecodeTaskImpl : public ImageDecodeTask {
  public:
   ImageDecodeTaskImpl(SkPixelRef* pixel_ref,
-                      int layer_id,
                       const base::Callback<void(bool was_canceled)>& reply)
       : pixel_ref_(skia::SharePtr(pixel_ref)),
-        layer_id_(layer_id),
         reply_(reply) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT0("cc", "ImageDecodeTaskImpl::RunOnWorkerThread");
 
     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
         pixel_ref_.get());
     // This will cause the image referred to by pixel ref to be decoded.
     pixel_ref_->lockPixels();
     pixel_ref_->unlockPixels();
   }
 
   // Overridden from TileTask:
   void ScheduleOnOriginThread(TileTaskClient* client) override {}
   void CompleteOnOriginThread(TileTaskClient* client) override {}
   void RunReplyOnOriginThread() override { reply_.Run(!HasFinishedRunning()); }
 
  protected:
   ~ImageDecodeTaskImpl() override {}
 
  private:
   skia::RefPtr<SkPixelRef> pixel_ref_;
-  int layer_id_;
   const base::Callback<void(bool was_canceled)> reply_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
 const char* TaskSetName(TaskSet task_set) {
   switch (task_set) {
     case TileManager::ALL:
       return "ALL";
     case TileManager::REQUIRED_FOR_ACTIVATION:
@@ skipping 180 matching lines @@
     // 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);
+    RasterTilePriorityQueue raster_priority_queue;
+    client_->BuildRasterQueue(&raster_priority_queue,
+                              global_state_.tree_priority,
+                              RasterTilePriorityQueue::Type::ALL);
+    AssignGpuMemoryToTiles(&raster_priority_queue, scheduled_raster_task_limit_,
+                           &tiles_that_need_to_be_rasterized);
 
     // 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());
+      // TODO(vmpstr): Add a function to unconditionally create an eviction
+      // queue and guard the rest of the calls sites with this flag, instead of
+      // clearing here and building, which is a bit awkward.
+      eviction_priority_queue_is_up_to_date_ = false;
+      resource_pool_->CheckBusyResources(false);
+      MemoryUsage memory_limit(0, 0);
+      MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(),
+                               resource_pool_->acquired_resource_count());
+      FreeTileResourcesUntilUsageIsWithinLimit(memory_limit, &memory_usage);
     }
 
     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();
 
+  RasterTilePriorityQueue required_for_draw_queue;
+  client_->BuildRasterQueue(&required_for_draw_queue,
+                            global_state_.tree_priority,
+                            RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
   TileVector tiles_that_need_to_be_rasterized;
-  AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized,
-                         std::numeric_limits<size_t>::max(), true);
+  AssignGpuMemoryToTiles(&required_for_draw_queue,
+                         std::numeric_limits<size_t>::max(),
+                         &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();
 
   // Run and complete all raster task synchronously.
   rasterizer_->RasterizeTiles(
       tiles_that_need_to_be_rasterized, resource_pool_,
       base::Bind(&TileManager::UpdateTileDrawInfo, base::Unretained(this)));
 
+  // Use on-demand raster for any required-for-draw tiles that have not been
+  // assigned memory after reaching a steady memory state.
+  // TODO(hendrikw): Figure out why this would improve jank on some tests - See
+  // crbug.com/449288
+  required_for_draw_queue.Reset();
+  client_->BuildRasterQueue(&required_for_draw_queue,
+                            global_state_.tree_priority,
+                            RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
+
+  // Use on-demand raster for any tiles that have not been been assigned
+  // memory. This ensures that we draw even when OOM.
+  for (; !required_for_draw_queue.IsEmpty(); required_for_draw_queue.Pop()) {
+    Tile* tile = required_for_draw_queue.Top();
+    tile->draw_info().set_rasterize_on_demand();
+    client_->NotifyTileStateChanged(tile);
+  }
+
   TRACE_EVENT_INSTANT1("cc", "DidRasterize", 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::UpdateVisibleTiles(
     const GlobalStateThatImpactsTilePriority& state) {
@@ skipping 94 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,
+    RasterTilePriorityQueue* raster_priority_queue,
     size_t scheduled_raster_task_limit,
-    bool required_for_draw_only) {
+    TileVector* tiles_that_need_to_be_rasterized) {
   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
+  // 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;
-  // TODO(vmpstr): Take this as a parameter and have SynchronousRaster build a
-  // REQUIRED_FOR_DRAW queue.
-  client_->BuildRasterQueue(&raster_priority_queue_,
-                            global_state_.tree_priority,
-                            RasterTilePriorityQueue::Type::ALL);
-
-  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;
-      }
-    }
+  for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
+    Tile* tile = raster_priority_queue->Top();
     TilePriority priority = tile->combined_priority();
 
     if (TilePriorityViolatesMemoryPolicy(priority)) {
       TRACE_EVENT_INSTANT0(
           "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) {
       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->desired_texture_size(), resource_pool_->resource_format());
+          tile->desired_texture_size(), resource_pool_->default_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);
 
     // 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;
     }
 
     memory_usage += memory_required_by_tile_to_be_scheduled;
     tiles_that_need_to_be_rasterized->push_back(tile);
-    raster_priority_queue_.Pop();
   }
 
   // Note that we should try and further reduce memory in case the above loop
   // didn't reduce memory. This ensures that we always release as many resources
   // as possible to stay within the memory limit.
   FreeTileResourcesUntilUsageIsWithinLimit(hard_memory_limit, &memory_usage);
 
   UMA_HISTOGRAM_BOOLEAN("TileManager.ExceededMemoryBudget",
                         !had_enough_memory_to_schedule_tiles_needed_now);
   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",
                    "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_)
@@ skipping 58 matching lines @@
   orphan_raster_tasks_.clear();
 
   did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
 }
 
 scoped_refptr<ImageDecodeTask> TileManager::CreateImageDecodeTask(
     Tile* tile,
     SkPixelRef* pixel_ref) {
   return make_scoped_refptr(new ImageDecodeTaskImpl(
       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->desired_texture_size());
+      resource_pool_->AcquireResource(tile->desired_texture_size(),
+                                      resource_pool_->default_format());
   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 104 matching lines @@
     TileTaskRunner* tile_task_runner) {
   tile_task_runner_ = tile_task_runner;
   tile_task_runner_->SetClient(this);
 }
 
 bool TileManager::IsReadyToActivate() const {
   TRACE_EVENT0("cc", "TileManager::IsReadyToActivate");
   const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
 
   // TODO(vmpstr): Replace this with building a REQUIRED_TO_ACTIVATE raster
-  // queue and checking if it's empty.
+  // queue and checking if the tiles it contains are all ready to draw.
   for (const auto& layer : layers) {
     if (!layer->AllTilesRequiredForActivationAreReadyToDraw())
       return false;
   }
 
   return true;
 }
 
 bool TileManager::IsReadyToDraw() const {
   const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
 
   // TODO(vmpstr): Replace this with building a REQUIRED_TO_DRAW raster queue
-  // and checking if it's empty.
+  // and checking if the tiles it contains are all ready to draw.
   for (const auto& layer : layers) {
     if (!layer->AllTilesRequiredForDrawAreReadyToDraw())
       return false;
   }
 
   return true;
 }
 
 void TileManager::NotifyReadyToActivate() {
   TRACE_EVENT0("cc", "TileManager::NotifyReadyToActivate");
@@ skipping 39 matching lines @@
   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,
-                         scheduled_raster_task_limit_, false);
+  RasterTilePriorityQueue raster_priority_queue;
+  client_->BuildRasterQueue(&raster_priority_queue, global_state_.tree_priority,
+                            RasterTilePriorityQueue::Type::ALL);
+  AssignGpuMemoryToTiles(&raster_priority_queue, scheduled_raster_task_limit_,
+                         &tiles_that_need_to_be_rasterized);
 
   // |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();
 
   resource_pool_->ReduceResourceUsage();
 
   // We don't reserve memory for required-for-activation tiles during
   // accelerated gestures, so we just postpone activation when we don't
   // have these tiles, and activate after the accelerated gesture.
   // Likewise if we don't allow any tiles (as is the case when we're
   // invisible), if we have tiles that aren't ready, then we shouldn't
   // activate as activation can cause checkerboards.
   bool allow_rasterize_on_demand =
       global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY &&
       global_state_.memory_limit_policy != ALLOW_NOTHING;
 
   // 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.
-  // TODO(vmpstr): Make this use REQUIRED_FOR_ACTIVAITON queue.
-  client_->BuildRasterQueue(&raster_priority_queue_,
-                            global_state_.tree_priority,
-                            RasterTilePriorityQueue::Type::ALL);
-  bool ready_to_activate = true;
-  while (!raster_priority_queue_.IsEmpty()) {
-    Tile* tile = raster_priority_queue_.Top();
-    TileDrawInfo& draw_info = tile->draw_info();
+  // ensures that we activate even when OOM. Note that we can't reuse the queue
+  // we used for AssignGpuMemoryToTiles, since the AssignGpuMemoryToTiles call
+  // could have evicted some tiles that would not be picked up by the old raster
+  // queue.
+  RasterTilePriorityQueue required_for_activation_queue;
+  client_->BuildRasterQueue(
+      &required_for_activation_queue, global_state_.tree_priority,
+      RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
 
-    if (tile->required_for_activation() && !draw_info.IsReadyToDraw()) {
-      // If we can't raster on demand, give up early (and don't activate).
-      if (!allow_rasterize_on_demand) {
-        ready_to_activate = false;
-        break;
-      }
+  // If we have tiles to mark as rasterize on demand, but we don't allow
+  // rasterize on demand, then skip activation and return early.
+  if (!required_for_activation_queue.IsEmpty() && !allow_rasterize_on_demand)
+    return;
 
-      draw_info.set_rasterize_on_demand();
-      client_->NotifyTileStateChanged(tile);
-    }
-    raster_priority_queue_.Pop();
+  // Mark required tiles as rasterize on demand.
+  for (; !required_for_activation_queue.IsEmpty();
+       required_for_activation_queue.Pop()) {
+    Tile* tile = required_for_activation_queue.Top();
+    tile->draw_info().set_rasterize_on_demand();
+    client_->NotifyTileStateChanged(tile);
   }
 
-  if (ready_to_activate) {
-    DCHECK(IsReadyToActivate());
-    ready_to_activate_check_notifier_.Schedule();
-  }
-  raster_priority_queue_.Reset();
+  DCHECK(IsReadyToActivate());
+  ready_to_activate_check_notifier_.Schedule();
 }
 
 TileManager::MemoryUsage::MemoryUsage() : memory_bytes_(0), resource_count_(0) {
 }
 
 TileManager::MemoryUsage::MemoryUsage(int64 memory_bytes, int resource_count)
     : memory_bytes_(memory_bytes), resource_count_(resource_count) {
 }
 
 // static
@@ skipping 33 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