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

cc/layer_tree_impl.cc

 // Copyright 2011 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/layer_tree_impl.h"
 
 #include "base/debug/trace_event.h"
+#include "cc/animation.h"
+#include "cc/animation_id_provider.h"
 #include "cc/heads_up_display_layer_impl.h"
+#include "cc/keyframed_animation_curve.h"
+#include "cc/layer.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_host_impl.h"
+#include "cc/pinch_zoom_scrollbar.h"
+#include "cc/scrollbar_layer_impl.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 namespace cc {
 
 LayerTreeImpl::LayerTreeImpl(LayerTreeHostImpl* layer_tree_host_impl)
     : layer_tree_host_impl_(layer_tree_host_impl),
       source_frame_number_(-1),
       hud_layer_(0),
       root_scroll_layer_(0),
       currently_scrolling_layer_(0),
       background_color_(0),
       has_transparent_background_(false),
+      pinch_zoom_scrollbar_horizontal_layer_id_(Layer::s_invalidLayerId),
+      pinch_zoom_scrollbar_vertical_layer_id_(Layer::s_invalidLayerId),
       page_scale_factor_(1),
       page_scale_delta_(1),
       sent_page_scale_delta_(1),
       min_page_scale_factor_(0),
       max_page_scale_factor_(0),
       scrolling_layer_id_from_previous_tree_(0),
       contents_textures_purged_(false),
       viewport_size_invalid_(false),
       needs_update_draw_properties_(true),
       needs_full_tree_sync_(true) {
@@ skipping 76 matching lines @@
     target_tree->SetViewportSizeInvalid();
   else
     target_tree->ResetViewportSizeInvalid();
 
   if (hud_layer())
     target_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(
         LayerTreeHostCommon::findLayerInSubtree(
             target_tree->RootLayer(), hud_layer()->id())));
   else
     target_tree->set_hud_layer(NULL);
+
+  target_tree->SetPinchZoomHorizontalLayerId(pinch_zoom_scrollbar_horizontal_layer_id_);

[enne (OOO), 2013/03/11 21:08:24]

style nit: 80 col.

[wjmaclean, 2013/03/12 16:13:07]

Done.

+  target_tree->SetPinchZoomVerticalLayerId(pinch_zoom_scrollbar_vertical_layer_id_);

[enne (OOO), 2013/03/11 21:08:24]

style nit: 80 col.

[wjmaclean, 2013/03/12 16:13:07]

Done.

 }
 
 LayerImpl* LayerTreeImpl::RootScrollLayer() {
   DCHECK(IsActiveTree());
   return root_scroll_layer_;
 }
 
 LayerImpl* LayerTreeImpl::CurrentlyScrollingLayer() {
   DCHECK(IsActiveTree());
   return currently_scrolling_layer_;
@@ skipping 198 matching lines @@
   layer->didBecomeActive();
   for (size_t i = 0; i < layer->children().size(); ++i)
     DidBecomeActiveRecursive(layer->children()[i]);
 }
 
 void LayerTreeImpl::DidBecomeActive() {
   if (RootLayer())
     DidBecomeActiveRecursive(RootLayer());
   FindRootScrollLayer();
   UpdateMaxScrollOffset();
+  // Main thread scrolls do not get handled in LayerTreeHostImpl, so after
+  // each commit (and after the root scroll layer has its max scroll offset
+  // set), we need to update pinch zoom scrollbars.
+  UpdatePinchZoomScrollbars();
 }
 
 bool LayerTreeImpl::ContentsTexturesPurged() const {
   return contents_textures_purged_;
 }
 
 void LayerTreeImpl::SetContentsTexturesPurged() {
   contents_textures_purged_ = true;
   layer_tree_host_impl_->OnCanDrawStateChangedForTree(this);
 }
@@ skipping 132 matching lines @@
   LayerIteratorType end = LayerIteratorType::end(&render_surface_layer_list_);
   for (LayerIteratorType it = LayerIteratorType::begin(
            &render_surface_layer_list_); it != end; ++it) {
     if (!it.representsItself())
       continue;
     state->Append((*it)->AsValue().release());
   }
   return state.PassAs<base::Value>();
 }
 
