cc: Simplify picture layer tiling update tile priorities.

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 97 matching lines @@
      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) {
-  // The amount of time/pixels for which we want to have prepainting coverage.
-  // Note: All very arbitrary constants: metric-based tuning is welcome!
-  const float kPrepaintingWindowTimeSeconds = 1.0f;
   const float kBackflingGuardDistancePixels = 314.0f;
-  // Note: The max distances here assume that SOON_BIN will never help overcome
-  // raster being too slow (only caching in advance will do that), so we just
-  // need enough padding to handle some latency and per-tile variability.
-  const float kMaxPrepaintingDistancePixelsHighRes = 2000.0f;
-  const float kMaxPrepaintingDistancePixelsLowRes = 4000.0f;
 
-  if (prio.distance_to_visible_in_pixels ==
-      std::numeric_limits<float>::infinity())
-    return NEVER_BIN;
-
-  if (prio.time_to_visible_in_seconds == 0)
+  if (prio.priority_bin == TilePriority::NOW)
     return NOW_BIN;
 
-  if (prio.resolution == NON_IDEAL_RESOLUTION)
-    return EVENTUALLY_BIN;
+  if (prio.priority_bin == TilePriority::SOON ||
+      prio.distance_to_visible < kBackflingGuardDistancePixels)
+    return SOON_BIN;
 
-  float max_prepainting_distance_pixels =
-      (prio.resolution == HIGH_RESOLUTION)
-          ? kMaxPrepaintingDistancePixelsHighRes
-          : kMaxPrepaintingDistancePixelsLowRes;
-
-  // Soon bin if we are within backfling-guard, or under both the time window
-  // and the max distance window.
-  if (prio.distance_to_visible_in_pixels < kBackflingGuardDistancePixels ||
-      (prio.time_to_visible_in_seconds < kPrepaintingWindowTimeSeconds &&
-       prio.distance_to_visible_in_pixels <= max_prepainting_distance_pixels))
-    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(
@@ skipping 282 matching lines @@
 
     // 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.time_to_needed_in_seconds = tile_priority.time_to_visible_in_seconds;
-    mts.distance_to_visible_in_pixels =
-        tile_priority.distance_to_visible_in_pixels;
+    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;
 
     if (mts.bin == NEVER_BIN) {
       FreeResourcesForTile(tile);
       continue;
     }
 
@@ skipping 481 matching lines @@
     resource_pool_->ReleaseResource(resource.Pass());
   } else {
     tile_version.set_use_resource();
     tile_version.resource_ = resource.Pass();
 
     bytes_releasable_ += BytesConsumedIfAllocated(tile);
     ++resources_releasable_;
   }
 
   FreeUnusedResourcesForTile(tile);
-  if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
+  if (tile->priority(ACTIVE_TREE).distance_to_visible == 0.f)
     did_initialize_visible_tile_ = true;
 }
 
 scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
                                             const gfx::Size& tile_size,
                                             const gfx::Rect& content_rect,
                                             const gfx::Rect& opaque_rect,
                                             float contents_scale,
                                             int layer_id,
                                             int source_frame_number,
                                             int flags) {
   scoped_refptr<Tile> tile = make_scoped_refptr(new Tile(this,
                                                          picture_pile,
                                                          tile_size,
                                                          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;
 }
 
 }  // namespace cc