Use the solid color detection to create solid layers

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 <limits>
 #include <set>
 
@@ skipping 57 matching lines @@
       ideal_source_scale_(0.f),
       ideal_contents_scale_(0.f),
       raster_page_scale_(0.f),
       raster_device_scale_(0.f),
       raster_source_scale_(0.f),
       raster_contents_scale_(0.f),
       low_res_raster_contents_scale_(0.f),
       raster_source_scale_is_fixed_(false),
       was_screen_space_transform_animating_(false),
       needs_post_commit_initialization_(true),
-      should_update_tile_priorities_(false) {
+      should_update_tile_priorities_(false),
+      is_solid_color_(false),
+      solid_color_(SK_ColorBLACK) {
   layer_tree_impl()->RegisterPictureLayerImpl(this);
 }
 
 PictureLayerImpl::~PictureLayerImpl() {
   layer_tree_impl()->UnregisterPictureLayerImpl(this);
 }
 
 const char* PictureLayerImpl::LayerTypeAsString() const {
   return "cc::PictureLayerImpl";
 }
 
 scoped_ptr<LayerImpl> PictureLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return PictureLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void PictureLayerImpl::PushPropertiesTo(LayerImpl* base_layer) {
   // It's possible this layer was never drawn or updated (e.g. because it was
   // a descendant of an opacity 0 layer).
   DoPostCommitInitializationIfNeeded();
+
   PictureLayerImpl* layer_impl = static_cast<PictureLayerImpl*>(base_layer);
 
   // We have already synced the important bits from the the active layer, and
   // we will soon swap out its tilings and use them for recycling. However,
   // there are now tiles in this layer's tilings that were unref'd and replaced
   // with new tiles (due to invalidation). This resets all active priorities on
   // the to-be-recycled tiling to ensure replaced tiles don't linger and take
   // memory (due to a stale 'active' priority).
   if (layer_impl->tilings_)
     layer_impl->tilings_->DidBecomeRecycled();
 
   LayerImpl::PushPropertiesTo(base_layer);
 
   // When the pending tree pushes to the active tree, the pending twin
   // becomes recycled.
   layer_impl->twin_layer_ = NULL;
   twin_layer_ = NULL;
 
   layer_impl->SetIsMask(is_mask_);
   layer_impl->pile_ = pile_;
 
+  DCHECK(!IsSolidColor() || !tilings_->num_tilings());
+  layer_impl->is_solid_color_ = is_solid_color_;
+  layer_impl->solid_color_ = solid_color_;
+
   // Tilings would be expensive to push, so we swap.
   layer_impl->tilings_.swap(tilings_);
 
   // Remove invalidated tiles from what will become a recycle tree.
   if (tilings_)
     tilings_->RemoveTilesInRegion(invalidation_);
 
   layer_impl->tilings_->SetClient(layer_impl);
   if (tilings_)
     tilings_->SetClient(this);
@@ skipping 14 matching lines @@
 
   // We always need to push properties.
   // See http://crbug.com/303943
   needs_push_properties_ = true;
 }
 
 void PictureLayerImpl::AppendQuads(
     RenderPass* render_pass,
     const OcclusionTracker<LayerImpl>& occlusion_tracker,
     AppendQuadsData* append_quads_data) {
+  if (IsSolidColor()) {
+    AppendSolidQuads(
+        render_pass, occlusion_tracker, append_quads_data, solid_color_);
+    return;
+  }
+
   DCHECK(!needs_post_commit_initialization_);
 
   float max_contents_scale = MaximumTilingContentsScale();
   gfx::Transform scaled_draw_transform = draw_transform();
   scaled_draw_transform.Scale(SK_MScalar1 / max_contents_scale,
                               SK_MScalar1 / max_contents_scale);
   gfx::Size scaled_content_bounds =
       gfx::ToCeiledSize(gfx::ScaleSize(content_bounds(), max_contents_scale));
 
   gfx::Rect scaled_visible_content_rect =
@@ skipping 413 matching lines @@
   // to force tilings to get managed.
   layer_tree_impl()->set_needs_update_draw_properties();
 }
 
 skia::RefPtr<SkPicture> PictureLayerImpl::GetPicture() {
   return pile_->GetFlattenedPicture();
 }
 
 scoped_refptr<Tile> PictureLayerImpl::CreateTile(PictureLayerTiling* tiling,
                                                const gfx::Rect& content_rect) {
+  DCHECK(!IsSolidColor());
   if (!pile_->CanRaster(tiling->contents_scale(), content_rect))
     return scoped_refptr<Tile>();
 
   // TODO(vmpstr): Revisit this. For now, enabling analysis means that we get as
   // much savings on memory as we can. However, for some cases like ganesh or
   // small layers, the amount of time we spend analyzing might not justify
   // memory savings that we can get.
   // Bugs: crbug.com/397198, crbug.com/396908
   int flags = Tile::USE_PICTURE_ANALYSIS;
 
@@ skipping 713 matching lines @@
   raster_contents_scale_ = 0.f;
   low_res_raster_contents_scale_ = 0.f;
   raster_source_scale_is_fixed_ = false;
 
   // When raster scales aren't valid, don't update tile priorities until
   // this layer has been updated via UpdateDrawProperties.
   should_update_tile_priorities_ = false;
 }
 
 bool PictureLayerImpl::CanHaveTilings() const {
+  if (IsSolidColor())
+    return false;
   if (!DrawsContent())
     return false;
   if (!pile_->HasRecordings())
     return false;
   return true;
 }
 
 bool PictureLayerImpl::CanHaveTilingWithScale(float contents_scale) const {
   if (!CanHaveTilings())
     return false;
@@ skipping 443 matching lines @@
     case PictureLayerTilingSet::LOWER_THAN_LOW_RES: {
       PictureLayerTilingSet::TilingRange tiling_range = CurrentTilingRange();
       size_t current_tiling_range_offset = current_tiling_ - tiling_range.start;
       return tiling_range.end - 1 - current_tiling_range_offset;
     }
   }
   NOTREACHED();
   return 0;
 }
 
+void PictureLayerImpl::SetSolidColorState(bool is_solid_color,
+                                          SkColor solid_color) {
+  is_solid_color_ = is_solid_color;
+  solid_color_ = solid_color;
+}
+
 }  // namespace cc