Revert "Pull chromium at 2c3ffb2355a27c32f45e508ef861416b820c823b"

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 421 matching lines @@
       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 = client_->BuildRasterQueue(
       global_state_.tree_priority,
       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
 
-  // Change to OOM mode for any tiles that have not been been assigned memory.
-  // This ensures that we draw even when OOM.
+  // 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_oom();
+    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());
 }
@@ skipping 140 matching lines @@
     // 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_IMPLIES(draw_info.mode() != TileDrawInfo::OOM_MODE,
-                   !draw_info.IsReadyToDraw());
+    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(), tile_task_runner_->GetResourceFormat());
     }
 
@@ skipping 347 matching lines @@
   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 wait_for_all_required_tiles =
-      global_state_.tree_priority == SMOOTHNESS_TAKES_PRIORITY ||
-      global_state_.memory_limit_policy == ALLOW_NOTHING;
+  bool allow_rasterize_on_demand =
+      global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY &&
+      global_state_.memory_limit_policy != ALLOW_NOTHING;
 
-  // Mark any required-for-activation tiles that have not been been assigned
-  // memory after reaching a steady memory state as OOM. This 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.
+  // 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 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.
   scoped_ptr<RasterTilePriorityQueue> required_for_activation_queue(
       client_->BuildRasterQueue(
           global_state_.tree_priority,
           RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
 
-  // If we have tiles left to raster for activation, and we don't allow
-  // activating without them, then skip activation and return early.
-  if (!required_for_activation_queue->IsEmpty() && wait_for_all_required_tiles)
+  // 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;
 
-  // Mark required tiles as OOM so that we can activate without them.
+  // 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_oom();
+    tile->draw_info().set_rasterize_on_demand();
     client_->NotifyTileStateChanged(tile);
   }
 
   DCHECK(IsReadyToActivate());
   ready_to_activate_check_notifier_.Schedule();
 }
 
 TileManager::MemoryUsage::MemoryUsage() : memory_bytes_(0), resource_count_(0) {
 }
 
@@ skipping 38 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