Use nine-patch resource for drawing Aura overlay scrollbar thumb.

cc/layers/painted_overlay_scrollbar_layer.cc

+// Copyright 2016 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/painted_overlay_scrollbar_layer.h"
+
+#include <algorithm>
+
+#include "base/auto_reset.h"
+#include "cc/base/math_util.h"
+#include "cc/layers/painted_overlay_scrollbar_layer_impl.h"
+#include "cc/resources/ui_resource_bitmap.h"
+#include "cc/resources/ui_resource_manager.h"
+#include "cc/trees/layer_tree_host.h"
+#include "cc/trees/layer_tree_impl.h"
+#include "skia/ext/platform_canvas.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/geometry/size_conversions.h"
+#include "ui/gfx/skia_util.h"
+
+namespace cc {
+
+std::unique_ptr<LayerImpl> PaintedOverlayScrollbarLayer::CreateLayerImpl(
+    LayerTreeImpl* tree_impl) {
+  return PaintedOverlayScrollbarLayerImpl::Create(
+      tree_impl, id(), scrollbar_->Orientation(),
+      scrollbar_->IsLeftSideVerticalScrollbar());
+}
+
+scoped_refptr<PaintedOverlayScrollbarLayer>
+PaintedOverlayScrollbarLayer::Create(std::unique_ptr<Scrollbar> scrollbar,
+                                     int scroll_layer_id) {
+  return make_scoped_refptr(
+      new PaintedOverlayScrollbarLayer(std::move(scrollbar), scroll_layer_id));
+}
+
+PaintedOverlayScrollbarLayer::PaintedOverlayScrollbarLayer(
+    std::unique_ptr<Scrollbar> scrollbar,
+    int scroll_layer_id)
+    : scrollbar_(std::move(scrollbar)),
+      scroll_layer_id_(scroll_layer_id),
+      thumb_thickness_(scrollbar_->ThumbThickness()),
+      thumb_length_(scrollbar_->ThumbLength()) {
+  DCHECK(scrollbar_->UsesNinePatchThumbResource());
+}
+
+PaintedOverlayScrollbarLayer::~PaintedOverlayScrollbarLayer() {}
+
+int PaintedOverlayScrollbarLayer::ScrollLayerId() const {
+  return scroll_layer_id_;
+}
+
+void PaintedOverlayScrollbarLayer::SetScrollLayer(int layer_id) {
+  if (layer_id == scroll_layer_id_)
+    return;
+
+  scroll_layer_id_ = layer_id;
+  SetNeedsFullTreeSync();
+}
+
+bool PaintedOverlayScrollbarLayer::OpacityCanAnimateOnImplThread() const {
+  return scrollbar_->IsOverlay();
+}
+
+bool PaintedOverlayScrollbarLayer::AlwaysUseActiveTreeOpacity() const {
+  return true;
+}
+
+ScrollbarOrientation PaintedOverlayScrollbarLayer::orientation() const {
+  return scrollbar_->Orientation();
+}
+
+void PaintedOverlayScrollbarLayer::PushPropertiesTo(LayerImpl* layer) {
+  Layer::PushPropertiesTo(layer);
+
+  PaintedOverlayScrollbarLayerImpl* scrollbar_layer =
+      static_cast<PaintedOverlayScrollbarLayerImpl*>(layer);
+
+  scrollbar_layer->SetScrollLayerId(scroll_layer_id_);
+
+  scrollbar_layer->SetThumbThickness(thumb_thickness_);
+  scrollbar_layer->SetThumbLength(thumb_length_);
+  if (orientation() == HORIZONTAL) {
+    scrollbar_layer->SetTrackStart(track_rect_.x() - location_.x());
+    scrollbar_layer->SetTrackLength(track_rect_.width());
+  } else {
+    scrollbar_layer->SetTrackStart(track_rect_.y() - location_.y());
+    scrollbar_layer->SetTrackLength(track_rect_.height());
+  }
+
+  if (thumb_resource_.get()) {
+    scrollbar_layer->SetImageBounds(
+        layer_tree_host()->GetUIResourceManager()->GetUIResourceSize(
+            thumb_resource_->id()));
+    scrollbar_layer->SetAperture(aperture_);
+    scrollbar_layer->set_thumb_ui_resource_id(thumb_resource_->id());
+  } else {
+    scrollbar_layer->SetImageBounds(gfx::Size());
+    scrollbar_layer->SetAperture(gfx::Rect());
+    scrollbar_layer->set_thumb_ui_resource_id(0);
+  }
+}
+
+ScrollbarLayerInterface* PaintedOverlayScrollbarLayer::ToScrollbarLayer() {
+  return this;
+}
+
+void PaintedOverlayScrollbarLayer::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()) {

[aelias_OOO_until_Jul13, 2017/02/28 23:23:51]

Nit: "!host ||" is no-op, can be removed.

[bokan, 2017/03/01 00:44:21]

Done.

+    thumb_resource_ = nullptr;
+  }

