cc: Use maximum tiling contents scales for picture layer scale

cc/picture_layer_impl.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_impl.h"
 
 #include "base/time.h"
 #include "cc/append_quads_data.h"
 #include "cc/checkerboard_draw_quad.h"
 #include "cc/debug_border_draw_quad.h"
 #include "cc/debug_colors.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/tile_draw_quad.h"
 #include "ui/gfx/quad_f.h"
+#include "ui/gfx/size_conversions.h"
 
 namespace cc {
 
 PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* treeImpl, int id)
     : LayerImpl(treeImpl, id),
       tilings_(this),
       pile_(PicturePileImpl::Create()),
       last_update_time_(0),
       is_mask_(false) {
 }
@@ skipping 94 matching lines @@
                  outside_bottom_edge && useAA);
     quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
   }
 }
 
 void PictureLayerImpl::dumpLayerProperties(std::string*, int indent) const {
   // TODO(enne): implement me
 }
 
 void PictureLayerImpl::didUpdateTransforms() {
-  if (drawsContent()) {
-    // TODO(enne): Add tilings during pinch zoom
-    // TODO(enne): Consider culling old tilings after pinch finishes.
-    if (!tilings_.num_tilings()) {
-      AddTiling(contentsScaleX(), TileSize());
-      // TODO(enne): Add a low-res tiling as well.
-    }
-  } else {
-    // TODO(enne): This should be unnecessary once there are two trees.
-    tilings_.Reset();
-  }
-
   gfx::Transform current_screen_space_transform =
       screenSpaceTransform();
   double current_time =
       (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
   double time_delta = 0;
   if (last_update_time_ != 0 && last_bounds_ == bounds() &&
       last_content_bounds_ == contentBounds() &&
       last_content_scale_x_ == contentsScaleX() &&
       last_content_scale_y_ == contentsScaleY()) {
     time_delta = current_time - last_update_time_;
   }
   WhichTree tree = layerTreeImpl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
   tilings_.UpdateTilePriorities(
       tree,
       layerTreeImpl()->device_viewport_size(),
       contentsScaleX(),
       contentsScaleY(),
       last_screen_space_transform_,
       current_screen_space_transform,
       time_delta);
 
   last_screen_space_transform_ = current_screen_space_transform;
   last_update_time_ = current_time;
   last_bounds_ = bounds();
   last_content_bounds_ = contentBounds();
   last_content_scale_x_ = contentsScaleX();
   last_content_scale_y_ = contentsScaleY();
 }
 
+void PictureLayerImpl::calculateContentsScale(
+    float ideal_contents_scale,
+    float* contents_scale_x,
+    float* contents_scale_y,
+    gfx::Size* content_bounds) {
+  if (!drawsContent()) {
+    DCHECK(!tilings_.num_tilings());
+    return;
+  }
+
+  ManageTilings(ideal_contents_scale);
+
+  // The content scale and bounds for a PictureLayerImpl is somewhat fictitious.
+  // There are (usually) several tilings at different scales.  However, the
+  // content bounds is the (integer!) space in which quads are generated.
+  // In order to guarantee that we can fill this integer space with any set of
+  // tilings (and then map back to floating point texture coordinates), the
+  // contents scale must be at least as large as the largest of the tilings.
+  float max_contents_scale = 1.f;
+  for (size_t i = 0; i < tilings_.num_tilings(); ++i) {
+    const PictureLayerTiling* tiling = tilings_.tiling_at(i);
+    max_contents_scale = std::max(max_contents_scale, tiling->contents_scale());
+  }
+
+  *contents_scale_x = max_contents_scale;
+  *contents_scale_y = max_contents_scale;
+  *content_bounds = gfx::ToCeiledSize(
+      gfx::ScaleSize(bounds(), max_contents_scale, max_contents_scale));
+}
+
 scoped_refptr<Tile> PictureLayerImpl::CreateTile(PictureLayerTiling* tiling,
                                                  gfx::Rect rect) {
   TileManager* tile_manager = layerTreeImpl()->tile_manager();
 
   return make_scoped_refptr(new Tile(
       tile_manager,
       pile_.get(),
       rect.size(),
       GL_RGBA,
       rect,
@@ skipping 70 matching lines @@
   if (is_mask_) {
     int max_size = layerTreeImpl()->MaxTextureSize();
     return gfx::Size(
         std::min(max_size, contentBounds().width()),
         std::min(max_size, contentBounds().height()));
   }
 
   return layerTreeImpl()->settings().defaultTileSize;
 }
 
+void PictureLayerImpl::ManageTilings(float ideal_contents_scale) {
+  if (drawsContent()) {
+    // TODO(enne): Add tilings during pinch zoom
+    // TODO(enne): Consider culling old tilings after pinch finishes.
+    if (!tilings_.num_tilings()) {
+      AddTiling(ideal_contents_scale, TileSize());
+      // TODO(enne): Add a low-res tiling as well.
+    }
+  } else {
+    // TODO(enne): This should be unnecessary once there are two trees.
+    tilings_.Reset();
+  }
+}
+
 }  // namespace cc