cc: Consolidate the analysis_canvas operations

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(),
                                               contentsScaleX(),
                                               rect,
                                               ideal_contents_scale_,
                                               layerDeviceAlignment);
          iter;
          ++iter) {
       SkColor color;
       float width;
-      if (*iter && iter->GetResourceId()) {
-        if (iter->priority(ACTIVE_TREE).resolution == HIGH_RESOLUTION) {
+      if (*iter && iter->is_ready_to_draw()) {
+        if (iter->is_solid_color() || iter->is_transparent()) {
+          color = DebugColors::SolidColorTileBorderColor();
+          width = DebugColors::SolidColorTileBorderWidth(layerTreeImpl());
+        } else if (iter->priority(ACTIVE_TREE).resolution == HIGH_RESOLUTION) {
           color = DebugColors::HighResTileBorderColor();
           width = DebugColors::HighResTileBorderWidth(layerTreeImpl());
         } else if (iter->priority(ACTIVE_TREE).resolution == LOW_RESOLUTION) {
           color = DebugColors::LowResTileBorderColor();
           width = DebugColors::LowResTileBorderWidth(layerTreeImpl());
         } else if (iter->contents_scale() > contentsScaleX()) {
           color = DebugColors::ExtraHighResTileBorderColor();
           width = DebugColors::ExtraHighResTileBorderWidth(layerTreeImpl());
         } else {
           color = DebugColors::ExtraLowResTileBorderColor();
@@ skipping 22 matching lines @@
                                             ideal_contents_scale_,
                                             layerDeviceAlignment);
        iter;
        ++iter) {
     ResourceProvider::ResourceId resource = 0;
     if (*iter)
       resource = iter->GetResourceId();
 
     gfx::Rect geometry_rect = iter.geometry_rect();
 
+    if (*iter && iter->is_solid_color()) {

[reveman, 2013/02/28 18:54:55]

I think it might be cleaner to move all this into a "if (*iter)" scope rather
than checking (*iter) multiple times. and you can merge it with the "if (*iter)
resource =..." above.

+      scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+      quad->SetNew(sharedQuadState,
+                   geometry_rect,
+                   iter->get_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 && iter->is_transparent()) {

[reveman, 2013/02/28 18:54:55]

is the "else if" needed? I think it'd be cleaner without if not needed.

+      continue;
+    } 
     if (!resource) {
       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();
@@ skipping 343 matching lines @@
     if (tiling->contents_scale() < min_acceptable_scale)
       continue;
 
     for (PictureLayerTiling::Iterator iter(tiling,
                                            contentsScaleX(),
                                            rect,
                                            PictureLayerTiling::LayerDeviceAlignmentUnknown);
          iter;
          ++iter) {
       // A null tile (i.e. no recording) is considered "ready".
-      if (!*iter || iter->GetResourceId())
+      if (!*iter || iter->is_ready_to_draw())
         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