Implement on demand quad rasterization for PicturePiles.

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/picture_draw_quad.h"
 #include "cc/quad_sink.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/tile_draw_quad.h"
 #include "cc/util.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace {
 const float kMaxScaleRatioDuringPinch = 2.0f;
@@ skipping 88 matching lines @@
          iter;
          ++iter) {
       SkColor color;
       float width;
       if (*iter && iter->drawing_info().IsReadyToDraw()) {
         ManagedTileState::DrawingInfo::Mode mode = iter->drawing_info().mode();
         if (mode == ManagedTileState::DrawingInfo::SOLID_COLOR_MODE ||
             mode == ManagedTileState::DrawingInfo::TRANSPARENT_MODE) {
           color = DebugColors::SolidColorTileBorderColor();
           width = DebugColors::SolidColorTileBorderWidth(layer_tree_impl());
+        } else if (mode == ManagedTileState::DrawingInfo::PICTURE_PILE_MODE) {
+          color = DebugColors::PictureTileBorderColor();
+          width = DebugColors::PictureTileBorderWidth(layer_tree_impl());
         } else if (iter->priority(ACTIVE_TREE).resolution == HIGH_RESOLUTION) {
           color = DebugColors::HighResTileBorderColor();
           width = DebugColors::HighResTileBorderWidth(layer_tree_impl());
         } else if (iter->priority(ACTIVE_TREE).resolution == LOW_RESOLUTION) {
           color = DebugColors::LowResTileBorderColor();
           width = DebugColors::LowResTileBorderWidth(layer_tree_impl());
         } else if (iter->contents_scale() > contents_scale_x()) {
           color = DebugColors::ExtraHighResTileBorderColor();
           width = DebugColors::ExtraHighResTileBorderWidth(layer_tree_impl());
         } else {
@@ skipping 41 matching lines @@
         if (quadSink->append(quad.PassAs<DrawQuad>(), appendQuadsData))
             appendQuadsData->numMissingTiles++;
       }
 
       appendQuadsData->hadIncompleteTile = true;
       continue;
     }
 
     const ManagedTileState::DrawingInfo& drawing_info = iter->drawing_info();
     switch (drawing_info.mode()) {
-      case ManagedTileState::DrawingInfo::TEXTURE_MODE: {
+      case ManagedTileState::DrawingInfo::TEXTURE_MODE:
+      case ManagedTileState::DrawingInfo::PICTURE_PILE_MODE: {

[vmpstr, 2013/03/13 21:03:08]

I not sure if it's worth combining the two cases, since you only save a few
lines, and then have to do another if/else on this variable again.

[Leandro Graciá Gil, 2013/03/19 17:30:07]

The point is that if we add more code here for TEXTURE_MODE it won't diverge
from the code for PICTURE_PILE_MODE. But I have no strong opinion on this. Let
me know what you prefer and I'll make any required updates.

         if (iter->contents_scale() != ideal_contents_scale_)
           appendQuadsData->hadIncompleteTile = true;
 
         gfx::RectF texture_rect = iter.texture_rect();
         gfx::Rect opaque_rect = iter->opaque_rect();
         opaque_rect.Intersect(content_rect);
 
-        scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
-        quad->SetNew(sharedQuadState,
-                     geometry_rect,
-                     opaque_rect,
-                     drawing_info.get_resource_id(),
-                     texture_rect,
-                     iter.texture_size(),
-                     drawing_info.contents_swizzled());
-        quadSink->append(quad.PassAs<DrawQuad>(), appendQuadsData);
+        if (drawing_info.mode() ==
+            ManagedTileState::DrawingInfo::TEXTURE_MODE) {
+          scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
+          quad->SetNew(sharedQuadState,
+                       geometry_rect,
+                       opaque_rect,
+                       drawing_info.get_resource_id(),
+                       texture_rect,
+                       iter.texture_size(),
+                       drawing_info.contents_swizzled());
+          quadSink->append(quad.PassAs<DrawQuad>(), appendQuadsData);
+        } else {
+          scoped_ptr<PictureDrawQuad> quad = PictureDrawQuad::Create();
+          quad->SetNew(sharedQuadState,
+                       geometry_rect,
+                       opaque_rect,
+                       texture_rect,
+                       iter.texture_size(),
+                       drawing_info.contents_swizzled(),
+                       iter->content_rect(),
+                       iter->contents_scale(),
+                       pile_);
+          quadSink->append(quad.PassAs<DrawQuad>(), appendQuadsData);
+        }
         break;
       }
       case ManagedTileState::DrawingInfo::SOLID_COLOR_MODE: {
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
         quad->SetNew(sharedQuadState,
                      geometry_rect,
                      drawing_info.get_solid_color());
         quadSink->append(quad.PassAs<DrawQuad>(), appendQuadsData);
         break;
       }
       case ManagedTileState::DrawingInfo::TRANSPARENT_MODE:
         break;
-      case ManagedTileState::DrawingInfo::PICTURE_PILE_MODE:
-        // TODO: crbug.com/173011 would fill this part in.
       default:
         NOTREACHED();
     }
 
     if (!seen_tilings.size() || seen_tilings.back() != iter.CurrentTiling())
       seen_tilings.push_back(iter.CurrentTiling());
   }
 
   // Aggressively remove any tilings that are not seen to save memory. Note
   // that this is at the expense of doing cause more frequent re-painting. A
@@ skipping 579 matching lines @@
 scoped_ptr<base::Value> PictureLayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   LayerImpl::AsValueInto(state.get());
 
   state->SetDouble("ideal_contents_scale", ideal_contents_scale_);
   state->Set("tilings", tilings_->AsValue().release());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc