cc: Move tiling management out of draw properties calculation.

cc/layers/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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/time/time.h"
@@ skipping 127 matching lines @@
 
 void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
                                    AppendQuadsData* append_quads_data) {
   DCHECK(!needs_post_commit_initialization_);
   gfx::Rect rect(visible_content_rect());
   gfx::Rect content_rect(content_bounds());
 
   SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
   PopulateSharedQuadState(shared_quad_state);
 
+  gfx::Transform scaled_transform = draw_transform();
+  scaled_transform.Scale(contents_scale_x(), contents_scale_x());

[enne (OOO), 2014/05/13 18:04:09]

This contents_scale is the wrong value.  You need to move the code from
CalculateContentsScale that finds max_contents_scale and use that scale here.

[danakj, 2014/05/13 18:10:07]

the contents_scale_x() is going to be 1 always now, right? so instead here we
should compute the scale we want to use, which would be the max scale of all the
picture layer impl's tilings.

+
   if (current_draw_mode_ == DRAW_MODE_RESOURCELESS_SOFTWARE) {
     AppendDebugBorderQuad(
         quad_sink,
         shared_quad_state,
         append_quads_data,
         DebugColors::DirectPictureBorderColor(),
         DebugColors::DirectPictureBorderWidth(layer_tree_impl()));
 
     gfx::Rect geometry_rect = rect;
     gfx::Rect opaque_rect = contents_opaque() ? geometry_rect : gfx::Rect();
     gfx::Rect visible_geometry_rect =
-        quad_sink->UnoccludedContentRect(geometry_rect, draw_transform());
+        quad_sink->UnoccludedContentRect(geometry_rect, scaled_transform);
     if (visible_geometry_rect.IsEmpty())
       return;
 
     gfx::Size texture_size = rect.size();
     gfx::RectF texture_rect = gfx::RectF(texture_size);
     gfx::Rect quad_content_rect = rect;
     float contents_scale = contents_scale_x();
 
     scoped_ptr<PictureDrawQuad> quad = PictureDrawQuad::Create();
     quad->SetNew(shared_quad_state,
                  geometry_rect,
                  opaque_rect,
                  visible_geometry_rect,
                  texture_rect,
                  texture_size,
                  RGBA_8888,
                  quad_content_rect,
                  contents_scale,
                  pile_);
     quad_sink->Append(quad.PassAs<DrawQuad>());
     append_quads_data->num_missing_tiles++;
     return;
   }
 
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   if (ShowDebugBorders()) {
     for (PictureLayerTilingSet::CoverageIterator iter(
         tilings_.get(), contents_scale_x(), rect, ideal_contents_scale_);

[enne (OOO), 2014/05/13 18:04:09]

This should be max_contents_scale.

          iter;
          ++iter) {
       SkColor color;
       float width;
       if (*iter && iter->IsReadyToDraw()) {
         ManagedTileState::TileVersion::Mode mode =
             iter->GetTileVersionForDrawing().mode();
         if (mode == ManagedTileState::TileVersion::SOLID_COLOR_MODE) {
           color = DebugColors::SolidColorTileBorderColor();
           width = DebugColors::SolidColorTileBorderWidth(layer_tree_impl());
@@ skipping 30 matching lines @@
       quad_sink->Append(debug_border_quad.PassAs<DrawQuad>());
     }
   }
 
   // Keep track of the tilings that were used so that tilings that are
   // unused can be considered for removal.
   std::vector<PictureLayerTiling*> seen_tilings;
 
   bool had_checkerboard_quads = false;
   for (PictureLayerTilingSet::CoverageIterator iter(
       tilings_.get(), contents_scale_x(), rect, ideal_contents_scale_);

[enne (OOO), 2014/05/13 18:04:09]

This should be max_contents_scale.

[danakj, 2014/05/13 18:10:07]

we should use the computed scale from above everywhere instead of the
contents_scale_x() which is 1?

        iter;
        ++iter) {
     gfx::Rect geometry_rect = iter.geometry_rect();
     gfx::Rect visible_geometry_rect =
-        quad_sink->UnoccludedContentRect(geometry_rect, draw_transform());
+        quad_sink->UnoccludedContentRect(geometry_rect, scaled_transform);
     if (visible_geometry_rect.IsEmpty())
       continue;
 
     append_quads_data->visible_content_area +=
         visible_geometry_rect.width() * visible_geometry_rect.height();
 
     if (!*iter || !iter->IsReadyToDraw()) {
       had_checkerboard_quads = true;
       if (draw_checkerboard_for_missing_tiles()) {
         scoped_ptr<CheckerboardDrawQuad> quad = CheckerboardDrawQuad::Create();
@@ skipping 236 matching lines @@
   DCHECK_GT(min_page_scale, 0.f);
   float min_device_scale = 1.f;
   float min_source_scale =
       min_contents_scale / min_page_scale / min_device_scale;
 
   float ideal_page_scale = page_scale_factor;
   float ideal_device_scale = device_scale_factor;
   float ideal_source_scale =
       ideal_contents_scale / ideal_page_scale / ideal_device_scale;
 
   ideal_contents_scale_ = std::max(ideal_contents_scale, min_contents_scale);

[danakj, 2014/05/13 18:10:07]

we still need to compute these values, but during CalculateContentsScale(), but
we need to do them before ManageTilings, or move them over into ManageTilings.

Maybe rename this method to ComputeIdealScales() and have ManageTilings call it?
We'll have to get the various inputs to this from other places such as the layer
draw properties.

DeviceScaleFactor should be available on the LayerTreeImpl.
animating_transform_to_screen is on the DrawProperties. page scale and maximum
animation scale I believe you'll need to store on the DrawProperties to make
them available to this method.

   ideal_page_scale_ = ideal_page_scale;
   ideal_device_scale_ = ideal_device_scale;
   ideal_source_scale_ = std::max(ideal_source_scale, min_source_scale);
 
-  ManageTilings(animating_transform_to_screen,
-                maximum_animation_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 = min_contents_scale;
   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;

[danakj, 2014/05/13 18:10:07]

we would always set these to 1 now, and move this loop to compute the max scale
over to AppendQuads.

[enne (OOO), 2014/05/13 18:04:09]

You need to remove this whole block of code and just set contents_scale_x = 1,
contents_scale_y = 1, and content_bounds = layer_bounds.  If you don't, then you
will "double scale" when you add the scale above in AppendQuads.

[danakj, 2014/05/13 18:11:41]

The LayerImpl implementation of this method should do what we want, so
PictureLayerImpl doesn't need to override it anymore.

   *contents_scale_y = max_contents_scale;
   *content_bounds = gfx::ToCeiledSize(
       gfx::ScaleSize(bounds(), max_contents_scale, max_contents_scale));
 }
 
 skia::RefPtr<SkPicture> PictureLayerImpl::GetPicture() {
   return pile_->GetFlattenedPicture();
 }
 
 scoped_refptr<Tile> PictureLayerImpl::CreateTile(PictureLayerTiling* tiling,
@@ skipping 161 matching lines @@
         *other->tilings_, bounds(), invalidation_, MinimumContentsScale());
   } else {
     RemoveAllTilings();
   }
 
   SanityCheckTilingState();
 }
 
 void PictureLayerImpl::SyncTiling(
     const PictureLayerTiling* tiling) {
-  if (!CanHaveTilingWithScale(tiling->contents_scale()))
+  if (!CanHaveTilingWithScale(tiling->contents_scale()) ||
+      !IsDrawnRenderSurfaceLayerListMember())
     return;
   tilings_->AddTiling(tiling->contents_scale());
 
   // If this tree needs update draw properties, then the tiling will
   // get updated prior to drawing or activation.  If this tree does not
   // need update draw properties, then its transforms are up to date and
   // we can create tiles for this tiling immediately.
   if (!layer_tree_impl()->needs_update_draw_properties() &&
       should_update_tile_priorities_) {
     UpdateTilePriorities();
   }
 }
 
 void PictureLayerImpl::SetIsMask(bool is_mask) {
   if (is_mask_ == is_mask)
     return;
   is_mask_ = is_mask;
   if (tilings_)
     tilings_->RemoveAllTiles();
 }
 
 ResourceProvider::ResourceId PictureLayerImpl::ContentsResourceId() const {
   gfx::Rect content_rect(content_bounds());
   float scale = contents_scale_x();

[danakj, 2014/05/13 18:10:07]

This should also be the max scale from the tilings

   PictureLayerTilingSet::CoverageIterator iter(
       tilings_.get(), scale, content_rect, ideal_contents_scale_);
 
   // Mask resource not ready yet.
   if (!iter || !*iter)
     return 0;
 
   // Masks only supported if they fit on exactly one tile.
   if (iter.geometry_rect() != content_rect)
     return 0;
@@ skipping 237 matching lines @@
         << "A layer with no tilings shouldn't have valid raster scales";
   }
 
   if (change_target_tiling) {
     RecalculateRasterScales(animating_transform_to_screen,
                             maximum_animation_contents_scale);
   }
 
   was_animating_transform_to_screen_ = animating_transform_to_screen;
 
-  if (!change_target_tiling)
+  if (!change_target_tiling || !IsDrawnRenderSurfaceLayerListMember())

[danakj, 2014/05/13 18:10:07]

Let's do this change separately

     return;
 
   PictureLayerTiling* high_res = NULL;
   PictureLayerTiling* low_res = NULL;
 
   PictureLayerTiling* previous_low_res = NULL;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
     if (tiling->contents_scale() == raster_contents_scale_)
       high_res = tiling;
@@ skipping 561 matching lines @@
   return iterator_index_ < iterators_.size();
 }
 
 bool PictureLayerImpl::LayerEvictionTileIterator::IsCorrectType(
     PictureLayerTiling::TilingEvictionTileIterator* it) const {
   return it->get_type() == iteration_stage_ &&
          (**it)->required_for_activation() == required_for_activation_;
 }
 
 }  // namespace cc