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_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),
@@ skipping 88 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);
+  target_tree->SetPinchZoomVerticalLayerId(pinch_zoom_scrollbar_vertical_layer_id);
 }
 
 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();
+  // When becoming active there may not be a currently scrolling layer so we
+  // need to force the update.
+  UpdatePinchZoomScrollbarsIfNeeded(UPDATE_MAIN_THREAD_SCROLL);

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

Can you explain this more clearly? Why would the scrollbars not be up to date? 
If there's no currently scrolling layer, why would they even need to be?

[wjmaclean, 2013/03/06 22:36:53]

Main-thread scrolls just update properties on the main thread, and never call
any of the scroll methods in LayerTreeHostImpl. Since PZ scrollbars are attached
to the LTI, and not a LayerImpl, then we need to update these properties after
each commit, and at a time when the max scroll offset has been called. This
seems to be the right place.

Comment revised.

 }
 
 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::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::UpdatePinchZoomScrollbarsIfNeeded(
+    PinchZoomScrollbarUpdateReason update_reason) {
+  LayerImpl* root_scroll_layer = RootScrollLayer();
+  if (!root_scroll_layer ||
+      (update_reason == UPDATE_IMPL_THREAD_SCROLL  &&
+       root_scroll_layer != CurrentlyScrollingLayer()))

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

What does the currently scrolling layer have to do with updating the scrollbars
with changes from the root scroll layer?

[wjmaclean, 2013/03/06 22:36:53]

I had intended not to update the PZ scrollbars if some layer other than the
rootScrollLayer was scrolling.

This was removed based on a suggestion elsewhere in your comments.

+    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::kFadeDuration, end_opacity,
+    EaseInTimingFunction::create()));
+
+  scoped_ptr<Animation> animation = Animation::create(curve.PassAs<AnimationCurve>(), AnimationIdProvider::NextAnimationId(), 0, Animation::Opacity);
+  animation->setIsImplAnimationOnly(true);
+
+  return animation.Pass();
+}
+
+void LayerTreeImpl::FadeInPinchZoomScrollbars() {
+  if (!HasPinchZoomScrollbars() || page_scale_factor_ == 1)
+    return;
+
+  animationRegistrar()->GetAnimationControllerForId(
+      pinch_zoom_scrollbar_horizontal_layer_id)->addAnimation(
+        MakePinchZoomFadeAnimation(0.01, PinchZoomScrollbar::kDefaultOpacity));

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

Shouldn't you start the fade animation from the current opacity value? What if
you fade in during the middle of a fade out?

At any rate, 0.01 looks odd.

[wjmaclean, 2013/03/06 22:36:53]

Agreed, but we need the start opacity to be non-zero or else the scrollbars
never paint.

I'm revising to handle pz scrollbar animations interrupting one another, so will
handle your comment about the start opacity (in part) with the revision.

[enne (OOO), 2013/03/06 22:45:38]

This is an impl-only animation.  How does that interact with painting?

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

Since the PZ scrollbar starts with opacity 0, it doesn't get painted until the
first time we do a fade-in animation. It seems if the animation doesn't start at
a non-zero value that it never gets painted.

+
+  animationRegistrar()->GetAnimationControllerForId(
+      pinch_zoom_scrollbar_vertical_layer_id)->addAnimation(
+        MakePinchZoomFadeAnimation(0.01, PinchZoomScrollbar::kDefaultOpacity));
+}
+
+void LayerTreeImpl::FadeOutPinchZoomScrollbars() {
+  if (!HasPinchZoomScrollbars())
+    return;
+
+  if (PinchZoomScrollbarHorizontal()->opacity() == 0 &&
+      PinchZoomScrollbarVertical()->opacity() == 0)
+    return;
+
+  animationRegistrar()->GetAnimationControllerForId(
+      pinch_zoom_scrollbar_horizontal_layer_id)->addAnimation(
+        MakePinchZoomFadeAnimation(PinchZoomScrollbar::kDefaultOpacity, 0));
+
+  animationRegistrar()->GetAnimationControllerForId(
+      pinch_zoom_scrollbar_vertical_layer_id)->addAnimation(
+        MakePinchZoomFadeAnimation(PinchZoomScrollbar::kDefaultOpacity, 0));
+}
+
 } // namespace cc