UI Resource Manager

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/resources/ui_resource_bitmap.h"
+#include "cc/resources/ui_resource_manager_client.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/SkSize.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>();
 }
 
 scoped_refptr<ScrollbarLayer> ScrollbarLayer::Create(
     scoped_ptr<Scrollbar> scrollbar,
     int 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),
-      texture_format_(GL_INVALID_ENUM) {
+      track_ui_resource_id_(0),
+      thumb_ui_resource_id_(0) {
   if (!scrollbar_->IsOverlay())
     SetShouldScrollOnMainThread(true);
 }
 
 ScrollbarLayer::~ScrollbarLayer() {}
 
 void ScrollbarLayer::SetScrollLayerId(int id) {
   if (id == scroll_layer_id_)
     return;
 
@@ skipping 40 matching lines @@
                                             float* contents_scale_y,
                                             gfx::Size* content_bounds) {
   ContentsScalingLayer::CalculateContentsScale(
       ClampScaleToMaxTextureSize(ideal_contents_scale),
       device_scale_factor,
       page_scale_factor,
       animating_transform_to_screen,
       contents_scale_x,
       contents_scale_y,
       content_bounds);
+
+  track_rect_ = scrollbar_->TrackRect();

[enne (OOO), 2013/07/22 23:09:15]

Why does this come before the solid color early-out?

Also, why do you need to stash these values during CalculateContentsScale? Can
you just do this work in Update as before?

[powei, 2013/07/24 02:28:29]

Done.  I moved this from Update originally thinking that all work should be done
in CalculateContentsScale.  Forgot to move it back.  trace_rect_ needs to come
before the solid color check because these values are also used in solid mode.

+
+  if (layer_tree_host()->settings().solid_color_scrollbars)
+    return;
+
+  if (scrollbar_->HasThumb()) {
+    thumb_thickness_ = scrollbar_->ThumbThickness();
+    thumb_length_ = scrollbar_->ThumbLength();
+  }
 }
 
 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) {
     int thickness_override =
@@ skipping 11 matching lines @@
   }
   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());
   }
 
-  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_track_ui_resource_id(track_ui_resource_id_);
+  scrollbar_layer->set_thumb_ui_resource_id(thumb_ui_resource_id_);
 }
 
 ScrollbarLayer* ScrollbarLayer::ToScrollbarLayer() {
   return this;
 }
 
 void ScrollbarLayer::SetLayerTreeHost(LayerTreeHost* host) {
+  // When the LTH is set to null, then this layer should remove all of
+  // its associated textures.
   if (!host || host != layer_tree_host()) {
-    track_updater_ = NULL;
-    track_.reset();
-    thumb_updater_ = NULL;
-    thumb_.reset();
+    if (track_ui_resource_id_) {
+      if (layer_tree_host()) {
+        layer_tree_host()->DeleteUIResource(track_ui_resource_id_);
+      }
+      track_ui_resource_id_ = 0;
+      track_bitmap_ = NULL;
+    }
+
+    if (thumb_ui_resource_id_) {
+      if (layer_tree_host()) {
+        layer_tree_host()->DeleteUIResource(thumb_ui_resource_id_);
+      }
+      thumb_ui_resource_id_ = 0;
+      thumb_bitmap_ = NULL;
+    }
   }
 
   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());
