cc: Start using raster/eviction iterators in tile manager

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 227 matching lines @@
   skia::RefPtr<SkPixelRef> pixel_ref_;
   int layer_id_;
   RenderingStatsInstrumentation* rendering_stats_;
   const base::Callback<void(bool was_canceled)> reply_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
 const size_t kScheduledRasterTasksLimit = 32u;
 
-// Memory limit policy works by mapping some bin states to the NEVER bin.
-const ManagedTileBin kBinPolicyMap[NUM_TILE_MEMORY_LIMIT_POLICIES][NUM_BINS] = {
-    // [ALLOW_NOTHING]
-    {NEVER_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
-     NEVER_BIN,  // [NOW_BIN]
-     NEVER_BIN,  // [SOON_BIN]
-     NEVER_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
-     NEVER_BIN,  // [EVENTUALLY_BIN]
-     NEVER_BIN,  // [AT_LAST_AND_ACTIVE_BIN]
-     NEVER_BIN,  // [AT_LAST_BIN]
-     NEVER_BIN   // [NEVER_BIN]
-    },
-    // [ALLOW_ABSOLUTE_MINIMUM]
-    {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
-     NOW_BIN,                    // [NOW_BIN]
-     NEVER_BIN,                  // [SOON_BIN]
-     NEVER_BIN,                  // [EVENTUALLY_AND_ACTIVE_BIN]
-     NEVER_BIN,                  // [EVENTUALLY_BIN]
-     NEVER_BIN,                  // [AT_LAST_AND_ACTIVE_BIN]
-     NEVER_BIN,                  // [AT_LAST_BIN]
-     NEVER_BIN                   // [NEVER_BIN]
-    },
-    // [ALLOW_PREPAINT_ONLY]
-    {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
-     NOW_BIN,                    // [NOW_BIN]
-     SOON_BIN,                   // [SOON_BIN]
-     NEVER_BIN,                  // [EVENTUALLY_AND_ACTIVE_BIN]
-     NEVER_BIN,                  // [EVENTUALLY_BIN]
-     NEVER_BIN,                  // [AT_LAST_AND_ACTIVE_BIN]
-     NEVER_BIN,                  // [AT_LAST_BIN]
-     NEVER_BIN                   // [NEVER_BIN]
-    },
-    // [ALLOW_ANYTHING]
-    {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
-     NOW_BIN,                    // [NOW_BIN]
-     SOON_BIN,                   // [SOON_BIN]
-     EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
-     EVENTUALLY_BIN,             // [EVENTUALLY_BIN]
-     AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
-     AT_LAST_BIN,                // [AT_LAST_BIN]
-     NEVER_BIN                   // [NEVER_BIN]
-    }};
-
-// Ready to draw works by mapping NOW_BIN to NOW_AND_READY_TO_DRAW_BIN.
-const ManagedTileBin kBinReadyToDrawMap[2][NUM_BINS] = {
-    // Not ready
-    {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
-     NOW_BIN,                    // [NOW_BIN]
-     SOON_BIN,                   // [SOON_BIN]
-     EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
-     EVENTUALLY_BIN,             // [EVENTUALLY_BIN]
-     AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
-     AT_LAST_BIN,                // [AT_LAST_BIN]
-     NEVER_BIN                   // [NEVER_BIN]
-    },
-    // Ready
-    {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
-     NOW_AND_READY_TO_DRAW_BIN,  // [NOW_BIN]
-     SOON_BIN,                   // [SOON_BIN]
-     EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
-     EVENTUALLY_BIN,             // [EVENTUALLY_BIN]
-     AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
-     AT_LAST_BIN,                // [AT_LAST_BIN]
-     NEVER_BIN                   // [NEVER_BIN]
-    }};
-
-// Active works by mapping some bin stats to equivalent _ACTIVE_BIN state.
-const ManagedTileBin kBinIsActiveMap[2][NUM_BINS] = {
-    // Inactive
-    {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
-     NOW_BIN,                    // [NOW_BIN]
-     SOON_BIN,                   // [SOON_BIN]
-     EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
-     EVENTUALLY_BIN,             // [EVENTUALLY_BIN]
-     AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
-     AT_LAST_BIN,                // [AT_LAST_BIN]
-     NEVER_BIN                   // [NEVER_BIN]
-    },
-    // Active
-    {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
-     NOW_BIN,                    // [NOW_BIN]
-     SOON_BIN,                   // [SOON_BIN]
-     EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
-     EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_BIN]
-     AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
-     AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_BIN]
-     NEVER_BIN                   // [NEVER_BIN]
-    }};
-
-// Determine bin based on three categories of tiles: things we need now,
-// things we need soon, and eventually.
-inline ManagedTileBin BinFromTilePriority(const TilePriority& prio) {
-  if (prio.priority_bin == TilePriority::NOW)
-    return NOW_BIN;
-
-  if (prio.priority_bin == TilePriority::SOON)
-    return SOON_BIN;
-
-  if (prio.distance_to_visible == std::numeric_limits<float>::infinity())
-    return NEVER_BIN;
-
-  return EVENTUALLY_BIN;
-}
-
 }  // namespace
 
 RasterTaskCompletionStats::RasterTaskCompletionStats()
     : completed_count(0u), canceled_count(0u) {}
 
 scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
     const RasterTaskCompletionStats& stats) {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->SetInteger("completed_count", stats.completed_count);
   state->SetInteger("canceled_count", stats.canceled_count);
@@ skipping 16 matching lines @@
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourcePool* resource_pool,
     Rasterizer* rasterizer,
     bool use_rasterize_on_demand,
     RenderingStatsInstrumentation* rendering_stats_instrumentation)
     : client_(client),
       resource_pool_(resource_pool),
       rasterizer_(rasterizer),
