Update chromium to branch 1599.

Change-Id: I04e775a946a208bb4500d3b722bcb05c82b9d7cb
Reviewed-by: Andras Becsi <andras.becsi@digia.com>

9 files changed, 297 insertions, 211 deletions

diff --git a/chromium/cc/layers/delegated_renderer_layer_impl_unittest.cc b/chromium/cc/layers/delegated_renderer_layer_impl_unittest.cc
index 2537c53053b..1584782f109 100644
--- a/chromium/cc/layers/delegated_renderer_layer_impl_unittest.cc
+++ b/chromium/cc/layers/delegated_renderer_layer_impl_unittest.cc
@@ -5,7 +5,6 @@
 #include "cc/layers/delegated_renderer_layer_impl.h"
 
 #include "cc/base/scoped_ptr_vector.h"
-#include "cc/debug/test_web_graphics_context_3d.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/quad_sink.h"
 #include "cc/layers/solid_color_layer_impl.h"
@@ -21,6 +20,7 @@
 #include "cc/test/mock_quad_culler.h"
 #include "cc/test/render_pass_test_common.h"
 #include "cc/test/render_pass_test_utils.h"
+#include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
diff --git a/chromium/cc/layers/picture_layer_impl.cc b/chromium/cc/layers/picture_layer_impl.cc
index 4f6052f04fa..2f1878bc3a6 100644
--- a/chromium/cc/layers/picture_layer_impl.cc
+++ b/chromium/cc/layers/picture_layer_impl.cc
@@ -617,24 +617,27 @@ void PictureLayerImpl::SetIsMask(bool is_mask) {
 ResourceProvider::ResourceId PictureLayerImpl::ContentsResourceId() const {
   gfx::Rect content_rect(content_bounds());
   float scale = contents_scale_x();
-  PictureLayerTilingSet::CoverageIterator iter(
-      tilings_.get(), scale, content_rect, ideal_contents_scale_);
-
-  // Mask resource not ready yet.
-  if (!iter || !*iter)
-    return 0;
+  for (PictureLayerTilingSet::CoverageIterator
+           iter(tilings_.get(), scale, content_rect, ideal_contents_scale_);
+       iter;
+       ++iter) {
+    // Mask resource not ready yet.
+    if (!*iter)
+      return 0;
 
-  // Masks only supported if they fit on exactly one tile.
-  if (iter.geometry_rect() != content_rect)
-    return 0;
+    const ManagedTileState::TileVersion& tile_version =
+        iter->GetTileVersionForDrawing();
+    if (!tile_version.IsReadyToDraw() ||
+        tile_version.mode() != ManagedTileState::TileVersion::RESOURCE_MODE)
+      return 0;
 
-  const ManagedTileState::TileVersion& tile_version =
-      iter->GetTileVersionForDrawing();
-  if (!tile_version.IsReadyToDraw() ||
-      tile_version.mode() != ManagedTileState::TileVersion::RESOURCE_MODE)
-    return 0;
+    // Masks only supported if they fit on exactly one tile.
+    if (iter.geometry_rect() != content_rect)
+      return 0;
 
-  return tile_version.get_resource_id();
+    return tile_version.get_resource_id();
+  }
+  return 0;
 }
 
 void PictureLayerImpl::MarkVisibleResourcesAsRequired() const {
diff --git a/chromium/cc/layers/scrollbar_layer.cc b/chromium/cc/layers/scrollbar_layer.cc
index a2fdd58ee36..95eb6384732 100644
--- a/chromium/cc/layers/scrollbar_layer.cc
+++ b/chromium/cc/layers/scrollbar_layer.cc
@@ -1,3 +1,4 @@
+
 // 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.
@@ -8,15 +9,12 @@
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "cc/layers/scrollbar_layer_impl.h"
-#include "cc/resources/ui_resource_bitmap.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 "cc/trees/layer_tree_impl.h"
-#include "skia/ext/platform_canvas.h"
-#include "skia/ext/refptr.h"
-#include "third_party/skia/include/core/SkBitmap.h"
-#include "third_party/skia/include/core/SkCanvas.h"
-#include "third_party/skia/include/core/SkSize.h"
-#include "ui/gfx/skia_util.h"
+#include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 
@@ -29,15 +27,16 @@ scoped_ptr<LayerImpl> ScrollbarLayer::CreateLayerImpl(
 scoped_refptr<ScrollbarLayer> ScrollbarLayer::Create(
     scoped_ptr<Scrollbar> scrollbar,
     int scroll_layer_id) {
-  return make_scoped_refptr(
-      new ScrollbarLayer(scrollbar.Pass(), scroll_layer_id));
+  return make_scoped_refptr(new ScrollbarLayer(scrollbar.Pass(),
+                                               scroll_layer_id));
 }
 
 ScrollbarLayer::ScrollbarLayer(
     scoped_ptr<Scrollbar> scrollbar,
     int scroll_layer_id)
     : scrollbar_(scrollbar.Pass()),
-      scroll_layer_id_(scroll_layer_id) {
+      scroll_layer_id_(scroll_layer_id),
+      texture_format_(GL_INVALID_ENUM) {
   if (!scrollbar_->IsOverlay())
     SetShouldScrollOnMainThread(true);
 }
@@ -122,17 +121,22 @@ void ScrollbarLayer::PushPropertiesTo(LayerImpl* layer) {
   }
   scrollbar_layer->SetThumbLength(thumb_length_);
   if (Orientation() == HORIZONTAL) {
-    scrollbar_layer->SetTrackStart(track_rect_.x());
+    scrollbar_layer->SetTrackStart(track_rect_.x() - location_.x());
     scrollbar_layer->SetTrackLength(track_rect_.width());
   } else {
-    scrollbar_layer->SetTrackStart(track_rect_.y());
+    scrollbar_layer->SetTrackStart(track_rect_.y() - location_.y());
     scrollbar_layer->SetTrackLength(track_rect_.height());
   }
 
-  if (track_resource_.get())
-    scrollbar_layer->set_track_ui_resource_id(track_resource_->id());
-  if (thumb_resource_.get())
-    scrollbar_layer->set_thumb_ui_resource_id(thumb_resource_->id());
+  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);
 
   scrollbar_layer->set_is_overlay_scrollbar(scrollbar_->IsOverlay());
 
@@ -145,16 +149,113 @@ ScrollbarLayer* ScrollbarLayer::ToScrollbarLayer() {
 }
 
 void ScrollbarLayer::SetLayerTreeHost(LayerTreeHost* host) {
-  // When the LTH is set to null or has changed, then this layer should remove
-  // all of its associated resources.
   if (!host || host != layer_tree_host()) {
-    track_resource_.reset();
-    thumb_resource_.reset();
+    track_updater_ = NULL;
+    track_.reset();
+    thumb_updater_ = NULL;
+    thumb_.reset();
   }
 
   ContentsScalingLayer::SetLayerTreeHost(host);
 }
 
+class ScrollbarPartPainter : public LayerPainter {
+ public:
+  ScrollbarPartPainter(Scrollbar* scrollbar, ScrollbarPart part)
+      : scrollbar_(scrollbar),
+        part_(part) {}
+  virtual ~ScrollbarPartPainter() {}
+
+  // LayerPainter implementation
+  virtual void Paint(SkCanvas* canvas,
+                     gfx::Rect content_rect,
+                     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)
+    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(),
+        rendering_stats_instrumentation(),
+        id());
+  }
+  if (!track_) {
+    track_ = track_updater_->CreateResource(
+        layer_tree_host()->contents_texture_manager());
+  }
+
+  if (!thumb_updater_.get()) {
+    thumb_updater_ = CachingBitmapContentLayerUpdater::Create(
+        scoped_ptr<LayerPainter>(
+            new ScrollbarPartPainter(scrollbar_.get(), THUMB))
+            .Pass(),
+        rendering_stats_instrumentation(),
+        id());
+  }
+  if (!thumb_ && scrollbar_->HasThumb()) {
+    thumb_ = thumb_updater_->CreateResource(
+        layer_tree_host()->contents_texture_manager());
+  }
+}
+
+bool ScrollbarLayer::UpdatePart(CachingBitmapContentLayerUpdater* painter,
+                                LayerUpdater::Resource* resource,
+                                gfx::Rect rect,
+                                ResourceUpdateQueue* queue) {
+  if (layer_tree_host()->settings().solid_color_scrollbars)
+    return false;
+
+  // 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 false;
+
+  // We should always have enough memory for UI.
+  DCHECK(resource->texture()->can_acquire_backing_texture());
+  if (!resource->texture()->can_acquire_backing_texture())
+    return false;
+
+  // Paint and upload the entire part.
+  gfx::Rect painted_opaque_rect;
+  painter->PrepareToUpdate(rect,
+                           rect.size(),
+                           contents_scale_x(),
+                           contents_scale_y(),
+                           &painted_opaque_rect);
+  if (!painter->pixels_did_change() &&
+      resource->texture()->have_backing_texture()) {
+    TRACE_EVENT_INSTANT0("cc",
+                         "ScrollbarLayer::UpdatePart no texture upload needed",
+                         TRACE_EVENT_SCOPE_THREAD);
+    return false;
+  }
+
+  bool partial_updates_allowed =
+      layer_tree_host()->settings().max_partial_texture_updates > 0;
+  if (!partial_updates_allowed)
+    resource->texture()->ReturnBackingTexture();
+
+  gfx::Vector2d dest_offset(0, 0);
+  resource->Update(queue, rect, dest_offset, partial_updates_allowed);
+  return true;
+}
+
 gfx::Rect ScrollbarLayer::ScrollbarLayerRectToContentRect(
     gfx::Rect layer_rect) const {
   // Don't intersect with the bounds as in LayerRectToContentRect() because
@@ -168,80 +269,85 @@ gfx::Rect ScrollbarLayer::ScrollbarLayerRectToContentRect(
   return expanded_rect;
 }
 
-gfx::Rect ScrollbarLayer::OriginThumbRect() const {
-  gfx::Size thumb_size;
-  if (Orientation() == HORIZONTAL) {
-    thumb_size =
-        gfx::Size(scrollbar_->ThumbLength(), scrollbar_->ThumbThickness());
-  } else {
-    thumb_size =
-        gfx::Size(scrollbar_->ThumbThickness(), scrollbar_->ThumbLength());
+void ScrollbarLayer::SetTexturePriorities(
+    const PriorityCalculator& priority_calc) {
+  if (layer_tree_host()->settings().solid_color_scrollbars)
+    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));
   }
-  return ScrollbarLayerRectToContentRect(gfx::Rect(thumb_size));
 }
 
 bool ScrollbarLayer::Update(ResourceUpdateQueue* queue,
                             const OcclusionTracker* occlusion) {
   track_rect_ = scrollbar_->TrackRect();
-  gfx::Rect scaled_track_rect = ScrollbarLayerRectToContentRect(
-      gfx::Rect(scrollbar_->Location(), bounds()));
+  location_ = scrollbar_->Location();
 
-  if (layer_tree_host()->settings().solid_color_scrollbars ||
-      track_rect_.IsEmpty() || scaled_track_rect.IsEmpty())
+  if (layer_tree_host()->settings().solid_color_scrollbars)
     return false;
 
+  bool updated = false;
+
   {
     base::AutoReset<bool> ignore_set_needs_commit(&ignore_set_needs_commit_,
                                                   true);
-    ContentsScalingLayer::Update(queue, occlusion);
+    updated = ContentsScalingLayer::Update(queue, occlusion);
   }
 
-  track_resource_ = ScopedUIResource::Create(
-      layer_tree_host(), RasterizeScrollbarPart(scaled_track_rect, TRACK));
-  gfx::Rect thumb_rect = OriginThumbRect();
+  dirty_rect_.Union(update_rect_);
+  if (content_bounds().IsEmpty())
+    return false;
+  if (visible_content_rect().IsEmpty())
+    return false;
+
+  CreateUpdaterIfNeeded();
 
-  if (scrollbar_->HasThumb() && !thumb_rect.IsEmpty()) {
+  gfx::Rect content_rect = ScrollbarLayerRectToContentRect(
+      gfx::Rect(scrollbar_->Location(), bounds()));
+  updated |= UpdatePart(track_updater_.get(), track_.get(), content_rect,
+                        queue);
+
+  if (scrollbar_->HasThumb()) {
     thumb_thickness_ = scrollbar_->ThumbThickness();
     thumb_length_ = scrollbar_->ThumbLength();
-    thumb_resource_ = ScopedUIResource::Create(
-        layer_tree_host(), RasterizeScrollbarPart(thumb_rect, THUMB));
+    gfx::Rect origin_thumb_rect = OriginThumbRect();
+    if (!origin_thumb_rect.IsEmpty()) {
+      updated |= UpdatePart(thumb_updater_.get(), thumb_.get(),
+                            origin_thumb_rect, queue);
+    }
   }
 
-  return true;
+  dirty_rect_ = gfx::RectF();
+  return updated;
 }
 
-scoped_refptr<UIResourceBitmap> ScrollbarLayer::RasterizeScrollbarPart(
-    gfx::Rect rect,
-    ScrollbarPart part) {
-  DCHECK(!layer_tree_host()->settings().solid_color_scrollbars);
-  DCHECK(!rect.size().IsEmpty());
-
-  scoped_refptr<UIResourceBitmap> bitmap =
-      UIResourceBitmap::Create(new uint8_t[rect.width() * rect.height() * 4],
-                               UIResourceBitmap::RGBA8,
-                               rect.size());
-
-  SkBitmap skbitmap;
-  skbitmap.setConfig(SkBitmap::kARGB_8888_Config, rect.width(), rect.height());
-  skbitmap.setPixels(bitmap->GetPixels());
-
-  SkCanvas skcanvas(skbitmap);
-  skcanvas.translate(SkFloatToScalar(-rect.x()), SkFloatToScalar(-rect.y()));
-  skcanvas.scale(SkFloatToScalar(contents_scale_x()),
-                 SkFloatToScalar(contents_scale_y()));
-
-  gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
-      rect, 1.f / contents_scale_x(), 1.f / contents_scale_y());
-  SkRect layer_skrect = RectToSkRect(layer_rect);
-  SkPaint paint;
-  paint.setAntiAlias(false);
-  paint.setXfermodeMode(SkXfermode::kClear_Mode);
-  skcanvas.drawRect(layer_skrect, paint);
-  skcanvas.clipRect(layer_skrect);
-
-  scrollbar_->PaintPart(&skcanvas, part, layer_rect);
-
-  return bitmap;
+gfx::Rect ScrollbarLayer::OriginThumbRect() const {
+  gfx::Size thumb_size;
+  if (Orientation() == HORIZONTAL) {
+    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
diff --git a/chromium/cc/layers/scrollbar_layer.h b/chromium/cc/layers/scrollbar_layer.h
index a162a7f00f5..6d0e58f7a4e 100644
--- a/chromium/cc/layers/scrollbar_layer.h
+++ b/chromium/cc/layers/scrollbar_layer.h
@@ -10,9 +10,10 @@
 #include "cc/layers/contents_scaling_layer.h"
 #include "cc/layers/scrollbar_theme_painter.h"
 #include "cc/resources/layer_updater.h"
-#include "cc/resources/scoped_ui_resource.h"
 
 namespace cc {
+class CachingBitmapContentLayerUpdater;
+class ResourceUpdateQueue;
 class ScrollbarThemeComposite;
 
 class CC_EXPORT ScrollbarLayer : public ContentsScalingLayer {
@@ -32,6 +33,8 @@ class CC_EXPORT ScrollbarLayer : public ContentsScalingLayer {
   ScrollbarOrientation Orientation() const;
 
   // Layer interface
+  virtual void SetTexturePriorities(const PriorityCalculator& priority_calc)
+      OVERRIDE;
   virtual bool Update(ResourceUpdateQueue* queue,
                       const OcclusionTracker* occlusion) OVERRIDE;
   virtual void SetLayerTreeHost(LayerTreeHost* host) OVERRIDE;
@@ -47,36 +50,42 @@ class CC_EXPORT ScrollbarLayer : public ContentsScalingLayer {
   virtual ScrollbarLayer* ToScrollbarLayer() OVERRIDE;
 
  protected:
-  ScrollbarLayer(scoped_ptr<Scrollbar> scrollbar, int scroll_layer_id);
+  ScrollbarLayer(scoped_ptr<Scrollbar> scrollbar,
+                 int scroll_layer_id);
   virtual ~ScrollbarLayer();
 
-  // For unit tests
-  UIResourceId track_resource_id() {
-    return track_resource_.get() ? track_resource_->id() : 0;
-  }
-  UIResourceId thumb_resource_id() {
-    return thumb_resource_.get() ? thumb_resource_->id() : 0;
-  }
-
  private:
+  bool UpdatePart(CachingBitmapContentLayerUpdater* painter,
+                  LayerUpdater::Resource* resource,
+                  gfx::Rect rect,
+                  ResourceUpdateQueue* queue);
+  void CreateUpdaterIfNeeded();
   gfx::Rect ScrollbarLayerRectToContentRect(gfx::Rect layer_rect) const;
   gfx::Rect OriginThumbRect() const;
 
+  bool is_dirty() const { return !dirty_rect_.IsEmpty(); }
+
   int MaxTextureSize();
   float ClampScaleToMaxTextureSize(float scale);
 
-  scoped_refptr<UIResourceBitmap> RasterizeScrollbarPart(gfx::Rect rect,
-                                                         ScrollbarPart part);
-
   scoped_ptr<Scrollbar> scrollbar_;
 
   int thumb_thickness_;
   int thumb_length_;
   gfx::Rect track_rect_;
+  gfx::Point location_;
   int scroll_layer_id_;
 
-  scoped_ptr<ScopedUIResource> track_resource_;
-  scoped_ptr<ScopedUIResource> thumb_resource_;
+  unsigned texture_format_;
+
+  gfx::RectF dirty_rect_;
+
+  scoped_refptr<CachingBitmapContentLayerUpdater> track_updater_;
+  scoped_refptr<CachingBitmapContentLayerUpdater> thumb_updater_;
+
+  // All the parts of the scrollbar except the thumb
+  scoped_ptr<LayerUpdater::Resource> track_;
+  scoped_ptr<LayerUpdater::Resource> thumb_;
 
   DISALLOW_COPY_AND_ASSIGN(ScrollbarLayer);
 };
diff --git a/chromium/cc/layers/scrollbar_layer_impl.cc b/chromium/cc/layers/scrollbar_layer_impl.cc
index c326d42ff24..1de185a77dd 100644
--- a/chromium/cc/layers/scrollbar_layer_impl.cc
+++ b/chromium/cc/layers/scrollbar_layer_impl.cc
@@ -31,8 +31,8 @@ ScrollbarLayerImpl::ScrollbarLayerImpl(
     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),
@@ -69,8 +69,8 @@ void ScrollbarLayerImpl::PushPropertiesTo(LayerImpl* layer) {
   scrollbar_layer->SetTrackLength(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,
@@ -106,19 +106,14 @@ void ScrollbarLayerImpl::AppendQuads(QuadSink* quad_sink,
     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,
@@ -128,15 +123,21 @@ void ScrollbarLayerImpl::AppendQuads(QuadSink* quad_sink,
     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,
@@ -315,6 +316,11 @@ gfx::Rect ScrollbarLayerImpl::ComputeThumbQuadRect() const {
   return ScrollbarLayerRectToContentRect(thumb_rect);
 }
 
+void ScrollbarLayerImpl::DidLoseOutputSurface() {
+  track_resource_id_ = 0;
+  thumb_resource_id_ = 0;
+}
+
 const char* ScrollbarLayerImpl::LayerTypeAsString() const {
   return "cc::ScrollbarLayerImpl";
 }
diff --git a/chromium/cc/layers/scrollbar_layer_impl.h b/chromium/cc/layers/scrollbar_layer_impl.h
index 86bf25558a0..6347c413dfc 100644
--- a/chromium/cc/layers/scrollbar_layer_impl.h
+++ b/chromium/cc/layers/scrollbar_layer_impl.h
@@ -8,7 +8,6 @@
 #include "cc/base/cc_export.h"
 #include "cc/input/scrollbar.h"
 #include "cc/layers/layer_impl.h"
-#include "cc/resources/ui_resource_client.h"
 
 namespace cc {
 
@@ -34,6 +33,8 @@ class CC_EXPORT ScrollbarLayerImpl : public LayerImpl {
   virtual void AppendQuads(QuadSink* quad_sink,
                            AppendQuadsData* append_quads_data) OVERRIDE;
 
+  virtual void DidLoseOutputSurface() OVERRIDE;
+
   int scroll_layer_id() const { return scroll_layer_id_; }
   void set_scroll_layer_id(int id) { scroll_layer_id_ = id; }
 
@@ -47,11 +48,11 @@ class CC_EXPORT ScrollbarLayerImpl : public LayerImpl {
   void SetTrackStart(int track_start);
   void SetTrackLength(int track_length);
   void SetVerticalAdjust(float vertical_adjust);
-  void set_track_ui_resource_id(UIResourceId uid) {
-    track_ui_resource_id_ = uid;
+  void set_track_resource_id(ResourceProvider::ResourceId id) {
+    track_resource_id_ = id;
   }
-  void set_thumb_ui_resource_id(UIResourceId uid) {
-    thumb_ui_resource_id_ = uid;
+  void set_thumb_resource_id(ResourceProvider::ResourceId id) {
+    thumb_resource_id_ = id;
   }
   void SetVisibleToTotalLengthRatio(float ratio);
   void set_is_overlay_scrollbar(bool is_overlay_scrollbar) {
@@ -74,8 +75,8 @@ class CC_EXPORT ScrollbarLayerImpl : public LayerImpl {
 
   gfx::Rect ScrollbarLayerRectToContentRect(gfx::RectF layer_rect) const;
 
-  UIResourceId track_ui_resource_id_;
-  UIResourceId thumb_ui_resource_id_;
+  ResourceProvider::ResourceId track_resource_id_;
+  ResourceProvider::ResourceId thumb_resource_id_;
 
   float current_pos_;
   int maximum_;
diff --git a/chromium/cc/layers/scrollbar_layer_unittest.cc b/chromium/cc/layers/scrollbar_layer_unittest.cc
index 79cfbb1f26d..b7981041f09 100644
--- a/chromium/cc/layers/scrollbar_layer_unittest.cc
+++ b/chromium/cc/layers/scrollbar_layer_unittest.cc
@@ -4,23 +4,22 @@
 
 #include "cc/layers/scrollbar_layer.h"
 
-#include "base/containers/hash_tables.h"
 #include "cc/animation/scrollbar_animation_controller.h"
-#include "cc/debug/test_web_graphics_context_3d.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/scrollbar_layer_impl.h"
 #include "cc/quads/solid_color_draw_quad.h"
+#include "cc/resources/prioritized_resource_manager.h"
+#include "cc/resources/priority_calculator.h"
 #include "cc/resources/resource_update_queue.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_scrollbar.h"
-#include "cc/test/fake_scrollbar_layer.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/test/mock_quad_culler.h"
-#include "cc/trees/layer_tree_host.h"
+#include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
@@ -405,48 +404,9 @@ class MockLayerTreeHost : public LayerTreeHost {
  public:
   MockLayerTreeHost(LayerTreeHostClient* client,
                     const LayerTreeSettings& settings)
-      : LayerTreeHost(client, settings),
-        next_id_(1),
-        total_ui_resource_created_(0),
-        total_ui_resource_deleted_(0) {
+      : LayerTreeHost(client, settings) {
     Initialize(NULL);
   }
-
-  virtual UIResourceId CreateUIResource(UIResourceClient* content) OVERRIDE {
-    total_ui_resource_created_++;
-    UIResourceId nid = next_id_++;
-    ui_resource_bitmap_map_[nid] = content->GetBitmap(nid, false);
-    return nid;
-  }
-
-  // Deletes a UI resource.  May safely be called more than once.
-  virtual void DeleteUIResource(UIResourceId id) OVERRIDE {
-    UIResourceBitmapMap::iterator iter = ui_resource_bitmap_map_.find(id);
-    if (iter != ui_resource_bitmap_map_.end()) {
-      ui_resource_bitmap_map_.erase(iter);
-      total_ui_resource_deleted_++;
-    }
-  }
-
-  size_t UIResourceCount() { return ui_resource_bitmap_map_.size(); }
-  int TotalUIResourceDeleted() { return total_ui_resource_deleted_; }
-  int TotalUIResourceCreated() { return total_ui_resource_created_; }
-
-  gfx::Size ui_resource_size(UIResourceId id) {
-    UIResourceBitmapMap::iterator iter = ui_resource_bitmap_map_.find(id);
-    if (iter != ui_resource_bitmap_map_.end() && iter->second.get())
-      return iter->second->GetSize();
-    return gfx::Size();
-  }
-
- private:
-  typedef base::hash_map<UIResourceId, scoped_refptr<UIResourceBitmap> >
-      UIResourceBitmapMap;
-  UIResourceBitmapMap ui_resource_bitmap_map_;
-
-  int next_id_;
-  int total_ui_resource_created_;
-  int total_ui_resource_deleted_;
 };
 
 
@@ -455,10 +415,7 @@ class ScrollbarLayerTestResourceCreation : public testing::Test {
   ScrollbarLayerTestResourceCreation()
       : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
 
-  void TestResourceUpload(int num_updates,
-                          size_t expected_resources,
-                          int expected_created,
-                          int expected_deleted) {
+  void TestResourceUpload(size_t expected_resources) {
     layer_tree_host_.reset(
         new MockLayerTreeHost(&fake_client_, layer_tree_settings_));
 
@@ -466,11 +423,13 @@ class ScrollbarLayerTestResourceCreation : public testing::Test {
     scoped_refptr<Layer> layer_tree_root = Layer::Create();
     scoped_refptr<Layer> content_layer = Layer::Create();
     scoped_refptr<Layer> scrollbar_layer =
-      ScrollbarLayer::Create(scrollbar.Pass(), layer_tree_root->id());
+        ScrollbarLayer::Create(scrollbar.Pass(), layer_tree_root->id());
     layer_tree_root->AddChild(content_layer);
     layer_tree_root->AddChild(scrollbar_layer);
 
     layer_tree_host_->InitializeOutputSurfaceIfNeeded();
+    layer_tree_host_->contents_texture_manager()->
+        SetMaxMemoryLimitBytes(1024 * 1024);
     layer_tree_host_->SetRootLayer(layer_tree_root);
 
     scrollbar_layer->SetIsDrawable(true);
@@ -488,17 +447,16 @@ class ScrollbarLayerTestResourceCreation : public testing::Test {
     testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
     EXPECT_EQ(scrollbar_layer->layer_tree_host(), layer_tree_host_.get());
 
+    PriorityCalculator calculator;
     ResourceUpdateQueue queue;
     OcclusionTracker occlusion_tracker(gfx::Rect(), false);
 
     scrollbar_layer->SavePaintProperties();
-    for (int update_counter = 0; update_counter < num_updates; update_counter++)
-      scrollbar_layer->Update(&queue, &occlusion_tracker);
-
-    // A non-solid-color scrollbar should have requested two textures.
-    EXPECT_EQ(expected_resources, layer_tree_host_->UIResourceCount());
-    EXPECT_EQ(expected_created, layer_tree_host_->TotalUIResourceCreated());
-    EXPECT_EQ(expected_deleted, layer_tree_host_->TotalUIResourceDeleted());
+    scrollbar_layer->SetTexturePriorities(calculator);
+    layer_tree_host_->contents_texture_manager()->PrioritizeTextures();
+    scrollbar_layer->Update(&queue, &occlusion_tracker);
+    EXPECT_EQ(0u, queue.FullUploadSize());
+    EXPECT_EQ(expected_resources, queue.PartialUploadSize());
 
     testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
@@ -513,18 +471,12 @@ class ScrollbarLayerTestResourceCreation : public testing::Test {
 
 TEST_F(ScrollbarLayerTestResourceCreation, ResourceUpload) {
   layer_tree_settings_.solid_color_scrollbars = false;
-  TestResourceUpload(0, 0, 0, 0);
-  int num_updates[3] = {1, 5, 10};
-  for (int j = 0; j < 3; j++) {
-    TestResourceUpload(
-        num_updates[j], 2, num_updates[j] * 2, (num_updates[j] - 1) * 2);
-  }
+  TestResourceUpload(2);
 }
 
 TEST_F(ScrollbarLayerTestResourceCreation, SolidColorNoResourceUpload) {
   layer_tree_settings_.solid_color_scrollbars = true;
-  TestResourceUpload(0, 0, 0, 0);
-  TestResourceUpload(1, 0, 0, 0);
+  TestResourceUpload(0);
 }
 
 class ScaledScrollbarLayerTestResourceCreation : public testing::Test {
@@ -532,20 +484,25 @@ class ScaledScrollbarLayerTestResourceCreation : public testing::Test {
   ScaledScrollbarLayerTestResourceCreation()
       : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
 
-  void TestResourceUpload(const float test_scale) {
+  void TestResourceUpload(size_t expected_resources, const float test_scale) {
     layer_tree_host_.reset(
         new MockLayerTreeHost(&fake_client_, layer_tree_settings_));
 
     gfx::Point scrollbar_location(0, 185);
+    scoped_ptr<FakeScrollbar> scrollbar(new FakeScrollbar(false, true, false));
+    scrollbar->set_location(scrollbar_location);
+
     scoped_refptr<Layer> layer_tree_root = Layer::Create();
     scoped_refptr<Layer> content_layer = Layer::Create();
-    scoped_refptr<FakeScrollbarLayer> scrollbar_layer =
-        FakeScrollbarLayer::Create(false, true, layer_tree_root->id());
-
+    scoped_refptr<Layer> scrollbar_layer =
+        ScrollbarLayer::Create(scrollbar.PassAs<cc::Scrollbar>(),
+                               layer_tree_root->id());
     layer_tree_root->AddChild(content_layer);
     layer_tree_root->AddChild(scrollbar_layer);
 
     layer_tree_host_->InitializeOutputSurfaceIfNeeded();
+    layer_tree_host_->contents_texture_manager()->
+        SetMaxMemoryLimitBytes(1024 * 1024);
     layer_tree_host_->SetRootLayer(layer_tree_root);
 
     scrollbar_layer->SetIsDrawable(true);
@@ -572,23 +529,30 @@ class ScaledScrollbarLayerTestResourceCreation : public testing::Test {
     testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
     EXPECT_EQ(scrollbar_layer->layer_tree_host(), layer_tree_host_.get());
 
+    PriorityCalculator calculator;
     ResourceUpdateQueue queue;
     OcclusionTracker occlusion_tracker(gfx::Rect(), false);
+
     scrollbar_layer->SavePaintProperties();
+    scrollbar_layer->SetTexturePriorities(calculator);
+    layer_tree_host_->contents_texture_manager()->PrioritizeTextures();
     scrollbar_layer->Update(&queue, &occlusion_tracker);
+    EXPECT_EQ(expected_resources, queue.PartialUploadSize());
 
     // Verify that we have not generated any content uploads that are larger
     // than their destination textures.
-
-    gfx::Size track_size = layer_tree_host_->ui_resource_size(
-        scrollbar_layer->track_resource_id());
-    gfx::Size thumb_size = layer_tree_host_->ui_resource_size(
-        scrollbar_layer->thumb_resource_id());
-
-    EXPECT_LE(track_size.width(), scrollbar_layer->content_bounds().width());
-    EXPECT_LE(track_size.height(), scrollbar_layer->content_bounds().height());
-    EXPECT_LE(thumb_size.width(), scrollbar_layer->content_bounds().width());
-    EXPECT_LE(thumb_size.height(), scrollbar_layer->content_bounds().height());
+    while (queue.HasMoreUpdates()) {
+      ResourceUpdate update = queue.TakeFirstPartialUpload();
+      EXPECT_LE(update.texture->size().width(),
+                scrollbar_layer->content_bounds().width());
+      EXPECT_LE(update.texture->size().height(),
+                scrollbar_layer->content_bounds().height());
+
+      EXPECT_LE(update.dest_offset.x() + update.content_rect.width(),
+                update.texture->size().width());
+      EXPECT_LE(update.dest_offset.y() + update.content_rect.height(),
+                update.texture->size().height());
+    }
 
     testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
@@ -605,9 +569,7 @@ TEST_F(ScaledScrollbarLayerTestResourceCreation, ScaledResourceUpload) {
   layer_tree_settings_.solid_color_scrollbars = false;
   // Pick a test scale that moves the scrollbar's (non-zero) position to
   // a non-pixel-aligned location.
-  TestResourceUpload(.041f);
-  TestResourceUpload(1.41f);
-  TestResourceUpload(4.1f);
+  TestResourceUpload(2, 1.41f);
 }
 
 }  // namespace
diff --git a/chromium/cc/layers/texture_layer.cc b/chromium/cc/layers/texture_layer.cc
index 2325a80c793..11009fa1b68 100644
--- a/chromium/cc/layers/texture_layer.cc
+++ b/chromium/cc/layers/texture_layer.cc
@@ -196,6 +196,7 @@ bool TextureLayer::Update(ResourceUpdateQueue* queue,
           client_->Context3d()->getGraphicsResetStatusARB() != GL_NO_ERROR)
         texture_id_ = 0;
       updated = true;
+      SetNeedsPushProperties();
     }
   }
 
diff --git a/chromium/cc/layers/texture_layer_unittest.cc b/chromium/cc/layers/texture_layer_unittest.cc
index 744bf004956..aa08e9f81ee 100644
--- a/chromium/cc/layers/texture_layer_unittest.cc
+++ b/chromium/cc/layers/texture_layer_unittest.cc
@@ -7,13 +7,11 @@
 #include <string>
 
 #include "base/callback.h"
-#include "cc/debug/test_web_graphics_context_3d.h"
 #include "cc/layers/texture_layer_client.h"
 #include "cc/layers/texture_layer_impl.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
-#include "cc/test/fake_output_surface.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/trees/layer_tree_host.h"