cc: Bump up pending tree now tiles order for smoothness mode.

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 494 matching lines @@
       return false;
     }
 
     *usage -= MemoryUsage::FromTile(tile);
     FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
     eviction_priority_queue_.Pop();
   }
   return true;
 }
 
-bool TileManager::TilePriorityViolatesMemoryPolicy(
-    const TilePriority& priority) {
+bool TileManager::TileViolatesMemoryPolicy(const Tile* tile) {
+  bool memory_policy_violated = true;
+  const TilePriority& priority =
+      tile->priority_for_tree_priority(global_state_.tree_priority);
   switch (global_state_.memory_limit_policy) {
     case ALLOW_NOTHING:
+      // In the case of ALLOW_NOTHING, there are no special cases. A tile always
+      // violated memory policy.
       return true;
     case ALLOW_ABSOLUTE_MINIMUM:
-      return priority.priority_bin > TilePriority::NOW;
+      memory_policy_violated = priority.priority_bin > TilePriority::NOW;
+      break;
     case ALLOW_PREPAINT_ONLY:
-      return priority.priority_bin > TilePriority::SOON;
+      memory_policy_violated = priority.priority_bin > TilePriority::SOON;
+      break;
     case ALLOW_ANYTHING:
-      return priority.distance_to_visible ==
-             std::numeric_limits<float>::infinity();
+      memory_policy_violated = priority.distance_to_visible ==
+                               std::numeric_limits<float>::infinity();
+      break;
   }
-  NOTREACHED();
-  return true;

[reveman, 2014/10/13 19:45:11]

can we keep this NOTREACHED statement?

[vmpstr, 2014/10/13 20:20:14]

Done.

+
+  // If memory policy was violated, we need to check whether this tile is coming
+  // from the NOW bin on the pending tree. The reason for this is that there is
+  // a possibility that a pending tree tile could be required for activation and
+  // we don't want to starve activation in any of the above cases.
+  // TODO(vmpstr): Note that it is insufficient to check whether tile is
+  // required for activation, since pending tree iterator can return NOW bin
+  // tiles not required for activation before NOW bin tiles that are required.
+  // The todo here is to fix this, so that we can check only the activation
+  // requirement.
+  if (memory_policy_violated) {
+    const TilePriority& pending_priority = tile->priority(PENDING_TREE);
+    memory_policy_violated = pending_priority.priority_bin != TilePriority::NOW;
+  }

[reveman, 2014/10/13 19:45:11]

Looks like this is just being tacked on as a quick fix. Can we refactor this
function so it more appropriately takes priority on both trees into account?
Maybe take both active_prio and pending_prio into account in the switch
statement above. Either ignoring the tree priority or by adding a second level
switch statement based on it that makes us do whatever is appropriate.

[vmpstr, 2014/10/13 20:20:14]

Reworked this a bit.

+  return memory_policy_violated;
 }
 
 void TileManager::AssignGpuMemoryToTiles(
     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
@@ skipping 13 matching lines @@
   MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(),
                            resource_pool_->acquired_resource_count());
 
   eviction_priority_queue_is_up_to_date_ = false;
   raster_priority_queue_.Reset();
   client_->BuildRasterQueue(&raster_priority_queue_,
                             global_state_.tree_priority);
 
   while (!raster_priority_queue_.IsEmpty()) {
     Tile* tile = raster_priority_queue_.Top();
-    TilePriority priority =
-        tile->priority_for_tree_priority(global_state_.tree_priority);
-
-    if (TilePriorityViolatesMemoryPolicy(priority))
+    if (TileViolatesMemoryPolicy(tile))
       break;
 
     // We won't be able to schedule this tile, so break out early.
     if (tiles_that_need_to_be_rasterized->size() >=
         kScheduledRasterTasksLimit) {
       all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
       break;
     }
 
     ManagedTileState& mts = tile->managed_state();
     mts.scheduled_priority = schedule_priority++;
 
     DCHECK(mts.draw_info.mode() ==
                ManagedTileState::DrawInfo::PICTURE_PILE_MODE ||
            !mts.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 (!mts.raster_task.get()) {
       memory_required_by_tile_to_be_scheduled = MemoryUsage::FromConfig(
           tile->size(), resource_pool_->resource_format());
     }
 
+    const TilePriority& priority =
+        tile->priority_for_tree_priority(global_state_.tree_priority);
     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(
@@ skipping 306 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