[aelias_OOO_until_Jul13, 2017/02/28 23:23:51]

nit: no {}

[bokan, 2017/03/01 00:44:21]

Done.

+
+  Layer::SetLayerTreeHost(host);
+}
+
+gfx::Rect PaintedOverlayScrollbarLayer::OriginThumbRectForPainting() const {
+  return gfx::Rect(gfx::Point(), scrollbar_->NinePatchThumbCanvasSize());
+}
+
+bool PaintedOverlayScrollbarLayer::Update() {
+  bool updated = false;
+  {
+    base::AutoReset<bool> ignore_set_needs_commit(&ignore_set_needs_commit_,

[aelias_OOO_until_Jul13, 2017/02/28 23:23:51]

It looks like this is copied from PaintedScrollbarLayer, but I'm not sure what
it's for.  Could you either delete it or add a comment explaining it?

[bokan, 2017/03/01 00:44:21]

This flag was added to Layer in:
https://chromium.googlesource.com/chromium/src/+/29493a1e29003b24d41a8cb44c6e...

And then here in:
https://chromium.googlesource.com/chromium/src/+/467829ba34bd4244b8415e35149e...

Looks like some kind of optimization I don't fully understand. I've removed it
but perhaps enne@ can elaborate.

[enne (OOO), 2017/03/01 00:52:20]

If you're in the middle of an Update before a commit, then any additional
SetNeedsCommit will cause another commit to happen afterwards due to logic in
LTH.  So, in cases where layers like ContentScalingLayer wanted to do some
updates that would cause invalidations (namely changing its internal contents
scale) then the code didn't want invalidations to cause more commits.

If this code isn't doing any invalidations via SetNeedsDisplay inside of update,
then you don't need the auto reset and ignore dance.  It looks like it's fine to
drop.

+                                                  true);
+    updated |= Layer::Update();
+  }
+
+  DCHECK(scrollbar_->HasThumb());
+  DCHECK(scrollbar_->IsOverlay());
+  DCHECK(scrollbar_->UsesNinePatchThumbResource());
+  updated |= UpdateProperty(scrollbar_->TrackRect(), &track_rect_);
+  updated |= UpdateProperty(scrollbar_->Location(), &location_);
+  updated |= UpdateProperty(scrollbar_->ThumbThickness(), &thumb_thickness_);
+  updated |= UpdateProperty(scrollbar_->ThumbLength(), &thumb_length_);
+  updated |= PaintThumbIfNeeded();
+
+  return updated;
+}
+
+bool PaintedOverlayScrollbarLayer::PaintThumbIfNeeded() {
+  if (!scrollbar_->NeedsPaintPart(THUMB))
+    return false;
+
+  gfx::Rect paint_rect = OriginThumbRectForPainting();
+  aperture_ = scrollbar_->NinePatchThumbAperture();
+
+  DCHECK(!paint_rect.size().IsEmpty());
+  DCHECK(paint_rect.origin().IsOrigin());
+
+  SkBitmap skbitmap;
+  skbitmap.allocN32Pixels(paint_rect.width(), paint_rect.height());
+  SkCanvas skcanvas(skbitmap);
+
+  SkRect content_skrect = RectToSkRect(paint_rect);
+  SkPaint paint;
+  paint.setAntiAlias(false);
+  paint.setBlendMode(SkBlendMode::kClear);
+  skcanvas.drawRect(content_skrect, paint);
+  skcanvas.clipRect(content_skrect);
+
+  scrollbar_->PaintPart(&skcanvas, THUMB, paint_rect);
+  // Make sure that the pixels are no longer mutable to unavoid unnecessary
+  // allocation and copying.
+  skbitmap.setImmutable();
+
+  thumb_resource_ = ScopedUIResource::Create(
+      layer_tree_host()->GetUIResourceManager(), UIResourceBitmap(skbitmap));
+
+  SetNeedsPushProperties();
+
+  return true;
+}
+
+}  // namespace cc