Make IsSolidColor() a property on CC scrollbar layers.

cc/layers/scrollbar_layer.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/scrollbar_layer.h"
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "cc/layers/scrollbar_layer_impl.h"
 #include "cc/resources/caching_bitmap_content_layer_updater.h"
 #include "cc/resources/layer_painter.h"
 #include "cc/resources/prioritized_resource.h"
 #include "cc/resources/resource_update_queue.h"
 #include "cc/trees/layer_tree_host.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 
 scoped_ptr<LayerImpl> ScrollbarLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return ScrollbarLayerImpl::Create(
-      tree_impl, id(), scrollbar_->Orientation()).PassAs<LayerImpl>();
+      tree_impl, id(), scrollbar_->Orientation(), is_solid_color_)
+      .PassAs<LayerImpl>();
 }
 
 scoped_refptr<ScrollbarLayer> ScrollbarLayer::Create(
     scoped_ptr<Scrollbar> scrollbar,
-    int scroll_layer_id) {
+    int scroll_layer_id,
+    bool is_solid_color) {
   return make_scoped_refptr(new ScrollbarLayer(scrollbar.Pass(),
-                                               scroll_layer_id));
+                                               scroll_layer_id,
+                                               is_solid_color));
 }
 
 ScrollbarLayer::ScrollbarLayer(
     scoped_ptr<Scrollbar> scrollbar,
-    int scroll_layer_id)
+    int scroll_layer_id,
+    bool is_solid_color)
     : scrollbar_(scrollbar.Pass()),
       scroll_layer_id_(scroll_layer_id),
+      is_solid_color_(is_solid_color),
       texture_format_(GL_INVALID_ENUM) {
   if (!scrollbar_->IsOverlay())
     SetShouldScrollOnMainThread(true);
 }
 
 ScrollbarLayer::~ScrollbarLayer() {}
 
 void ScrollbarLayer::SetScrollLayerId(int id) {
   if (id == scroll_layer_id_)
     return;
 
   scroll_layer_id_ = id;
   SetNeedsFullTreeSync();
 }
 
 bool ScrollbarLayer::OpacityCanAnimateOnImplThread() const {
   return scrollbar_->IsOverlay();
 }
 
 ScrollbarOrientation ScrollbarLayer::Orientation() const {
   return scrollbar_->Orientation();
 }
 
