Use the solid color detection to create solid layers

cc/layers/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/layer_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/json/json_reader.h"
 #include "base/strings/stringprintf.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/base/simple_enclosed_region.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/debug/layer_tree_debug_state.h"
 #include "cc/debug/micro_benchmark_impl.h"
 #include "cc/debug/traced_value.h"
 #include "cc/input/layer_scroll_offset_delegate.h"
 #include "cc/layers/layer_utils.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass.h"
+#include "cc/quads/solid_color_draw_quad.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/layer_tree_settings.h"
+#include "cc/trees/occlusion_tracker.h"
 #include "cc/trees/proxy.h"
 #include "ui/gfx/box_f.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
 
+namespace {
+const int kSolidQuadTileSize = 256;
+}
+
 namespace cc {
 LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
     : parent_(NULL),
       scroll_parent_(NULL),
       clip_parent_(NULL),
       mask_layer_id_(-1),
       replica_layer_id_(-1),
       layer_id_(id),
       layer_tree_impl_(tree_impl),
       scroll_offset_delegate_(NULL),
@@ skipping 247 matching lines @@
   if (masks_to_bounds_) {
     *color = DebugColors::MaskingLayerBorderColor();
     *width = DebugColors::MaskingLayerBorderWidth(layer_tree_impl());
     return;
   }
 
   *color = DebugColors::ContainerLayerBorderColor();
   *width = DebugColors::ContainerLayerBorderWidth(layer_tree_impl());
 }
 
+void LayerImpl::AppendSolidQuads(
+    RenderPass* render_pass,
+    const OcclusionTracker<LayerImpl>& occlusion_tracker,
+    AppendQuadsData* append_quads_data,
+    SkColor color) {
+  SharedQuadState* shared_quad_state =
+      render_pass->CreateAndAppendSharedQuadState();
+  PopulateSharedQuadState(shared_quad_state);
+
+  AppendDebugBorderQuad(
+      render_pass, content_bounds(), shared_quad_state, append_quads_data);
+
+  // We create a series of smaller quads instead of just one large one so that
+  // the culler can reduce the total pixels drawn.
+  int width = content_bounds().width();
+  int height = content_bounds().height();
+  for (int x = 0; x < width; x += kSolidQuadTileSize) {
+    for (int y = 0; y < height; y += kSolidQuadTileSize) {
+      gfx::Rect quad_rect(x,
+                          y,
+                          std::min(width - x, kSolidQuadTileSize),
+                          std::min(height - y, kSolidQuadTileSize));
+      gfx::Rect visible_quad_rect = occlusion_tracker.UnoccludedContentRect(
+          quad_rect, draw_properties().target_space_transform);
+      if (visible_quad_rect.IsEmpty())
+        continue;
+
+      SolidColorDrawQuad* quad =
+          render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
+      quad->SetNew(
+          shared_quad_state, quad_rect, visible_quad_rect, color, false);
+    }
+  }
+}
+
 void LayerImpl::AppendDebugBorderQuad(
     RenderPass* render_pass,
     const gfx::Size& content_bounds,
     const SharedQuadState* shared_quad_state,
     AppendQuadsData* append_quads_data) const {
   SkColor color;
   float width;
   GetDebugBorderProperties(&color, &width);
   AppendDebugBorderQuad(render_pass,
                         content_bounds,
@@ skipping 1225 matching lines @@
 }
 
 void LayerImpl::NotifyAnimationFinished(
     base::TimeTicks monotonic_time,
     Animation::TargetProperty target_property) {
   if (target_property == Animation::ScrollOffset)
     layer_tree_impl_->InputScrollAnimationFinished();
 }
 
 }  // namespace cc