cc: Refactored Tile::GetResourceId

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"
@@ skipping 97 matching lines @@
   if (ShowDebugBorders()) {
     for (PictureLayerTilingSet::Iterator iter(tilings_.get(),
                                               contents_scale_x(),
                                               rect,
                                               ideal_contents_scale_,
                                               layerDeviceAlignment);
          iter;
          ++iter) {
       SkColor color;
       float width;
-      if (*iter && iter->IsReadyToDraw()) {
-        if (iter->is_solid_color() || iter->is_transparent()) {
+      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 (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();
@@ skipping 22 matching lines @@
   for (PictureLayerTilingSet::Iterator iter(tilings_.get(),
                                             contents_scale_x(),
                                             rect,
                                             ideal_contents_scale_,
                                             layerDeviceAlignment);
        iter;
        ++iter) {
 
     gfx::Rect geometry_rect = iter.geometry_rect();
     ResourceProvider::ResourceId resource = 0;
-    if (*iter) {
-      if (iter->is_solid_color()) {
-        scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-        quad->SetNew(sharedQuadState, geometry_rect, iter->solid_color());
-        quadSink->append(quad.PassAs<DrawQuad>(), appendQuadsData);
-
-        if (!seen_tilings.size() || seen_tilings.back() != iter.CurrentTiling())
-          seen_tilings.push_back(iter.CurrentTiling());
-        continue;
-      } else if (iter->is_transparent()) {
-        continue;
-      }
-      resource = iter->GetResourceId();
-    } 
-    if (!resource) {
+    if (!*iter || !iter->drawing_info().IsReadyToDraw()) {
       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(sharedQuadState, geometry_rect, color);
         if (quadSink->append(quad.PassAs<DrawQuad>(), appendQuadsData))
             appendQuadsData->numMissingTiles++;
       } else {
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
         quad->SetNew(sharedQuadState, geometry_rect, background_color());
         if (quadSink->append(quad.PassAs<DrawQuad>(), appendQuadsData))
             appendQuadsData->numMissingTiles++;
       }
 
       appendQuadsData->hadIncompleteTile = true;
       continue;
     }
 
-    if (iter->contents_scale() != ideal_contents_scale_)
-      appendQuadsData->hadIncompleteTile = true;
+    const ManagedTileState::DrawingInfo& drawing_info = iter->drawing_info();
+    switch (drawing_info.mode()) {
+      case ManagedTileState::DrawingInfo::TEXTURE_MODE: {
+        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);
+        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,
-                 resource,
-                 texture_rect,
-                 iter.texture_size(),
-                 iter->contents_swizzled());
-    quadSink->append(quad.PassAs<DrawQuad>(), appendQuadsData);
+        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);
+        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
   // better scheme would be to maintain a tighter visibleContentRect for the
   // finer tilings.
   CleanUpTilingsOnActiveLayer(seen_tilings);
@@ skipping 246 matching lines @@
   gfx::Rect content_rect(content_bounds());
   float scale = contents_scale_x();
   for (PictureLayerTilingSet::Iterator iter(tilings_.get(),
                                             scale,
                                             content_rect,
                                             ideal_contents_scale_,
                                             PictureLayerTiling::LayerDeviceAlignmentUnknown);
        iter;
        ++iter) {
     // Mask resource not ready yet.
-    if (!*iter || !iter->GetResourceId())
+    if (!*iter ||
+        iter->drawing_info().mode() !=
+            ManagedTileState::DrawingInfo::TEXTURE_MODE ||
+        !iter->drawing_info().IsReadyToDraw())
       return 0;
     // Masks only supported if they fit on exactly one tile.
     if (iter.geometry_rect() != content_rect)
       return 0;
-    return iter->GetResourceId();
+    return iter->drawing_info().get_resource_id();
   }
   return 0;
 }
 
 bool PictureLayerImpl::AreVisibleResourcesReady() const {
   DCHECK(layer_tree_impl()->IsPendingTree());
   DCHECK(ideal_contents_scale_);
 
   const gfx::Rect& rect = visible_content_rect();
 
@@ skipping 23 matching lines @@
     if (tiling->contents_scale() < min_acceptable_scale)
       continue;
 
     for (PictureLayerTiling::Iterator iter(tiling,
                                            contents_scale_x(),
                                            rect,
                                            PictureLayerTiling::LayerDeviceAlignmentUnknown);
          iter;
          ++iter) {
       // A null tile (i.e. no recording) is considered "ready".
-      if (!*iter || iter->IsReadyToDraw())
+      if (!*iter || iter->drawing_info().IsReadyToDraw())
         missing_region.Subtract(iter.geometry_rect());
     }
   }
 
   return missing_region.IsEmpty();
 }
 
 PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
   DCHECK(contents_scale >= MinimumContentsScale());
 
@@ skipping 257 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