-      prioritized_tiles_dirty_(false),
       all_tiles_that_need_to_be_rasterized_have_memory_(true),
       all_tiles_required_for_activation_have_memory_(true),
-      memory_required_bytes_(0),
-      memory_nice_to_have_bytes_(0),
       bytes_releasable_(0),
       resources_releasable_(0),
       ever_exceeded_memory_budget_(false),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       did_initialize_visible_tile_(false),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
       use_rasterize_on_demand_(use_rasterize_on_demand) {
   rasterizer_->SetClient(this);
 }
 
@@ skipping 19 matching lines @@
 
   for (std::vector<PictureLayerImpl*>::iterator it = layers_.begin();
        it != layers_.end();
        ++it) {
     (*it)->DidUnregisterLayer();
   }
   layers_.clear();
 }
 
 void TileManager::Release(Tile* tile) {
-  prioritized_tiles_dirty_ = true;
   released_tiles_.push_back(tile);
 }
 
-void TileManager::DidChangeTilePriority(Tile* tile) {
-  prioritized_tiles_dirty_ = true;
-}
-
 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
   return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY;
 }
 
 void TileManager::CleanUpReleasedTiles() {
   for (std::vector<Tile*>::iterator it = released_tiles_.begin();
        it != released_tiles_.end();
        ++it) {
     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
@@ skipping 13 matching lines @@
       used_layer_counts_.erase(layer_it);
       image_decode_tasks_.erase(tile->layer_id());
     }
 
     delete tile;
   }
 
   released_tiles_.clear();
 }
 
-void TileManager::UpdatePrioritizedTileSetIfNeeded() {
-  if (!prioritized_tiles_dirty_)
-    return;
-
-  CleanUpReleasedTiles();
-
-  prioritized_tiles_.Clear();
-  GetTilesWithAssignedBins(&prioritized_tiles_);
-  prioritized_tiles_dirty_ = false;
-}
-
 void TileManager::DidFinishRunningTasks() {
   TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks");
 
   bool memory_usage_above_limit = resource_pool_->total_memory_usage_bytes() >
                                   global_state_.soft_memory_limit_in_bytes;
 
   // When OOM, keep re-assigning memory until we reach a steady state
   // where top-priority tiles are initialized.
   if (all_tiles_that_need_to_be_rasterized_have_memory_ &&
       !memory_usage_above_limit)
     return;
 
   rasterizer_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   TileVector tiles_that_need_to_be_rasterized;
-  AssignGpuMemoryToTiles(&prioritized_tiles_,
-                         &tiles_that_need_to_be_rasterized);
+  AssignGpuMemoryToTiles(&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;
   }
 
   resource_pool_->ReduceResourceUsage();
 
@@ skipping 29 matching lines @@
   // activation are initialized when no tiles are OOM. We need to
   // wait for DidFinishRunningTasks() to be called, try to re-assign
   // memory and in worst case use on-demand raster when tiles
   // required for activation are OOM.
   if (!all_tiles_required_for_activation_have_memory_)
     return;
 
   client_->NotifyReadyToActivate();
 }
 