+void LayerTreeImpl::DidBeginScroll() {
+  if (HasPinchZoomScrollbars())
+    FadeInPinchZoomScrollbars();
+}
+
+void LayerTreeImpl::DidUpdateScroll() {
+  if (HasPinchZoomScrollbars())
+    UpdatePinchZoomScrollbars();
+}
+
+void LayerTreeImpl::DidEndScroll() {
+  if (HasPinchZoomScrollbars())
+    FadeOutPinchZoomScrollbars();
+}
+
+void LayerTreeImpl::SetPinchZoomHorizontalLayerId(int layer_id) {
+  pinch_zoom_scrollbar_horizontal_layer_id_ = layer_id;
+}
+
+ScrollbarLayerImpl* LayerTreeImpl::PinchZoomScrollbarHorizontal() {
+  return static_cast<ScrollbarLayerImpl*>(LayerById(
+    pinch_zoom_scrollbar_horizontal_layer_id_));
+}
+
+void LayerTreeImpl::SetPinchZoomVerticalLayerId(int layer_id) {
+  pinch_zoom_scrollbar_vertical_layer_id_ = layer_id;
+}
+
+ScrollbarLayerImpl* LayerTreeImpl::PinchZoomScrollbarVertical() {
+  return static_cast<ScrollbarLayerImpl*>(LayerById(
+    pinch_zoom_scrollbar_vertical_layer_id_));
+}
+
+void LayerTreeImpl::UpdatePinchZoomScrollbars() {
+  LayerImpl* root_scroll_layer = RootScrollLayer();
+  if (!root_scroll_layer)
+    return;
+
+  if (ScrollbarLayerImpl* scrollbar = PinchZoomScrollbarHorizontal()) {
+    scrollbar->setCurrentPos(root_scroll_layer->scrollOffset().x());
+    scrollbar->setTotalSize(root_scroll_layer->bounds().width());
+    scrollbar->setMaximum(root_scroll_layer->maxScrollOffset().x());
+  }
+  if (ScrollbarLayerImpl* scrollbar = PinchZoomScrollbarVertical()) {
+    scrollbar->setCurrentPos(root_scroll_layer->scrollOffset().y());
+    scrollbar->setTotalSize(root_scroll_layer->bounds().height());
+    scrollbar->setMaximum(root_scroll_layer->maxScrollOffset().y());
+  }
+}
+
+static scoped_ptr<Animation> MakePinchZoomFadeAnimation(
+    float start_opacity, float end_opacity) {
+  scoped_ptr<KeyframedFloatAnimationCurve> curve =
+    KeyframedFloatAnimationCurve::create();
+  curve->addKeyframe(FloatKeyframe::create(
+    0, start_opacity, EaseInTimingFunction::create()));
+  curve->addKeyframe(FloatKeyframe::create(
+    PinchZoomScrollbar::kFadeDurationInSeconds, end_opacity,
+    EaseInTimingFunction::create()));
+
+  scoped_ptr<Animation> animation = Animation::create(
+      curve.PassAs<AnimationCurve>(), AnimationIdProvider::NextAnimationId(),
+      0, Animation::Opacity);
+  animation->setIsImplOnly(true);
+
+  return animation.Pass();
+}
+
+static void StartFadeInAnimation(LayerImpl* layer) {
+  // The start opacity value must be > 0 in order that the scrollbars get
+  // painted at the start of the animation, otherwise they never display.
+  float start_opacity = fmax(0.01, layer->opacity());

[enne (OOO), 2013/03/11 21:08:24]

Can you help me understand how an impl-side animation affects painting?  I still
don't get it.

[wjmaclean, 2013/03/12 16:13:07]

The very first time the scrollbars need to be shown, they will not yet have been
painted, so presumably we need to make sure this happens. I suppose ideally the
system would detect if the scrollbar had not yet been painted (no texture id),
and request a repaint. It seems that happens automatically if I set a non-zero
start value, but it is happy to run the entire animation *without* a texture if
I don't.

In the next revision of the CL I have attempted an alternate method to invoke
the painting process.

+  LayerAnimationController* controller = layer->layerAnimationController();
+  // TODO() It shouldn't be necessary to manually remove the old animation.
+  if (Animation* animation = controller->getAnimation(Animation::Opacity))
+    controller->removeAnimation(animation->id());
+  controller->addAnimation(MakePinchZoomFadeAnimation(start_opacity,
+    PinchZoomScrollbar::kDefaultOpacity));
+}
+
+void LayerTreeImpl::FadeInPinchZoomScrollbars() {
+  if (!HasPinchZoomScrollbars() || page_scale_factor_ == 1)
+    return;
+
+  StartFadeInAnimation(PinchZoomScrollbarHorizontal());
+  StartFadeInAnimation(PinchZoomScrollbarVertical());
+}
+
+static void StartFadeOutAnimation(LayerImpl* layer) {
+  float opacity = layer->opacity();
+  if (!opacity)
+    return;
+
+  LayerAnimationController* controller = layer->layerAnimationController();
+  // TODO() It shouldn't be necessary to manually remove the old animation.

[enne (OOO), 2013/03/11 21:08:24]

TODO(wjmaclean)

[wjmaclean, 2013/03/12 16:13:07]

Done.

+  if (Animation* animation = controller->getAnimation(Animation::Opacity))
+    controller->removeAnimation(animation->id());
+  controller->addAnimation(MakePinchZoomFadeAnimation(opacity, 0));
+}
+
+void LayerTreeImpl::FadeOutPinchZoomScrollbars() {
+  if (!HasPinchZoomScrollbars())
+    return;
+
+  StartFadeOutAnimation(PinchZoomScrollbarHorizontal());
+  StartFadeOutAnimation(PinchZoomScrollbarVertical());
+}
+
+bool LayerTreeImpl::HasPinchZoomScrollbars() const {
+  return pinch_zoom_scrollbar_horizontal_layer_id_ != Layer::s_invalidLayerId &&
+         pinch_zoom_scrollbar_vertical_layer_id_ != Layer::s_invalidLayerId;
+}
+
+
 } // namespace cc