cc: Low quality support for low res tiles

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 "base/time.h"
 #include "cc/base/math_util.h"
@@ skipping 145 matching lines @@
       draw_transform(),
       gfx::QuadF(rect),
       &clipped);
   if (ShowDebugBorders()) {
     for (PictureLayerTilingSet::CoverageIterator iter(
         tilings_.get(), contents_scale_x(), rect, ideal_contents_scale_);
          iter;
          ++iter) {
       SkColor color;
       float width;
-      if (*iter && iter->tile_version().IsReadyToDraw()) {
-        ManagedTileState::TileVersion::Mode mode = iter->tile_version().mode();
+      TileRasterMode raster_mode;
+      if (*iter && iter->IsReadyToDraw(&raster_mode)) {
+        ManagedTileState::TileVersion::Mode mode =
+            iter->tile_version(raster_mode).mode();
         if (mode == ManagedTileState::TileVersion::SOLID_COLOR_MODE) {
           color = DebugColors::SolidColorTileBorderColor();
           width = DebugColors::SolidColorTileBorderWidth(layer_tree_impl());
         } else if (mode == ManagedTileState::TileVersion::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) {
@@ skipping 22 matching lines @@
 
   // Keep track of the tilings that were used so that tilings that are
   // unused can be considered for removal.
   std::vector<PictureLayerTiling*> seen_tilings;
 
   for (PictureLayerTilingSet::CoverageIterator iter(
       tilings_.get(), contents_scale_x(), rect, ideal_contents_scale_);
        iter;
        ++iter) {
     gfx::Rect geometry_rect = iter.geometry_rect();
-    if (!*iter || !iter->tile_version().IsReadyToDraw()) {
+    if (!*iter || !iter->IsReadyToDraw(NULL)) {
       if (DrawCheckerboardForMissingTiles()) {
         // TODO(enne): Figure out how to show debug "invalidated checker" color
         scoped_ptr<CheckerboardDrawQuad> quad = CheckerboardDrawQuad::Create();
         SkColor color = DebugColors::DefaultCheckerboardColor();
         quad->SetNew(shared_quad_state, geometry_rect, color);
         if (quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data))
           append_quads_data->num_missing_tiles++;
       } else {
         SkColor color = SafeOpaqueBackgroundColor();
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
         quad->SetNew(shared_quad_state, geometry_rect, color, false);
         if (quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data))
           append_quads_data->num_missing_tiles++;
       }
 
       append_quads_data->had_incomplete_tile = true;
       continue;
     }
 
-    const ManagedTileState::TileVersion& tile_version = iter->tile_version();
+    TileRasterMode raster_mode;
+    iter->IsReadyToDraw(&raster_mode);

[reveman, 2013/06/06 06:02:02]

can we consolidate this with the IsReadyToDraw call above?

[vmpstr, 2013/06/06 15:20:22]

Done.

+    const ManagedTileState::TileVersion& tile_version =
+        iter->tile_version(raster_mode);
     switch (tile_version.mode()) {
       case ManagedTileState::TileVersion::RESOURCE_MODE: {
         gfx::RectF texture_rect = iter.texture_rect();
         gfx::Rect opaque_rect = iter->opaque_rect();
         opaque_rect.Intersect(content_rect);
 
         if (iter->contents_scale() != ideal_contents_scale_)
           append_quads_data->had_incomplete_tile = true;
 
         scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
@@ skipping 365 matching lines @@
 }
 
 ResourceProvider::ResourceId PictureLayerImpl::ContentsResourceId() const {
   gfx::Rect content_rect(content_bounds());
   float scale = contents_scale_x();
   for (PictureLayerTilingSet::CoverageIterator
            iter(tilings_.get(), scale, content_rect, ideal_contents_scale_);
        iter;
        ++iter) {
     // Mask resource not ready yet.
-    if (!*iter ||
-        iter->tile_version().mode() !=
-            ManagedTileState::TileVersion::RESOURCE_MODE ||
-        !iter->tile_version().IsReadyToDraw())
+    TileRasterMode raster_mode;
+    if (!*iter || !iter->IsReadyToDraw(&raster_mode))
       return 0;
+
+    if (iter->tile_version(raster_mode).mode() !=
+            ManagedTileState::TileVersion::RESOURCE_MODE)
+      return 0;
+
     // Masks only supported if they fit on exactly one tile.
     if (iter.geometry_rect() != content_rect)
       return 0;
-    return iter->tile_version().get_resource_id();
+
+    return iter->tile_version(raster_mode).get_resource_id();
   }
   return 0;
 }
 
 void PictureLayerImpl::MarkVisibleResourcesAsRequired() const {
   DCHECK(layer_tree_impl()->IsPendingTree());
   DCHECK(!layer_tree_impl()->needs_update_draw_properties());
   DCHECK(ideal_contents_scale_);
   DCHECK_GT(tilings_->num_tilings(), 0u);
 
@@ skipping 29 matching lines @@
     if (tiling->resolution() == HIGH_RESOLUTION) {
       DCHECK(!high_res) << "There can only be one high res tiling";
       high_res = tiling;
       continue;
     }
     for (PictureLayerTiling::CoverageIterator iter(tiling,
                                                    contents_scale_x(),
                                                    rect);
          iter;
          ++iter) {
-      if (!*iter || !iter->tile_version().IsReadyToDraw())
+      if (!*iter || !iter->IsReadyToDraw(NULL))
         continue;
 
       // This iteration is over the visible content rect which is potentially
       // less conservative than projecting the viewport into the layer.
       // Ignore tiles that are know to be outside the viewport.
       if (iter->priority(PENDING_TREE).distance_to_visible_in_pixels != 0)
         continue;
 
       missing_region.Subtract(iter.geometry_rect());
       iter->mark_required_for_activation();
@@ skipping 328 matching lines @@
   state->Set("tilings", tilings_->AsValue().release());
   state->Set("pictures", pile_->AsValue().release());
   state->Set("invalidation", invalidation_.AsValue().release());
 }
 
 size_t PictureLayerImpl::GPUMemoryUsageInBytes() const {
   return tilings_->GPUMemoryUsageInBytes();
 }
 
 }  // namespace cc