+bool ScrollbarLayer::IsSolidColor() const {
+  DCHECK(layer_tree_host());

[enne (OOO), 2013/06/26 17:39:05]

This seems dangerous.  cc::Layers can be detached from their host at any point.

What about having WebScrollbarLayerImpl check the command line for this force
flag and pass that to the ScrollbarLayer constructor, in the same way that we do
for making WebContentLayerImpl decide to be backed by ContentLayer vs.
PictureLayer?

[wjmaclean, 2013/06/26 18:16:00]

There isn't a command line flag for force_solid_color_scrollbars. It only exists
as a layer tree setting, meaning that the value of this could (theoretically)
differ between RenderWidgetCompositor instances.

My original design tried to get around this by retaining a distinction between
(1) the is_solid_color_ value the scrollbar was created with, and (2) the
settings of the currently attached layer_tree_host_, and or-ing them to
determine what to do.

WebScrollbarLayerImpl's default to false then unless overriden by the settings,
and ScrollbarLayers created to be pinch-inner-viewport scrollbars have this
value set at construction time.

Could we go back to that?

I'm assuming that WebScrollbarLayerImpl shouldn't know about which compositor
instance will use it until it's attached to a tree, is that right?

[enne (OOO), 2013/06/26 20:02:11]

Right now it can't differ, and is always true on Android:
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/g...

I'm not sure allowing it to differ per compositor is a feature we should
consider supporting.  I suspect moving a ScrollbarLayer between hosts with
different solid color scrollbars probably would behave quite poorly.

+  return is_solid_color_ ||
+         layer_tree_host()->settings().force_solid_color_scrollbars;
+}
+
 int ScrollbarLayer::MaxTextureSize() {
   DCHECK(layer_tree_host());
   return layer_tree_host()->GetRendererCapabilities().max_texture_size;
 }
 
 float ScrollbarLayer::ClampScaleToMaxTextureSize(float scale) {
-  if (layer_tree_host()->settings().solid_color_scrollbars)
+  if (IsSolidColor())
     return scale;
 
   // If the scaled content_bounds() is bigger than the max texture size of the
   // device, we need to clamp it by rescaling, since content_bounds() is used
   // below to set the texture size.
   gfx::Size scaled_bounds = ComputeContentBoundsForScale(scale, scale);
   if (scaled_bounds.width() > MaxTextureSize() ||
       scaled_bounds.height() > MaxTextureSize()) {
     if (scaled_bounds.width() > scaled_bounds.height())
       return (MaxTextureSize() - 1) / static_cast<float>(bounds().width());
@@ skipping 18 matching lines @@
       contents_scale_x,
       contents_scale_y,
       content_bounds);
 }
 
 void ScrollbarLayer::PushPropertiesTo(LayerImpl* layer) {
   ContentsScalingLayer::PushPropertiesTo(layer);
 
   ScrollbarLayerImpl* scrollbar_layer = static_cast<ScrollbarLayerImpl*>(layer);
 
-  if (layer_tree_host() &&
-      layer_tree_host()->settings().solid_color_scrollbars) {
+  if (layer_tree_host() && IsSolidColor()) {
     int thickness_override =
         layer_tree_host()->settings().solid_color_scrollbar_thickness_dip;
     if (thickness_override != -1) {
       scrollbar_layer->set_thumb_thickness(thickness_override);
     } else {
       if (Orientation() == HORIZONTAL)
         scrollbar_layer->set_thumb_thickness(bounds().height());
       else
         scrollbar_layer->set_thumb_thickness(bounds().width());
     }
   } else {
     scrollbar_layer->set_thumb_thickness(thumb_thickness_);
   }
   scrollbar_layer->set_thumb_length(thumb_length_);
   if (Orientation() == HORIZONTAL) {
     scrollbar_layer->set_track_start(track_rect_.x());
     scrollbar_layer->set_track_length(track_rect_.width());
   } else {
     scrollbar_layer->set_track_start(track_rect_.y());
     scrollbar_layer->set_track_length(track_rect_.height());
   }
+  scrollbar_layer->set_is_solid_color(IsSolidColor());
 
   if (track_ && track_->texture()->have_backing_texture())
     scrollbar_layer->set_track_resource_id(track_->texture()->resource_id());
   else
     scrollbar_layer->set_track_resource_id(0);
 
   if (thumb_ && thumb_->texture()->have_backing_texture())
     scrollbar_layer->set_thumb_resource_id(thumb_->texture()->resource_id());
   else
     scrollbar_layer->set_thumb_resource_id(0);
@@ skipping 27 matching lines @@
                      gfx::RectF* opaque) OVERRIDE {
     scrollbar_->PaintPart(canvas, part_, content_rect);
   }
 
  private:
   Scrollbar* scrollbar_;
   ScrollbarPart part_;
 };
 
 void ScrollbarLayer::CreateUpdaterIfNeeded() {
-  if (layer_tree_host()->settings().solid_color_scrollbars)
+  if (IsSolidColor())
     return;
 
   texture_format_ =
       layer_tree_host()->GetRendererCapabilities().best_texture_format;
 
   if (!track_updater_.get()) {
     track_updater_ = CachingBitmapContentLayerUpdater::Create(
         scoped_ptr<LayerPainter>(
             new ScrollbarPartPainter(scrollbar_.get(), TRACK))
             .Pass(),
@@ skipping 17 matching lines @@
     thumb_ = thumb_updater_->CreateResource(
         layer_tree_host()->contents_texture_manager());
   }
 }
 
 void ScrollbarLayer::UpdatePart(CachingBitmapContentLayerUpdater* painter,
                                 LayerUpdater::Resource* resource,
                                 gfx::Rect rect,
                                 ResourceUpdateQueue* queue,
                                 RenderingStats* stats) {
-  if (layer_tree_host()->settings().solid_color_scrollbars)
+  if (IsSolidColor())
     return;
 
   // Skip painting and uploading if there are no invalidations and
   // we already have valid texture data.
   if (resource->texture()->have_backing_texture() &&
       resource->texture()->size() == rect.size() &&
       !is_dirty())
     return;
 
   // We should always have enough memory for UI.
@@ skipping 34 matching lines @@
       layer_rect, contents_scale_y(), contents_scale_y());
   // We should never return a rect bigger than the content_bounds().
   gfx::Size clamped_size = expanded_rect.size();
   clamped_size.SetToMin(content_bounds());
   expanded_rect.set_size(clamped_size);
   return expanded_rect;
 }
 
 void ScrollbarLayer::SetTexturePriorities(
     const PriorityCalculator& priority_calc) {
-  if (layer_tree_host()->settings().solid_color_scrollbars)
+  if (IsSolidColor())
     return;
 
   if (content_bounds().IsEmpty())
     return;
   DCHECK_LE(content_bounds().width(), MaxTextureSize());
   DCHECK_LE(content_bounds().height(), MaxTextureSize());
 
   CreateUpdaterIfNeeded();
 
   bool draws_to_root = !render_target()->parent();
   if (track_) {
     track_->texture()->SetDimensions(content_bounds(), texture_format_);
     track_->texture()->set_request_priority(
         PriorityCalculator::UIPriority(draws_to_root));
   }
   if (thumb_) {
     gfx::Size thumb_size = OriginThumbRect().size();
     thumb_->texture()->SetDimensions(thumb_size, texture_format_);
     thumb_->texture()->set_request_priority(
         PriorityCalculator::UIPriority(draws_to_root));
   }
 }
 
 void ScrollbarLayer::Update(ResourceUpdateQueue* queue,
                             const OcclusionTracker* occlusion,
                             RenderingStats* stats) {
   track_rect_ = scrollbar_->TrackRect();
 
-  if (layer_tree_host()->settings().solid_color_scrollbars)
+  if (IsSolidColor())
     return;
 
   {
     base::AutoReset<bool> ignore_set_needs_commit(&ignore_set_needs_commit_,
                                                   true);
     ContentsScalingLayer::Update(queue, occlusion, stats);
   }
 
   dirty_rect_.Union(update_rect_);
   if (content_bounds().IsEmpty())
@@ skipping 33 matching lines @@
     thumb_size = gfx::Size(scrollbar_->ThumbLength(),
                            scrollbar_->ThumbThickness());
   } else {
     thumb_size = gfx::Size(scrollbar_->ThumbThickness(),
                            scrollbar_->ThumbLength());
   }
   return ScrollbarLayerRectToContentRect(gfx::Rect(thumb_size));
 }
 
 }  // namespace cc