Make IsSolidColor() a property on CC scrollbar layers.

cc/layers/scrollbar_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/scrollbar_layer_impl.h"
 
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/quad_sink.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 
 scoped_ptr<ScrollbarLayerImpl> ScrollbarLayerImpl::Create(
     LayerTreeImpl* tree_impl,
     int id,
-    ScrollbarOrientation orientation) {
+    ScrollbarOrientation orientation,
+    bool is_solid_color) {
   return make_scoped_ptr(new ScrollbarLayerImpl(tree_impl,
                                                 id,
-                                                orientation));
+                                                orientation,
+                                                is_solid_color));
 }
 
 ScrollbarLayerImpl::ScrollbarLayerImpl(
     LayerTreeImpl* tree_impl,
     int id,
-    ScrollbarOrientation orientation)
+    ScrollbarOrientation orientation,
+    bool is_solid_color)
     : LayerImpl(tree_impl, id),
       track_resource_id_(0),
       thumb_resource_id_(0),
       current_pos_(0.f),
       maximum_(0),
       thumb_thickness_(0),
       thumb_length_(0),
       track_start_(0),
       track_length_(0),
       orientation_(orientation),
       vertical_adjust_(0.f),
       visible_to_total_length_ratio_(1.f),
       scroll_layer_id_(Layer::INVALID_ID),
       is_scrollable_area_active_(false),
       is_scroll_view_scrollbar_(false),
       enabled_(false),
       is_custom_scrollbar_(false),
-      is_overlay_scrollbar_(false) {}
+      is_overlay_scrollbar_(false),
+      is_solid_color_(is_solid_color) {
+}
 
 ScrollbarLayerImpl::~ScrollbarLayerImpl() {}
 
 ScrollbarLayerImpl* ScrollbarLayerImpl::ToScrollbarLayer() {
   return this;
 }
 
 scoped_ptr<LayerImpl> ScrollbarLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return ScrollbarLayerImpl::Create(tree_impl,
-                                    id(),
-                                    orientation_).PassAs<LayerImpl>();
+  return ScrollbarLayerImpl::Create(
+      tree_impl, id(), orientation_, is_solid_color_).PassAs<LayerImpl>();
 }
 
 void ScrollbarLayerImpl::PushPropertiesTo(LayerImpl* layer) {
   LayerImpl::PushPropertiesTo(layer);
 
   ScrollbarLayerImpl* scrollbar_layer = static_cast<ScrollbarLayerImpl*>(layer);
 
+  scrollbar_layer->set_is_solid_color(is_solid_color_);
+
   scrollbar_layer->set_thumb_thickness(thumb_thickness_);
   scrollbar_layer->set_thumb_length(thumb_length_);
   scrollbar_layer->set_track_start(track_start_);
   scrollbar_layer->set_track_length(track_length_);
 
   scrollbar_layer->set_track_resource_id(track_resource_id_);
   scrollbar_layer->set_thumb_resource_id(thumb_resource_id_);
 }
 
 bool ScrollbarLayerImpl::WillDraw(DrawMode draw_mode,
                                   ResourceProvider* resource_provider) {
   LayerImpl::WillDraw(draw_mode, resource_provider);
   return draw_mode != DRAW_MODE_RESOURCELESS_SOFTWARE ||
-         layer_tree_impl()->settings().solid_color_scrollbars;
+         IsSolidColor();
 }
 
 void ScrollbarLayerImpl::AppendQuads(QuadSink* quad_sink,
                                      AppendQuadsData* append_quads_data) {
   bool premultipled_alpha = true;
   bool flipped = false;
   gfx::PointF uv_top_left(0.f, 0.f);
   gfx::PointF uv_bottom_right(1.f, 1.f);
   gfx::Rect bounds_rect(bounds());
   gfx::Rect content_bounds_rect(content_bounds());
 
   SharedQuadState* shared_quad_state =
       quad_sink->UseSharedQuadState(CreateSharedQuadState());
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   gfx::Rect thumb_quad_rect = ComputeThumbQuadRect();
 
-  if (layer_tree_impl()->settings().solid_color_scrollbars) {
+  if (IsSolidColor()) {
     scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
     quad->SetNew(shared_quad_state,
                  thumb_quad_rect,
                  layer_tree_impl()->settings().solid_color_scrollbar_color,
                  false);
     quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
     return;
   }
 
   if (thumb_resource_id_ && !thumb_quad_rect.IsEmpty()) {
@@ skipping 33 matching lines @@
                  opacity,
                  flipped);
     quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
   }
 }
 
 ScrollbarOrientation ScrollbarLayerImpl::Orientation() const {
   return orientation_;
 }
 
+bool ScrollbarLayerImpl::IsSolidColor() const {
+  return is_solid_color_ ||
+         (layer_tree_impl() &&

[aelias_OOO_until_Jul13, 2013/06/21 23:34:35]

DCHECK(layer_tree_impl()).  (Or you could just get rid of the branch on this
side by pushing the value of IsSolidColor() in PushPropertiesTo()).

[wjmaclean, 2013/06/24 14:06:41]

I thought about pushing it as a property, though I wasn't sure if we'd ever want
to distinguish (at some later time) between a layer that was created "solid"
from one that just picks up the property.

I'll change it so we push the value over.

+          layer_tree_impl()->settings().force_solid_color_scrollbars);
+}
+
+void ScrollbarLayerImpl::set_is_solid_color(bool is_solid_color) {
+  is_solid_color_ = is_solid_color;
+}
+
 float ScrollbarLayerImpl::CurrentPos() const {
   return current_pos_;
 }
 
 int ScrollbarLayerImpl::Maximum() const {
   return maximum_;
 }
 
 gfx::Rect ScrollbarLayerImpl::ScrollbarLayerRectToContentRect(
     gfx::RectF layer_rect) const {
@@ skipping 64 matching lines @@
   // actually see down to 1000px. Thus we have to move the quad for the
   // horizontal scrollbar down by the vertical_adjust_ factor and lay the
   // vertical thumb out on a track lengthed by the vertical_adjust_ factor. This
   // means the quads may extend outside the layer's bounds.
 
   int thumb_length = thumb_length_;
   float track_length = track_length_;
   if (orientation_ == VERTICAL)
     track_length += vertical_adjust_;
 
-  if (layer_tree_impl()->settings().solid_color_scrollbars) {
+  if (IsSolidColor()) {
     thumb_length = std::max(
         static_cast<int>(visible_to_total_length_ratio_ * track_length),
         thumb_thickness_);
   }
 
   // With the length known, we can compute the thumb's position.
   float ratio = current_pos_ / maximum_;
   float max_offset = track_length - thumb_length;
   int thumb_offset = static_cast<int>(ratio * max_offset) + track_start_;
 
@@ skipping 12 matching lines @@
 void ScrollbarLayerImpl::DidLoseOutputSurface() {
   track_resource_id_ = 0;
   thumb_resource_id_ = 0;
 }
 
 const char* ScrollbarLayerImpl::LayerTypeAsString() const {
   return "cc::ScrollbarLayerImpl";
 }
 
 }  // namespace cc