-  }
-}
-
-void ScrollbarLayer::UpdatePart(CachingBitmapContentLayerUpdater* painter,
-                                LayerUpdater::Resource* resource,
-                                gfx::Rect rect,
-                                ResourceUpdateQueue* queue) {
-  if (layer_tree_host()->settings().solid_color_scrollbars)
-    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.
-  DCHECK(resource->texture()->can_acquire_backing_texture());
-  if (!resource->texture()->can_acquire_backing_texture())
-    return;
-
-  // 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;
-  }
-
-  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);
-}
-
 gfx::Rect ScrollbarLayer::ScrollbarLayerRectToContentRect(
     gfx::Rect layer_rect) const {
   // Don't intersect with the bounds as in LayerRectToContentRect() because
   // layer_rect here might be in coordinates of the containing layer.
   gfx::Rect expanded_rect = gfx::ScaleToEnclosingRect(
       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)
-    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) {
-  track_rect_ = scrollbar_->TrackRect();
-
-  if (layer_tree_host()->settings().solid_color_scrollbars)
-    return;
-
-  {
-    base::AutoReset<bool> ignore_set_needs_commit(&ignore_set_needs_commit_,
-                                                  true);
-    ContentsScalingLayer::Update(queue, occlusion);
-  }
-
-  dirty_rect_.Union(update_rect_);
-  if (content_bounds().IsEmpty())
-    return;
-  if (visible_content_rect().IsEmpty())
-    return;
-
-  CreateUpdaterIfNeeded();
-
-  gfx::Rect content_rect = ScrollbarLayerRectToContentRect(
-      gfx::Rect(scrollbar_->Location(), bounds()));
-  UpdatePart(track_updater_.get(),
-             track_.get(),
-             content_rect,
-             queue);
-
-  if (scrollbar_->HasThumb()) {
-    thumb_thickness_ = scrollbar_->ThumbThickness();
-    thumb_length_ = scrollbar_->ThumbLength();
-    gfx::Rect origin_thumb_rect = OriginThumbRect();
-    if (!origin_thumb_rect.IsEmpty()) {
-      UpdatePart(thumb_updater_.get(),
-                 thumb_.get(),
-                 origin_thumb_rect,
-                 queue);
-    }
-  }
-
-  dirty_rect_ = gfx::RectF();
-}
-
 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));
 }
 