-void TileManager::GetTilesWithAssignedBins(PrioritizedTileSet* tiles) {
-  TRACE_EVENT0("cc", "TileManager::GetTilesWithAssignedBins");
-
-  // Compute new stats to be return by GetMemoryStats().
-  memory_required_bytes_ = 0;
-  memory_nice_to_have_bytes_ = 0;
-
-  const TileMemoryLimitPolicy memory_policy = global_state_.memory_limit_policy;
-  const TreePriority tree_priority = global_state_.tree_priority;
-
-  // For each tree, bin into different categories of tiles.
-  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
-    Tile* tile = it->second;
-    ManagedTileState& mts = tile->managed_state();
-
-    const ManagedTileState::TileVersion& tile_version =
-        tile->GetTileVersionForDrawing();
-    bool tile_is_ready_to_draw = tile_version.IsReadyToDraw();
-    bool tile_is_active = tile_is_ready_to_draw ||
-                          mts.tile_versions[mts.raster_mode].raster_task_;
-
-    // Get the active priority and bin.
-    TilePriority active_priority = tile->priority(ACTIVE_TREE);
-    ManagedTileBin active_bin = BinFromTilePriority(active_priority);
-
-    // Get the pending priority and bin.
-    TilePriority pending_priority = tile->priority(PENDING_TREE);
-    ManagedTileBin pending_bin = BinFromTilePriority(pending_priority);
-
-    bool pending_is_low_res = pending_priority.resolution == LOW_RESOLUTION;
-    bool pending_is_non_ideal =
-        pending_priority.resolution == NON_IDEAL_RESOLUTION;
-    bool active_is_non_ideal =
-        active_priority.resolution == NON_IDEAL_RESOLUTION;
-
-    // Adjust bin state based on if ready to draw.
-    active_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][active_bin];
-    pending_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][pending_bin];
-
-    // Adjust bin state based on if active.
-    active_bin = kBinIsActiveMap[tile_is_active][active_bin];
-    pending_bin = kBinIsActiveMap[tile_is_active][pending_bin];
-
-    // We never want to paint new non-ideal tiles, as we always have
-    // a high-res tile covering that content (paint that instead).
-    if (!tile_is_ready_to_draw && active_is_non_ideal)
-      active_bin = NEVER_BIN;
-    if (!tile_is_ready_to_draw && pending_is_non_ideal)
-      pending_bin = NEVER_BIN;
-
-    if (!tile_is_ready_to_draw || tile_version.requires_resource()) {
-      // The bin that the tile would have if the GPU memory manager had
-      // a maximally permissive policy, send to the GPU memory manager
-      // to determine policy.
-      ManagedTileBin gpu_memmgr_stats_bin = std::min(active_bin, pending_bin);
-      if ((gpu_memmgr_stats_bin == NOW_BIN) ||
-          (gpu_memmgr_stats_bin == NOW_AND_READY_TO_DRAW_BIN))
-        memory_required_bytes_ += BytesConsumedIfAllocated(tile);
-      if (gpu_memmgr_stats_bin != NEVER_BIN)
-        memory_nice_to_have_bytes_ += BytesConsumedIfAllocated(tile);
-    }
-
-    ManagedTileBin tree_bin[NUM_TREES];
-    tree_bin[ACTIVE_TREE] = kBinPolicyMap[memory_policy][active_bin];
-    tree_bin[PENDING_TREE] = kBinPolicyMap[memory_policy][pending_bin];
-
-    // Adjust pending bin state for low res tiles. This prevents pending tree
-    // low-res tiles from being initialized before high-res tiles.
-    if (pending_is_low_res)
-      tree_bin[PENDING_TREE] = std::max(tree_bin[PENDING_TREE], EVENTUALLY_BIN);
-
-    TilePriority tile_priority;
-    switch (tree_priority) {
-      case SAME_PRIORITY_FOR_BOTH_TREES:
-        mts.bin = std::min(tree_bin[ACTIVE_TREE], tree_bin[PENDING_TREE]);
-        tile_priority = tile->combined_priority();
-        break;
-      case SMOOTHNESS_TAKES_PRIORITY:
-        mts.bin = tree_bin[ACTIVE_TREE];
-        tile_priority = active_priority;
-        break;
-      case NEW_CONTENT_TAKES_PRIORITY:
-        mts.bin = tree_bin[PENDING_TREE];
-        tile_priority = pending_priority;
-        break;
-    }
-
-    // Bump up the priority if we determined it's NEVER_BIN on one tree,
-    // but is still required on the other tree.
-    bool is_in_never_bin_on_both_trees = tree_bin[ACTIVE_TREE] == NEVER_BIN &&
-                                         tree_bin[PENDING_TREE] == NEVER_BIN;
-
-    if (mts.bin == NEVER_BIN && !is_in_never_bin_on_both_trees)
-      mts.bin = tile_is_active ? AT_LAST_AND_ACTIVE_BIN : AT_LAST_BIN;
-
-    mts.resolution = tile_priority.resolution;
-    mts.priority_bin = tile_priority.priority_bin;
-    mts.distance_to_visible = tile_priority.distance_to_visible;
-    mts.required_for_activation = tile_priority.required_for_activation;
-
-    mts.visible_and_ready_to_draw =
-        tree_bin[ACTIVE_TREE] == NOW_AND_READY_TO_DRAW_BIN;
-
-    // Tiles that are required for activation shouldn't be in NEVER_BIN unless
-    // smoothness takes priority or memory policy allows nothing to be
-    // initialized.
-    DCHECK(!mts.required_for_activation || mts.bin != NEVER_BIN ||
-           tree_priority == SMOOTHNESS_TAKES_PRIORITY ||
-           memory_policy == ALLOW_NOTHING);
-
-    // If the tile is in NEVER_BIN and it does not have an active task, then we
-    // can release the resources early. If it does have the task however, we
-    // should keep it in the prioritized tile set to ensure that AssignGpuMemory
-    // can visit it.
-    if (mts.bin == NEVER_BIN &&
-        !mts.tile_versions[mts.raster_mode].raster_task_) {
-      FreeResourcesForTile(tile);
-      continue;
-    }
-
-    // Insert the tile into a priority set.
-    tiles->InsertTile(tile, mts.bin);
-  }
-}
-
 void TileManager::CleanUpLayers() {
   for (size_t i = 0; i < layers_.size(); ++i) {
     if (layers_[i]->IsDrawnRenderSurfaceLayerListMember())
       continue;
 
     layers_[i]->DidUnregisterLayer();
     std::swap(layers_[i], layers_.back());
     layers_.pop_back();
     --i;
-    prioritized_tiles_dirty_ = true;
   }
 }
 
 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
   TRACE_EVENT0("cc", "TileManager::ManageTiles");
 
   // Update internal state.
