UI Resource Manager

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/quads/tile_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) {
   return make_scoped_ptr(new ScrollbarLayerImpl(tree_impl,
                                                 id,
                                                 orientation));
 }
 
 ScrollbarLayerImpl::ScrollbarLayerImpl(
     LayerTreeImpl* tree_impl,
     int id,
     ScrollbarOrientation orientation)
     : 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),
+      track_ui_resource_id_(0),
+      thumb_ui_resource_id_(0),
       is_scrollable_area_active_(false),
       is_scroll_view_scrollbar_(false),
       enabled_(false),
       is_custom_scrollbar_(false),
-      is_overlay_scrollbar_(false) {}
+      is_overlay_scrollbar_(false) {
+}
 
 ScrollbarLayerImpl::~ScrollbarLayerImpl() {}
 
 ScrollbarLayerImpl* ScrollbarLayerImpl::ToScrollbarLayer() {
   return this;
 }
 
 scoped_ptr<LayerImpl> ScrollbarLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return ScrollbarLayerImpl::Create(tree_impl,
                                     id(),
                                     orientation_).PassAs<LayerImpl>();
 }
 
 void ScrollbarLayerImpl::PushPropertiesTo(LayerImpl* layer) {
   LayerImpl::PushPropertiesTo(layer);
 
   ScrollbarLayerImpl* scrollbar_layer = static_cast<ScrollbarLayerImpl*>(layer);
 
   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_);
+  if (scrollbar_layer->track_ui_resource_id_ != track_ui_resource_id_ ||
+      scrollbar_layer->thumb_ui_resource_id_ != thumb_ui_resource_id_) {
+    scrollbar_layer->set_track_ui_resource_id(track_ui_resource_id_);
+    scrollbar_layer->set_thumb_ui_resource_id(thumb_ui_resource_id_);
+
+    NoteLayerPropertyChanged();

[aelias_OOO_until_Jul13, 2013/07/10 23:07:22]

This is never called in PushPropertiesTo anywhere else so I don't think these 2
lines should be here.

[powei, 2013/07/11 23:54:44]

Done.

+    scrollbar_layer->NoteLayerPropertyChanged();
+  }
 }
 
 bool ScrollbarLayerImpl::WillDraw(DrawMode draw_mode,

[aelias_OOO_until_Jul13, 2013/07/10 23:07:22]

Please revert the unnecessary changes in this method, you're ignoring the return
value of LayerImpl::WillDraw.

[powei, 2013/07/11 23:54:44]

Done.

                                   ResourceProvider* resource_provider) {
-  if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE &&
-      !layer_tree_impl()->settings().solid_color_scrollbars)
-    return false;
-  return LayerImpl::WillDraw(draw_mode, resource_provider);
+  LayerImpl::WillDraw(draw_mode, resource_provider);
+  return draw_mode != DRAW_MODE_RESOURCELESS_SOFTWARE ||
+         layer_tree_impl()->settings().solid_color_scrollbars;
 }
 
 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) {
     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()) {
-    gfx::Rect opaque_rect;
-    const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
-    scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
-    quad->SetNew(shared_quad_state,
-                 thumb_quad_rect,
-                 opaque_rect,
-                 thumb_resource_id_,
-                 premultipled_alpha,
-                 uv_top_left,
-                 uv_bottom_right,
-                 opacity,
-                 flipped);
-    quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
+  gfx::Rect track_quad_rect = content_bounds_rect;
+
+  ResourceProvider::ResourceId thumb_resource_id =
+    layer_tree_impl()->ResourceIdForUIResource(thumb_ui_resource_id_);
+  ResourceProvider::ResourceId track_resource_id =
+    layer_tree_impl()->ResourceIdForUIResource(track_ui_resource_id_);
+
+  if (thumb_resource_id) {
+    scoped_ptr<TileDrawQuad> thumb_quad = TileDrawQuad::Create();

[aelias_OOO_until_Jul13, 2013/07/10 23:07:22]

TileDrawQuad is not the right choice here, it's only for tiled web content. 
Please switch back to TextureDrawQuad.

[powei, 2013/07/11 23:54:44]

Done.

+    thumb_quad->SetNew(shared_quad_state,
+                       thumb_quad_rect,
+                       thumb_quad_rect,
+                       thumb_resource_id,
+                       gfx::RectF(0, 0, 1, 1),
+                       gfx::Size(1, 1),
+                       false);
+    quad_sink->Append(thumb_quad.PassAs<DrawQuad>(), append_quads_data);
   }
 
-  if (!track_resource_id_)
-    return;
-
-  // Order matters here: since the back track texture is being drawn to the
-  // entire contents rect, we must append it after the thumb and fore track
-  // quads. The back track texture contains (and displays) the buttons.
-  if (!content_bounds_rect.IsEmpty()) {
-    gfx::Rect quad_rect(content_bounds_rect);
-    gfx::Rect opaque_rect(contents_opaque() ? quad_rect : gfx::Rect());
-    const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
-    scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
-    quad->SetNew(shared_quad_state,
-                 quad_rect,
-                 opaque_rect,
-                 track_resource_id_,
-                 premultipled_alpha,
-                 uv_top_left,
-                 uv_bottom_right,
-                 opacity,
-                 flipped);
-    quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
+  if (!track_quad_rect.IsEmpty() && track_resource_id) {
+    scoped_ptr<TileDrawQuad> track_quad = TileDrawQuad::Create();
+    track_quad->SetNew(shared_quad_state,
+                       track_quad_rect,
+                       track_quad_rect,
+                       track_resource_id,
+                       gfx::RectF(0, 0, 1, 1),
+                       gfx::Size(1, 1),
+                       false);
+    quad_sink->Append(track_quad.PassAs<DrawQuad>(), append_quads_data);
   }
 }
 
 ScrollbarOrientation ScrollbarLayerImpl::Orientation() const {
   return orientation_;
 }
 
 float ScrollbarLayerImpl::CurrentPos() const {
   return current_pos_;
 }
@@ skipping 95 matching lines @@
                             thumb_length, thumb_thickness_);
   } else {
     thumb_rect = gfx::RectF(0.f, thumb_offset,
                             thumb_thickness_, thumb_length);
   }
 
   return ScrollbarLayerRectToContentRect(thumb_rect);
 }
 
 void ScrollbarLayerImpl::DidLoseOutputSurface() {
-  track_resource_id_ = 0;
-  thumb_resource_id_ = 0;
 }
 
 const char* ScrollbarLayerImpl::LayerTypeAsString() const {
   return "cc::ScrollbarLayerImpl";
 }
 
+void ScrollbarLayerImpl::set_track_ui_resource_id(UIResourceId uid) {
+  track_ui_resource_id_ = uid;
+}
+
+void ScrollbarLayerImpl::set_thumb_ui_resource_id(UIResourceId uid) {
+  thumb_ui_resource_id_ = uid;
+}
+
 }  // namespace cc