Scrollbar Layer revert

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 <algorithm>
 
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/layers/layer.h"
@@ skipping 13 matching lines @@
   return make_scoped_ptr(new ScrollbarLayerImpl(tree_impl,
                                                 id,
                                                 orientation));
 }
 
 ScrollbarLayerImpl::ScrollbarLayerImpl(
     LayerTreeImpl* tree_impl,
     int id,
     ScrollbarOrientation orientation)
     : LayerImpl(tree_impl, id),
-      track_ui_resource_id_(0),
-      thumb_ui_resource_id_(0),
+      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),
@@ skipping 16 matching lines @@
   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_is_overlay_scrollbar(is_overlay_scrollbar_);
 
-  scrollbar_layer->set_track_ui_resource_id(track_ui_resource_id_);
-  scrollbar_layer->set_thumb_ui_resource_id(thumb_ui_resource_id_);
+  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) {
   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE &&
       !layer_tree_impl()->settings().solid_color_scrollbars)
     return false;
   return LayerImpl::WillDraw(draw_mode, resource_provider);
 }
 
@@ skipping 15 matching lines @@
   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;
   }
 
-  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 && !thumb_quad_rect.IsEmpty()) {
+  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,
+                 thumb_resource_id_,
                  premultipled_alpha,
                  uv_top_left,
                  uv_bottom_right,
                  SK_ColorTRANSPARENT,
                  opacity,
                  flipped);
     quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
   }
 
-  gfx::Rect track_quad_rect = content_bounds_rect;
-  if (track_resource_id && !track_quad_rect.IsEmpty()) {
-    gfx::Rect opaque_rect(contents_opaque() ? track_quad_rect : gfx::Rect());
+  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,
-                 track_quad_rect,
+                 quad_rect,
                  opaque_rect,
-                 track_resource_id,
+                 track_resource_id_,
                  premultipled_alpha,
                  uv_top_left,
                  uv_bottom_right,
                  SK_ColorTRANSPARENT,
                  opacity,
                  flipped);
     quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
   }
 }
 
@@ skipping 103 matching lines @@
     thumb_rect = gfx::RectF(thumb_offset, vertical_adjust_,
                             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";
 }
 
 }  // namespace cc