Implement pinch-zoom scaling for main-frame scrollbars and pinch-zoom overlay scrollbars.

cc/pinch_zoom_scrollbar.cc

Index: cc/pinch_zoom_scrollbar.cc
diff --git a/cc/pinch_zoom_scrollbar.cc b/cc/pinch_zoom_scrollbar.cc
new file mode 100644
index 0000000000000000000000000000000000000000..67dbf4d5715bdba3df71195eea55449d984a3c98
--- /dev/null
+++ b/cc/pinch_zoom_scrollbar.cc
@@ -0,0 +1,113 @@
+// Copyright 2013 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/pinch_zoom_scrollbar.h"
+
+#include "cc/layer.h"
+#include "cc/layer_tree_host.h"
+#include "cc/pinch_zoom_scrollbar_geometry.h"
+
+namespace cc {
+
+const float PinchZoomScrollbar::kDefaultOpacity = 0.5;
+const float PinchZoomScrollbar::kFadeDuration = 0.5; // Seconds.

[enne (OOO), 2013/03/06 19:32:58]

Instead of a comment, you could just bake this into the constant name, e.g.
kFadeDurationInSeconds.

[wjmaclean, 2013/03/07 22:57:39]

Sorry, missed this in the latest patch, but have added it now to the upcoming
patch.

+
+PinchZoomScrollbar::PinchZoomScrollbar(
+    WebKit::WebScrollbar::Orientation orientation, LayerTreeHost* owner)
+  : orientation_(orientation),
+    owner_(owner) {
+  DCHECK(owner_);
+}
+
+
+bool PinchZoomScrollbar::isOverlay() const { return true; }
+
+int PinchZoomScrollbar::value() const {
+  Layer* rootScrollLayer = owner_->rootScrollLayer();
+  if (!rootScrollLayer)
+    return 0;
+
+  if (orientation_ == WebKit::WebScrollbar::Horizontal)
+    return rootScrollLayer->scrollOffset().x();
+  else
+    return rootScrollLayer->scrollOffset().y();
+}
+
+WebKit::WebPoint PinchZoomScrollbar::location() const {
+  return WebKit::WebPoint();
+}
+
+WebKit::WebSize PinchZoomScrollbar::size() const {
+  gfx::Size viewportSize = owner_->layoutViewportSize();
+  gfx::Size size;
+  int track_width = PinchZoomScrollbarGeometry::kTrackWidth;
+  if (orientation_ == WebKit::WebScrollbar::Horizontal)
+    size = gfx::Size(viewportSize.width() - track_width, track_width);
+  else
+    size = gfx::Size(track_width, viewportSize.height() - track_width);
+  return WebKit::WebSize(size);
+}
+
+bool PinchZoomScrollbar::enabled() const {
+    return true;
+}
+
+int PinchZoomScrollbar::maximum() const {
+  gfx::Size size = owner_->layoutViewportSize();
+  Layer* rootScrollLayer = owner_->rootScrollLayer();
+  if (!rootScrollLayer)
+    return 0;
+
+  if (orientation_ == WebKit::WebScrollbar::Horizontal)
+    return rootScrollLayer->contentBounds().width() - size.width();
+  else
+    return rootScrollLayer->contentBounds().height() - size.height();
+}
+
+int PinchZoomScrollbar::totalSize() const {
+  Layer* rootScrollLayer = owner_->rootScrollLayer();
+  gfx::Size size;
+  if (rootScrollLayer)
+    size = rootScrollLayer->contentBounds();

[enne (OOO), 2013/03/06 19:32:58]

Can you convince me that contentBounds is the right choice for totalSize and
maximum? I thought scroll positions were all in layer space and thus should be
using bounds().  See also: LayerImpl::updateScrollPositions()

[wjmaclean, 2013/03/07 22:57:39]

On the main thread size, bounds() does not change when you zoom in, yet the
scrollbars need to update based on the pageScaleFactor. Using contentBounds
makes this easier (I don't need to export PSF from LTH), and I make sure that
all the rects produced in PinchZoomScrollbarGeometry are in bounds coordinates.

The rootScrollLayer scrollOffset already seems to have PSF baked in. I could
might be able to get away with using bounds if (1) the PSF was available to
re-scale the scrollOffset, and (2) the rootScrollLayer maxScrollOffset was
guaranteed to be > scrollOffset (at present this doesn't seem to be true always
- in fact it's sometimes zero when scrollOffset is quite large, making me think
it's perhaps only reliable on the impl-side).

[enne (OOO), 2013/03/07 23:41:17]

Aren't the PinchZoomScrollbars overlay scrollbars and thus are sized to the
viewport? Why would you need need to update them based on page scale factor?
This should only happen if boundsContainPageScale(), although I feel like that
should always be false these days.  That doesn't mean that you should use
contentBounds.

My understanding is that scroll offset / delta / sent delta are always in layer
space and not content space.  For another example, see:
https://code.google.com/p/chromium/codesearch#chromium/src/cc/layer_tree_host...

+  else
+    size = owner_->layoutViewportSize();
+
+  if (orientation_ == WebKit::WebScrollbar::Horizontal)
+    return size.width();
+  else
+    return size.height();
+}
+
+bool PinchZoomScrollbar::isScrollViewScrollbar() const {
+    return false;
+}
+
+bool PinchZoomScrollbar::isScrollableAreaActive() const {
+    return true;
+}
+
+WebKit::WebScrollbar::ScrollbarControlSize PinchZoomScrollbar::controlSize() const {
+    return WebKit::WebScrollbar::SmallScrollbar;
+}
+
+WebKit::WebScrollbar::ScrollbarPart PinchZoomScrollbar::pressedPart() const {
+    return WebKit::WebScrollbar::NoPart;
+}
+
+WebKit::WebScrollbar::ScrollbarPart PinchZoomScrollbar::hoveredPart() const {
+    return WebKit::WebScrollbar::NoPart;
+}
+
+WebKit::WebScrollbar::ScrollbarOverlayStyle PinchZoomScrollbar::scrollbarOverlayStyle() const {
+    return WebKit::WebScrollbar::ScrollbarOverlayStyleDefault;
+}
+bool PinchZoomScrollbar::isCustomScrollbar() const {
+    return false;
+}
+
+WebKit::WebScrollbar::Orientation PinchZoomScrollbar::orientation() const {
+    return orientation_;
+}
+
+}  // namespace cc