-  if (state != global_state_) {
-    global_state_ = state;
-    prioritized_tiles_dirty_ = true;
-  }
+  global_state_ = state;
 
   CleanUpLayers();
 
+  // TODO(vmpstr): See if we still need to keep tiles alive when layers release
+  // them.
+  CleanUpReleasedTiles();
+
   // 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_) {
     rasterizer_->CheckForCompletedTasks();
     did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
   }
 
-  UpdatePrioritizedTileSetIfNeeded();
-
   TileVector tiles_that_need_to_be_rasterized;
-  AssignGpuMemoryToTiles(&prioritized_tiles_,
-                         &tiles_that_need_to_be_rasterized);
+  AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
 
   // Finally, schedule rasterizer tasks.
   ScheduleTasks(tiles_that_need_to_be_rasterized);
 
   TRACE_EVENT_INSTANT1("cc",
                        "DidManage",
                        TRACE_EVENT_SCOPE_THREAD,
                        "state",
                        TracedValue::FromValue(BasicStateAsValue().release()));
 
@@ skipping 21 matching lines @@
 
   bool did_initialize_visible_tile = did_initialize_visible_tile_;
   did_initialize_visible_tile_ = false;
   return did_initialize_visible_tile;
 }
 
 void TileManager::GetMemoryStats(size_t* memory_required_bytes,
                                  size_t* memory_nice_to_have_bytes,
                                  size_t* memory_allocated_bytes,
                                  size_t* memory_used_bytes) const {
-  *memory_required_bytes = memory_required_bytes_;
-  *memory_nice_to_have_bytes = memory_nice_to_have_bytes_;
+  *memory_required_bytes = resource_pool_->total_memory_usage_bytes();
+  *memory_nice_to_have_bytes = resource_pool_->total_memory_usage_bytes();
   *memory_allocated_bytes = resource_pool_->total_memory_usage_bytes();
   *memory_used_bytes = resource_pool_->acquired_memory_usage_bytes();
 }
 
 scoped_ptr<base::Value> TileManager::BasicStateAsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->SetInteger("tile_count", tiles_.size());
   state->Set("global_state", global_state_.AsValue().release());
   state->Set("memory_requirements", GetMemoryRequirementsAsValue().release());
   return state.PassAs<base::Value>();
@@ skipping 19 matching lines @@
                  &memory_allocated_bytes,
                  &memory_used_bytes);
   requirements->SetInteger("memory_required_bytes", memory_required_bytes);
   requirements->SetInteger("memory_nice_to_have_bytes",
                            memory_nice_to_have_bytes);
   requirements->SetInteger("memory_allocated_bytes", memory_allocated_bytes);
   requirements->SetInteger("memory_used_bytes", memory_used_bytes);
   return requirements.PassAs<base::Value>();
 }
 
