cc: Generate tilings at other scales for impl-side painting

cc/picture_layer_tiling.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/picture_layer_tiling.h"
 
 #include "cc/math_util.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
 
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Create(
     float contents_scale,
     gfx::Size tile_size) {
   return make_scoped_ptr(new PictureLayerTiling(contents_scale, tile_size));
 }
 
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Clone() const {
   return make_scoped_ptr(new PictureLayerTiling(*this));
 }
 
 PictureLayerTiling::PictureLayerTiling(float contents_scale,
                                        gfx::Size tile_size)
     : client_(NULL),
       contents_scale_(contents_scale),
-      tiling_data_(tile_size, gfx::Size(), true) {
+      tiling_data_(tile_size, gfx::Size(), true),
+      resolution_(NON_IDEAL_RESOLUTION) {
 }
 
 PictureLayerTiling::~PictureLayerTiling() {
 }
 
 const PictureLayerTiling& PictureLayerTiling::operator=(
     const PictureLayerTiling& tiler) {
   tiling_data_ = tiler.tiling_data_;
   tiles_ = tiler.tiles_;
   return *this;
@@ skipping 15 matching lines @@
     return NULL;
   return iter->second.get();
 }
 
 void PictureLayerTiling::CreateTile(int i, int j) {
   gfx::Rect tile_rect = tiling_data_.TileBoundsWithBorder(i, j);
   tile_rect.set_size(tiling_data_.max_texture_size());
   TileMapKey key(i, j);
   DCHECK(!tiles_[key]);
   tiles_[key] = client_->CreateTile(this, tile_rect);
-
-  // TODO(enne): Remove this when we start setting priorities correctly.
-  TilePriority priority;
-  priority.resolution = HIGH_RESOLUTION;
-  priority.time_to_visible_in_seconds = 1000;
-  tiles_[key]->set_priority(ACTIVE_TREE, priority);
 }
 
 Region PictureLayerTiling::OpaqueRegionInContentRect(
     const gfx::Rect& content_rect) const {
   Region opaque_region;
   // TODO(enne): implement me
   return opaque_region;
 }
 
 void PictureLayerTiling::SetLayerBounds(gfx::Size layer_bounds) {
@@ skipping 185 matching lines @@
   return texture_rect;
 }
 
 gfx::Size PictureLayerTiling::Iterator::texture_size() const {
   return tiling_->tiling_data_.max_texture_size();
 }
 
 void PictureLayerTiling::UpdateTilePriorities(
     WhichTree tree,
     const gfx::Size& device_viewport,
-    float layer_content_scale_x,
-    float layer_content_scale_y,
+    float last_layer_contents_scale,
+    float current_layer_contents_scale,
     const gfx::Transform& last_screen_transform,
     const gfx::Transform& current_screen_transform,
     double time_delta) {
   gfx::Rect content_rect = ContentRect();
   if (content_rect.IsEmpty())
     return;
 
   gfx::Rect view_rect(gfx::Point(), device_viewport);
   int right = tiling_data_.TileXIndexFromSrcCoord(content_rect.width() - 1);
   int bottom = tiling_data_.TileYIndexFromSrcCoord(content_rect.height() - 1);
 
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     TileMapKey key = it->first;
     TilePriority priority;
+    priority.resolution = resolution_;
     if (key.first > right || key.second > bottom) {
       priority.distance_to_visible_in_pixels = std::numeric_limits<int>::max();
       priority.time_to_visible_in_seconds =
           TilePriority::kMaxTimeToVisibleInSeconds;
       it->second->set_priority(tree, priority);
       continue;
     }
 
     gfx::Rect tile_bound = tiling_data_.TileBounds(key.first, key.second);
-    gfx::RectF layer_content_rect = gfx::ScaleRect(
+    gfx::RectF current_layer_content_rect = gfx::ScaleRect(
         tile_bound,
-        layer_content_scale_x / contents_scale_,
-        layer_content_scale_y / contents_scale_);
-    gfx::RectF screen_rect = MathUtil::mapClippedRect(
-        current_screen_transform, layer_content_rect);
-    gfx::RectF previous_rect = MathUtil::mapClippedRect(
-        last_screen_transform, layer_content_rect);
+        current_layer_contents_scale / contents_scale_,
+        current_layer_contents_scale / contents_scale_);
+    gfx::RectF current_screen_rect = MathUtil::mapClippedRect(
+        current_screen_transform, current_layer_content_rect);
+    gfx::RectF last_layer_content_rect = gfx::ScaleRect(
+        tile_bound,
+        last_layer_contents_scale / contents_scale_,
+        last_layer_contents_scale / contents_scale_);
+    gfx::RectF last_screen_rect  = MathUtil::mapClippedRect(
+        last_screen_transform, last_layer_content_rect);
 
-    priority.resolution = HIGH_RESOLUTION;
     priority.time_to_visible_in_seconds =
         TilePriority::TimeForBoundsToIntersect(
-            previous_rect, screen_rect, time_delta, view_rect);
+            last_screen_rect, current_screen_rect, time_delta, view_rect);
 
     priority.distance_to_visible_in_pixels =
-        TilePriority::manhattanDistance(screen_rect, view_rect);
+        TilePriority::manhattanDistance(current_screen_rect, view_rect);
     it->second->set_priority(tree, priority);
   }
 }
 
 }  // namespace cc