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_;
 
+  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);

[vmpstr, 2014/08/29 06:49:15]

If you push solid color == true, it shouldn't have tilings. Or do you always
create tilings? I think solid color shouldn't have a tiling set at all

[hendrikw, 2014/08/29 14:03:21]

We always create tilings_, but it's empty, so it shouldn't do any work.  we're
already doing this for the tens of empty layers we for some reason think we need
to create.

Any attempt I've made to avoid the tilings leaves us in a bad state.

If you like, I can continue to try to avoid creating the tilings, but this
change will become much more invasive.

[vmpstr, 2014/08/29 14:20:44]

No, I guess not having tilings but having a tiling set is fine. I would then ask
to put a few DCHECKs here and there along the lines of

DCHECK(!IsSolidColor() || !tilings_->num_tilings());

[hendrikw, 2014/09/02 14:19:17]

Acknowledged.

   if (tilings_)
     tilings_->SetClient(this);
 
   layer_impl->raster_page_scale_ = raster_page_scale_;
   layer_impl->raster_device_scale_ = raster_device_scale_;
   layer_impl->raster_source_scale_ = raster_source_scale_;
   layer_impl->raster_contents_scale_ = raster_contents_scale_;
   layer_impl->low_res_raster_contents_scale_ = low_res_raster_contents_scale_;
   layer_impl->needs_post_commit_initialization_ = false;
 
   // The invalidation on this soon-to-be-recycled layer must be cleared to
   // mirror clearing the invalidation in PictureLayer's version of this function
   // in case push properties is skipped.
   layer_impl->invalidation_.Swap(&invalidation_);
   invalidation_.Clear();
   needs_post_commit_initialization_ = true;
 
   // 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()) {

[vmpstr, 2014/08/29 06:49:15]

Can you put this code in a helper and do

if (IsSolidColor()) {
  AppendQuadsForSolidColor(...);
  return;
}

[hendrikw, 2014/08/29 14:03:21]

As I mentioned in the post above, I will need to derive PictureLayerImpl from
SolidColorLayer and share that functionality completely.  I didn't have time to
complete this, I wanted to get this cl out quickly since I'm technically on
vacation now.

[vmpstr, 2014/08/29 14:20:45]

Can you have a SolidColorLayerImpl as a member instead? It feels weird deriving
from it.

[enne (OOO), 2014/08/29 16:53:43]

Please, no to either deriving from PictureLayerImpl or having a
SolidColorLayerImpl as a member.

What about making some SolidColorQuadGenerator class that both of them could
use?  It could even just have no members and only static functions that you have
to pass the right things into.

[hendrikw, 2014/09/02 14:19:17]

I already tried that.  It calls AppendDebugBorderQuad, which is a protected
function of LayerImpl.

I can think of several ways around this -- this last one has a helper function
in layerimpl

[vmpstr, 2014/09/02 19:02:25]

I feel that LayerImpl should really move more towards being an interface type of
thing. In that spirit, I think putting more functionality there that is kind of
specific to a couple of implementations is moving in the other direction. 

Feel free to disagree, but I would vote for trying to make a separate helper
class for PictureLayerImpl and SolidColorLayerImpl instead of using LayerImpl
for that purpose.

+    // TODO(hendrikw) code sharing
+    const int tile_size_ = 256;  // this comes from solidcolorlayerimpl

[vmpstr, 2014/08/29 06:49:15]

trailing _ is for member variables. This should be const int kSolidColorTileSize
in the anonymous namespace

[hendrikw, 2014/08/29 14:03:21]

This will go away when I derive from solid color.

[vmpstr, 2014/08/29 14:20:44]

Acknowledged.

+    SharedQuadState* shared_quad_state =
+        render_pass->CreateAndAppendSharedQuadState();
+    PopulateSharedQuadState(shared_quad_state);
+
+    AppendDebugBorderQuad(

[vmpstr, 2014/08/29 06:49:15]

Should each of the solid color quads also have a debug border quad of some other
color?

[hendrikw, 2014/08/29 14:03:21]

This functionality will exist in solid color when I'm done, I don't plan on
changing it, in fact, all of this code should be rewritten, we're not batching
the quads. I'm not convinced that it makes sense to check occlusions and output
rects (on hardware), we probably should just output one rect, but this is out of
scope for this change.

[vmpstr, 2014/08/29 14:20:44]

Acknowledged.

+        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

[enne (OOO), 2014/08/29 16:53:43]

This code is not your fault, but we shouldn't do this anymore.  Occlusion used
to be outside the layer at the quad level and so the solid color layer had to be
split up into small enough quads that some of them could be occluded.

You can now ask the occlusion tracker for the occlusion rect directly, and so
it'd be better to generate the minimal set of rects from that.  Each quad is a
needless draw call, so it'd be better to not have to do this splitting.

If you want to punt to another patch, that's fine, but it'd be a good followup.

[hendrikw, 2014/09/02 14:19:17]

Acknowledged.

+    // 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 += tile_size_) {
+      for (int y = 0; y < height; y += tile_size_) {
+        gfx::Rect quad_rect(x,
+                            y,
+                            std::min(width - x, tile_size_),
+                            std::min(height - y, tile_size_));
+        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,
+                     solid_color_,
+                     false);
+      }
+    }
+    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) {
-  if (!pile_->CanRaster(tiling->contents_scale(), content_rect))
+  if (!pile_->CanRaster(tiling->contents_scale(), content_rect) ||

[vmpstr, 2014/08/29 06:49:15]

Hmm, I was hoping to avoid creating tilings at all for this, since things like
tile priorities updates and whatever else have non-zero cost that is unneeded
for solid color. Is that possible?

[hendrikw, 2014/08/29 14:03:21]

If there are no tiles in the tiling, why would updating tile priorities do
anything?

[vmpstr, 2014/08/29 14:20:45]

If we don't create tilings, then this function should never be called. So you
should DCHECK(!IsSolidColor()) instead then.

+      IsSolidColor())
     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;
 
   return layer_tree_impl()->tile_manager()->CreateTile(
@@ skipping 1175 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