+bool TileManager::FreeTileResourcesUntilUsageIsWithinBudget(
+    EvictionTileIterator* eviction_iterator,
+    const MemoryBudget& required_budget,
+    MemoryBudget* current_budget,
+    const TilePriority& max_priority,
+    bool evict_unconditionally) {
+  bool evicted_tiles_required_for_activation = false;
+  while (required_budget.Exceeds(*current_budget)) {
+    if (!*eviction_iterator)
+      break;
+
+    Tile* eviction_tile = **eviction_iterator;
+    DCHECK(eviction_tile);
+
+    TilePriority eviction_priority =
+        eviction_tile->priority_for_tree_priority(global_state_.tree_priority);
+
+    if (!evict_unconditionally &&
+        !max_priority.IsHigherPriorityThan(eviction_priority))
+      break;
+
+    size_t eviction_bytes_if_allocated =
+        BytesConsumedIfAllocated(eviction_tile);
+    ManagedTileState& eviction_mts = eviction_tile->managed_state();
+    for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
+      if (eviction_mts.tile_versions[mode].resource_) {
+        current_budget->hard_memory_bytes += eviction_bytes_if_allocated;
+        if (eviction_priority.priority_bin != TilePriority::NOW)
+          current_budget->soft_memory_bytes += eviction_bytes_if_allocated;
+        current_budget->resource_count++;
+      }
+    }
+    FreeResourcesForTile(eviction_tile);
+    ++(*eviction_iterator);
+
+    evicted_tiles_required_for_activation |=
+        eviction_tile->required_for_activation();
+  }
+  return evicted_tiles_required_for_activation;
+}
+
+bool TileManager::TilePriorityViolatesMemoryPolicy(
+    const TilePriority& priority) {
+  switch (global_state_.memory_limit_policy) {
+    case ALLOW_NOTHING:
+      return true;
+    case ALLOW_ABSOLUTE_MINIMUM:
+      return priority.priority_bin > TilePriority::NOW;
+    case ALLOW_PREPAINT_ONLY:
+      return priority.priority_bin > TilePriority::SOON;
+    case ALLOW_ANYTHING:
+      return priority.distance_to_visible ==
+             std::numeric_limits<float>::infinity();
+    case NUM_TILE_MEMORY_LIMIT_POLICIES:

[reveman, 2014/05/28 16:04:12]

Please remove NUM_TILE_MEMORY_LIMIT_POLICIES and move NOTREACHED() out of the
switch statement now that it's no longer needed.

+      NOTREACHED();
+      break;
+  }
+  return true;
+}
+
 void TileManager::AssignGpuMemoryToTiles(
-    PrioritizedTileSet* tiles,
     TileVector* tiles_that_need_to_be_rasterized) {
   TRACE_EVENT0("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();
 
   // Now give memory out to the tiles until we're out, and build
   // the needs-to-be-rasterized queue.
   all_tiles_that_need_to_be_rasterized_have_memory_ = true;
   all_tiles_required_for_activation_have_memory_ = true;
 
+  MemoryBudget budget;
   // Cast to prevent overflow.
-  int64 soft_bytes_available =
-      static_cast<int64>(bytes_releasable_) +
+  budget.soft_memory_bytes =
       static_cast<int64>(global_state_.soft_memory_limit_in_bytes) -
       static_cast<int64>(resource_pool_->acquired_memory_usage_bytes());
-  int64 hard_bytes_available =
-      static_cast<int64>(bytes_releasable_) +
+  budget.hard_memory_bytes =
       static_cast<int64>(global_state_.hard_memory_limit_in_bytes) -
       static_cast<int64>(resource_pool_->acquired_memory_usage_bytes());
-  int resources_available = resources_releasable_ +
-                            global_state_.num_resources_limit -
-                            resource_pool_->acquired_resource_count();
-  size_t soft_bytes_allocatable =
-      std::max(static_cast<int64>(0), soft_bytes_available);
-  size_t hard_bytes_allocatable =
-      std::max(static_cast<int64>(0), hard_bytes_available);
-  size_t resources_allocatable = std::max(0, resources_available);
+  budget.resource_count = global_state_.num_resources_limit -
+                          resource_pool_->acquired_resource_count();
+
+  MemoryBudget initial_budget = budget;
+
+  EvictionTileIterator eviction_it(this, global_state_.tree_priority);
+
+  MemoryBudget required_budget;
+  required_budget.soft_memory_bytes = 0;
+  required_budget.hard_memory_bytes = 0;
+  required_budget.resource_count = 0;
+
+  bool evicted_tiles_required_for_activation =
+      FreeTileResourcesUntilUsageIsWithinBudget(
+          &eviction_it, required_budget, &budget, TilePriority(), true);
 
   size_t bytes_that_exceeded_memory_budget = 0;
-  size_t soft_bytes_left = soft_bytes_allocatable;
-  size_t hard_bytes_left = hard_bytes_allocatable;
 
-  size_t resources_left = resources_allocatable;
   bool oomed_soft = false;
   bool oomed_hard = false;
   bool have_hit_soft_memory = false;  // Soft memory comes after hard.
 
   unsigned schedule_priority = 1u;
-  for (PrioritizedTileSet::Iterator it(tiles, true); it; ++it) {
+  for (RasterTileIterator it(this, global_state_.tree_priority); it; ++it) {
     Tile* tile = *it;
+    TilePriority priority =
+        tile->priority_for_tree_priority(global_state_.tree_priority);
+
+    if (TilePriorityViolatesMemoryPolicy(priority))
+      break;
+
     ManagedTileState& mts = tile->managed_state();
 
     mts.scheduled_priority = schedule_priority++;
 
     mts.raster_mode = tile->DetermineOverallRasterMode();
 
     ManagedTileState::TileVersion& tile_version =
         mts.tile_versions[mts.raster_mode];
 
-    // If this tile doesn't need a resource, then nothing to do.
-    if (!tile_version.requires_resource())
+    // If this tile version is ready to draw, then nothing to do.
+    if (tile_version.IsReadyToDraw())
       continue;
 
-    // If the tile is not needed, free it up.
-    if (mts.bin == NEVER_BIN) {
-      FreeResourcesForTile(tile);
-      continue;
-    }
-
-    const bool tile_uses_hard_limit = mts.bin <= NOW_BIN;
+    const bool tile_uses_hard_limit =
+        priority.priority_bin == TilePriority::NOW;
     const size_t bytes_if_allocated = BytesConsumedIfAllocated(tile);
-    const size_t tile_bytes_left =
-        (tile_uses_hard_limit) ? hard_bytes_left : soft_bytes_left;
 
     // Hard-limit is reserved for tiles that would cause a calamity
     // if they were to go away, so by definition they are the highest
     // priority memory, and must be at the front of the list.
     DCHECK(!(have_hit_soft_memory && tile_uses_hard_limit));
     have_hit_soft_memory |= !tile_uses_hard_limit;
 
-    size_t tile_bytes = 0;
-    size_t tile_resources = 0;
+    int64 tile_bytes = 0;
+    int tile_resources = 0;
 
     // It costs to maintain a resource.
     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
       if (mts.tile_versions[mode].resource_) {
         tile_bytes += bytes_if_allocated;
         tile_resources++;
       }
     }
 
-    // Allow lower priority tiles with initialized resources to keep
-    // their memory by only assigning memory to new raster tasks if
-    // they can be scheduled.
-    bool reached_scheduled_raster_tasks_limit =
-        tiles_that_need_to_be_rasterized->size() >= kScheduledRasterTasksLimit;
-    if (!reached_scheduled_raster_tasks_limit) {
-      // If we don't have the required version, and it's not in flight
-      // then we'll have to pay to create a new task.
-      if (!tile_version.resource_ && !tile_version.raster_task_) {
-        tile_bytes += bytes_if_allocated;
-        tile_resources++;
-      }
+    // If we don't have the required version, and it's not in flight
+    // then we'll have to pay to create a new task.
+    if (!tile_version.resource_ && !tile_version.raster_task_) {
+      tile_bytes += bytes_if_allocated;
+      tile_resources++;
     }
 
-    // Tile is OOM.
-    if (tile_bytes > tile_bytes_left || tile_resources > resources_left) {
+    required_budget.soft_memory_bytes = 0;
+    required_budget.hard_memory_bytes = 0;
+    required_budget.resource_count = tile_resources;
+    if (tile_uses_hard_limit)
+      required_budget.hard_memory_bytes = tile_bytes;
+    else
+      required_budget.soft_memory_bytes = tile_bytes;
+
+    // Handle OOM tiles.
+    evicted_tiles_required_for_activation =
+        FreeTileResourcesUntilUsageIsWithinBudget(
+            &eviction_it, required_budget, &budget, priority, false) ||
+        evicted_tiles_required_for_activation;
+
+    // Tile is still OOM.
+    if (required_budget.Exceeds(budget)) {
       FreeResourcesForTile(tile);
 
       // This tile was already on screen and now its resources have been
       // released. In order to prevent checkerboarding, set this tile as
       // rasterize on demand immediately.
       if (mts.visible_and_ready_to_draw && use_rasterize_on_demand_)
         tile_version.set_rasterize_on_demand();
 
       oomed_soft = true;
       if (tile_uses_hard_limit) {
         oomed_hard = true;
         bytes_that_exceeded_memory_budget += tile_bytes;
       }
     } else {
-      resources_left -= tile_resources;
-      hard_bytes_left -= tile_bytes;
-      soft_bytes_left =
-          (soft_bytes_left > tile_bytes) ? soft_bytes_left - tile_bytes : 0;
+      budget.resource_count -= tile_resources;
+      budget.hard_memory_bytes -= tile_bytes;
+      budget.soft_memory_bytes = (budget.soft_memory_bytes > tile_bytes)
+                                     ? budget.soft_memory_bytes - tile_bytes
+                                     : 0;
       if (tile_version.resource_)
         continue;
     }
 
     DCHECK(!tile_version.resource_);
 
     // Tile shouldn't be rasterized if |tiles_that_need_to_be_rasterized|
     // has reached it's limit or we've failed to assign gpu memory to this
     // or any higher priority tile. Preventing tiles that fit into memory
     // budget to be rasterized when higher priority tile is oom is
     // important for two reasons:
     // 1. Tile size should not impact raster priority.
     // 2. Tiles with existing raster task could otherwise incorrectly
     //    be added as they are not affected by |bytes_allocatable|.
     bool can_schedule_tile =
-        !oomed_soft && !reached_scheduled_raster_tasks_limit;
+        !oomed_soft &&
+        tiles_that_need_to_be_rasterized->size() < kScheduledRasterTasksLimit;
 
     if (!can_schedule_tile) {
       all_tiles_that_need_to_be_rasterized_have_memory_ = false;
-      if (tile->required_for_activation())
-        all_tiles_required_for_activation_have_memory_ = false;
-      it.DisablePriorityOrdering();
-      continue;
+      all_tiles_required_for_activation_have_memory_ =

[reveman, 2014/05/28 16:04:12]

I don't think all_tiles_required_for_activation_have_memory_ makes sense
anymore. No good way to accurately determine this and also not necessary. We can
remove it completely or maybe replace it with
some_tiles_required_for_activation_are_pending_ to avoid some unnecessary calls
to CheckIfReadyToActivate.

+          !it.HasTilesRequiredForActivation() &&
+          !evicted_tiles_required_for_activation;
+      break;
     }
 
     tiles_that_need_to_be_rasterized->push_back(tile);
   }
 
   // OOM reporting uses hard-limit, soft-OOM is normal depending on limit.
   ever_exceeded_memory_budget_ |= oomed_hard;
   if (ever_exceeded_memory_budget_) {
     TRACE_COUNTER_ID2("cc",
                       "over_memory_budget",
                       this,
                       "budget",
                       global_state_.hard_memory_limit_in_bytes,
                       "over",
                       bytes_that_exceeded_memory_budget);
   }
   memory_stats_from_last_assign_.total_budget_in_bytes =
       global_state_.hard_memory_limit_in_bytes;
   memory_stats_from_last_assign_.bytes_allocated =
-      hard_bytes_allocatable - hard_bytes_left;
+      initial_budget.hard_memory_bytes - budget.hard_memory_bytes;
   memory_stats_from_last_assign_.bytes_unreleasable =
       resource_pool_->acquired_memory_usage_bytes() - bytes_releasable_;
   memory_stats_from_last_assign_.bytes_over = bytes_that_exceeded_memory_budget;
 }
 
 void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) {
   ManagedTileState& mts = tile->managed_state();
   if (mts.tile_versions[mode].resource_) {
     resource_pool_->ReleaseResource(mts.tile_versions[mode].resource_.Pass());
 
@@ skipping 241 matching lines @@
                                                          content_rect,
                                                          opaque_rect,
                                                          contents_scale,
                                                          layer_id,
                                                          source_frame_number,
                                                          flags));
   DCHECK(tiles_.find(tile->id()) == tiles_.end());
 
   tiles_[tile->id()] = tile;
   used_layer_counts_[tile->layer_id()]++;
-  prioritized_tiles_dirty_ = true;
   return tile;
 }
 
 void TileManager::RegisterPictureLayerImpl(PictureLayerImpl* layer) {
   DCHECK(std::find(layers_.begin(), layers_.end(), layer) == layers_.end());
   layers_.push_back(layer);
 }
 
 void TileManager::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
@@ skipping 14 matching lines @@
     PictureLayerImpl* layer = *it;
 
     // This is a recycle tree layer, we can safely skip since the tiles on this
     // layer have to be accessible via the active tree.
     if (!layer->IsOnActiveOrPendingTree())
       continue;
 
     PictureLayerImpl* twin_layer = layer->GetTwinLayer();
 
     // If the twin layer is recycled, it is not a valid twin.
-    if (twin_layer && !twin_layer->IsOnActiveOrPendingTree())
+    // Note another case twin is not valid is if it wasn't yet registered in
+    // this tile manager. This can happen at the start of a new page when we
+    // only update the pending tree's priority after the first commit.
+    if (twin_layer && (!twin_layer->IsOnActiveOrPendingTree() ||
+                       !twin_layer->LayerRegisteredInTileManager())) {
       twin_layer = NULL;
+    }
 
     PairedPictureLayer paired_layer;
     WhichTree tree = layer->GetTree();
 
     // If the current tree is ACTIVE_TREE, then always generate a paired_layer.
     // If current tree is PENDING_TREE, then only generate a paired_layer if
     // there is no twin layer.
     if (tree == ACTIVE_TREE) {
       DCHECK(!twin_layer || twin_layer->GetTree() == PENDING_TREE);
       paired_layer.active_layer = layer;
@@ skipping 42 matching lines @@
       paired_iterators_.push_back(paired_iterator);
       iterator_heap_.push_back(&paired_iterators_.back());
     }
   }
 
   std::make_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_);
 }
 
 TileManager::RasterTileIterator::~RasterTileIterator() {}
 