+
+void ScrollbarLayer::Update(ResourceUpdateQueue* queue,
+                            const OcclusionTracker* occlusion) {
+  if (layer_tree_host()->settings().solid_color_scrollbars)
+    return;
+
+  // Setting this boolean is still necessary to ensure no extra commits.
+  base::AutoReset<bool> ignore_set_needs_commit(&ignore_set_needs_commit_,
+                                                true);
+  ContentsScalingLayer::Update(queue, occlusion);
+
+  RasterizeTrackAndThumb();
+
+  if (track_ui_resource_id_) {

[aelias_OOO_until_Jul13, 2013/07/23 00:06:48]

nit: no {}

[powei, 2013/07/24 02:28:29]

Done.

+    layer_tree_host()->DeleteUIResource(track_ui_resource_id_);
+  }
+  track_ui_resource_id_ = layer_tree_host()->CreateUIResource(
+      base::Bind(&ScrollbarLayer::GetTrackBitmap, this));
+
+  if (scrollbar_->HasThumb()) {
+    if (thumb_ui_resource_id_) {

[aelias_OOO_until_Jul13, 2013/07/23 00:06:48]

nit: no {}

[powei, 2013/07/24 02:28:29]

Done.

+      layer_tree_host()->DeleteUIResource(thumb_ui_resource_id_);
+    }
+
+    thumb_ui_resource_id_ = layer_tree_host()->CreateUIResource(
+        base::Bind(&ScrollbarLayer::GetThumbBitmap, this));

[aelias_OOO_until_Jul13, 2013/07/23 00:06:48]

This will crash if the ScrollbarLayer no longer exists when the context is lost.

I suggest using base::WeakPtrFactory<ScrollbarLayer> here instead of directly
"this".  (I don't think it's a good idea to refcount the ScrollbarLayer.)

[powei, 2013/07/24 02:28:29]

Apparently, "WeakCalls" are only supported for null return-type callbacks (see
bind_internal.h:1093).  This callback would crash if the ScrollbarLayer is not
detached from LTH before it is deleted (with SetLayerTreeHost(NULL)).  Can we
assume that this situation will never happen?

[aelias_OOO_until_Jul13, 2013/07/24 02:57:46]

OK, that makes sense.  We should address the issue by being more careful about
ScrollbarLayer destruction.

+  }
+}
+
+void ScrollbarLayer::RasterizeTrackAndThumb() {

[aelias_OOO_until_Jul13, 2013/07/23 00:06:48]

Add a DCHECK(!layer_tree_host()->settings().solid_color_scrollbars);

[powei, 2013/07/24 02:28:29]

Done.

+  {

[aelias_OOO_until_Jul13, 2013/07/23 00:06:48]

nit: this block looks weird, I suggest removing it.

[powei, 2013/07/24 02:28:29]

Done.

+    gfx::Rect track_rect = ScrollbarLayerRectToContentRect(
+        gfx::Rect(scrollbar_->Location(), bounds()));
+    track_bitmap_ = UIResourceBitmap::Create(
+        new uint8_t[track_rect.width() * track_rect.height() * 4],
+        UIResourceBitmap::RGBA8,
+        track_rect.size());
+
+    skia::RefPtr<SkCanvas> track_canvas = skia::AdoptRef(
+        skia::CreatePlatformCanvas(track_rect.width(),
+                                   track_rect.height(),
+                                   false,
+                                   reinterpret_cast<uint8_t*>(

[aelias_OOO_until_Jul13, 2013/07/23 00:06:48]

Should be static_cast<>

[powei, 2013/07/24 02:28:29]

Done.

+                                       track_bitmap_->GetPixels()),
+                                   skia::CRASH_ON_FAILURE));
+
+    track_canvas->save();
+    track_canvas->translate(SkFloatToScalar(-track_rect.x()),
+                            SkFloatToScalar(-track_rect.y()));
+    SkPaint paint;
+    paint.setAntiAlias(false);
+    paint.setXfermodeMode(SkXfermode::kClear_Mode);
+    SkRect layer_sk_rect = SkRect::MakeXYWH(track_rect.x(),
+                                            track_rect.y(),
+                                            track_rect.width(),
+                                            track_rect.height());
+
+    track_canvas->drawRect(layer_sk_rect, paint);

[aelias_OOO_until_Jul13, 2013/07/23 00:06:48]

You are clearing the track canvas but not the thumb canvas, why?  Please get rid
of this clear if it's unnecessary, or add it to the thumb paint if it's needed.

[powei, 2013/07/24 02:28:29]

Done.

+    track_canvas->clipRect(layer_sk_rect);
+    scrollbar_->PaintPart(track_canvas.get(), TRACK, track_rect);
+    track_canvas->restore();
+  }
+
+  if (scrollbar_->HasThumb()) {
+    gfx::Rect thumb_rect = OriginThumbRect();
+    thumb_bitmap_ = UIResourceBitmap::Create(
+        new uint8_t[thumb_rect.width() * thumb_rect.height() * 4],
+        UIResourceBitmap::RGBA8,
+        thumb_rect.size());
+
+    skia::RefPtr<SkCanvas> thumb_canvas = skia::AdoptRef(
+        skia::CreatePlatformCanvas(thumb_rect.width(),
+                                   thumb_rect.height(),
+                                   false,
+                                   reinterpret_cast<uint8_t*>(

[aelias_OOO_until_Jul13, 2013/07/23 00:06:48]

Should be static_cast<>

[powei, 2013/07/24 02:28:29]

Done.

+                                       thumb_bitmap_->GetPixels()),
+                                   skia::CRASH_ON_FAILURE));
+
+    scrollbar_->PaintPart(thumb_canvas.get(),
+                          THUMB,
+                          thumb_rect);
+  }
+}
+
+scoped_refptr<UIResourceBitmap>
+ScrollbarLayer::GetTrackBitmap(bool resource_lost) {
+  return track_bitmap_;
+}
+
+scoped_refptr<UIResourceBitmap>
+ScrollbarLayer::GetThumbBitmap(bool resource_lost) {
+  return thumb_bitmap_;
+}
+
 }  // namespace cc