+bool TileManager::RasterTileIterator::HasTilesRequiredForActivation() const {
+  for (std::vector<PairedPictureLayerIterator*>::const_iterator it =
+           iterator_heap_.begin();
+       it != iterator_heap_.end();
+       ++it) {
+    const PairedPictureLayerIterator* pair = *it;
+
+    // Tiles required for activation can only come from pending layers.
+    if (pair->pending_iterator.HasTilesRequiredForActivation())
+      return true;
+  }
+  return false;
+}
+
 TileManager::RasterTileIterator& TileManager::RasterTileIterator::operator++() {
   DCHECK(*this);
 
   std::pop_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_);
   PairedPictureLayerIterator* paired_iterator = iterator_heap_.back();
   iterator_heap_.pop_back();
 
   paired_iterator->PopTile(tree_priority_);
   if (paired_iterator->PeekTile(tree_priority_) != NULL) {
     iterator_heap_.push_back(paired_iterator);
@@ skipping 112 matching lines @@
 
   Tile* a_tile = **a_pair.first;
   Tile* b_tile = **b_pair.first;
 
   const TilePriority& a_priority =
       a_tile->priority_for_tree_priority(tree_priority_);
   const TilePriority& b_priority =
       b_tile->priority_for_tree_priority(tree_priority_);
   bool prioritize_low_res = tree_priority_ == SMOOTHNESS_TAKES_PRIORITY;
 
-  if (b_priority.resolution != a_priority.resolution) {
+  if (b_priority.priority_bin == a_priority.priority_bin &&
+      b_priority.resolution != a_priority.resolution) {
     return (prioritize_low_res && b_priority.resolution == LOW_RESOLUTION) ||
            (!prioritize_low_res && b_priority.resolution == HIGH_RESOLUTION) ||
            (a_priority.resolution == NON_IDEAL_RESOLUTION);
   }
 
   return b_priority.IsHigherPriorityThan(a_priority);
 }
 
 TileManager::EvictionTileIterator::EvictionTileIterator()
-    : comparator_(SAME_PRIORITY_FOR_BOTH_TREES) {}
+    : initialized_(true),
+      tile_manager_(NULL),
+      comparator_(SAME_PRIORITY_FOR_BOTH_TREES) {
+}
 
 TileManager::EvictionTileIterator::EvictionTileIterator(
     TileManager* tile_manager,
     TreePriority tree_priority)
-    : tree_priority_(tree_priority), comparator_(tree_priority) {
+    : initialized_(false),
+      tile_manager_(tile_manager),
+      tree_priority_(tree_priority),
+      comparator_(tree_priority) {
+}
+
+void TileManager::EvictionTileIterator::Initialize() {
   std::vector<TileManager::PairedPictureLayer> paired_layers;
 
-  tile_manager->GetPairedPictureLayers(&paired_layers);
+  tile_manager_->GetPairedPictureLayers(&paired_layers);
 
   paired_iterators_.reserve(paired_layers.size());
   iterator_heap_.reserve(paired_layers.size());
   for (std::vector<TileManager::PairedPictureLayer>::iterator it =
            paired_layers.begin();
        it != paired_layers.end();
        ++it) {
     PairedPictureLayerIterator paired_iterator;
     if (it->active_layer) {
       paired_iterator.active_iterator =
           PictureLayerImpl::LayerEvictionTileIterator(it->active_layer,
                                                       tree_priority_);
     }
 
     if (it->pending_layer) {
       paired_iterator.pending_iterator =
           PictureLayerImpl::LayerEvictionTileIterator(it->pending_layer,
                                                       tree_priority_);
     }
 
     if (paired_iterator.PeekTile(tree_priority_) != NULL) {
       paired_iterators_.push_back(paired_iterator);
       iterator_heap_.push_back(&paired_iterators_.back());
     }
   }
 
   std::make_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_);
+  initialized_ = true;
 }
 
 TileManager::EvictionTileIterator::~EvictionTileIterator() {}
 
 TileManager::EvictionTileIterator& TileManager::EvictionTileIterator::
 operator++() {
+  DCHECK(initialized_);
+
   std::pop_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_);
   PairedPictureLayerIterator* paired_iterator = iterator_heap_.back();
   iterator_heap_.pop_back();
 
   paired_iterator->PopTile(tree_priority_);
   if (paired_iterator->PeekTile(tree_priority_) != NULL) {
     iterator_heap_.push_back(paired_iterator);
     std::push_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_);
   }
   return *this;
 }
 
-TileManager::EvictionTileIterator::operator bool() const {
+TileManager::EvictionTileIterator::operator bool() {
+  if (!initialized_)
+    Initialize();
+
   return !iterator_heap_.empty();
 }
 
 Tile* TileManager::EvictionTileIterator::operator*() {
+  DCHECK(initialized_);
   DCHECK(*this);
   return iterator_heap_.front()->PeekTile(tree_priority_);
 }
 
 TileManager::EvictionTileIterator::PairedPictureLayerIterator::
     PairedPictureLayerIterator() {}
 
 TileManager::EvictionTileIterator::PairedPictureLayerIterator::
     ~PairedPictureLayerIterator() {}
 
@@ skipping 91 matching lines @@
   }
   return a_priority.IsHigherPriorityThan(b_priority);
 }
 
 void TileManager::SetRasterizerForTesting(Rasterizer* rasterizer) {
   rasterizer_ = rasterizer;
   rasterizer_->SetClient(this);
 }
 
 }  // namespace cc