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::INVALID_ID),
+      pinch_zoom_scrollbar_vertical_layer_id_(Layer::INVALID_ID),
       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_);
+  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();
+  // 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->scroll_offset().x());
+    scrollbar->SetTotalSize(root_scroll_layer->bounds().width());
+    scrollbar->SetMaximum(root_scroll_layer->max_scroll_offset().x());
+  }
+  if (ScrollbarLayerImpl* scrollbar = PinchZoomScrollbarVertical()) {
+    scrollbar->SetCurrentPos(root_scroll_layer->scroll_offset().y());
+    scrollbar->SetTotalSize(root_scroll_layer->bounds().height());
+    scrollbar->SetMaximum(root_scroll_layer->max_scroll_offset().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->set_is_impl_only(true);
+
+  return animation.Pass();
+}
+
+static bool StartFadeInAnimation(ScrollbarLayerImpl* 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 = 0; // fmax(0.01, layer->opacity());
+  ScrollbarLayerImpl* scrollbar = layer->ToScrollbarLayer();
+  DCHECK(scrollbar);
+  LayerAnimationController* controller = layer->layer_animation_controller();
+  // TODO() It shouldn't be necessary to manually remove the old animation.

[enne (OOO), 2013/03/12 16:27:37]

TODO(wjmaclean)

[wjmaclean, 2013/03/12 18:25:33]

Done.

(I'm officially going insane ... I clearly remember making this edit, but it
disappeared somehow :-( )

+  if (Animation* animation = controller->GetAnimation(Animation::Opacity))
+    controller->RemoveAnimation(animation->id());
+  controller->AddAnimation(MakePinchZoomFadeAnimation(start_opacity,
+    PinchZoomScrollbar::kDefaultOpacity));
+
+  return layer->HasThumbTexture();

[enne (OOO), 2013/03/12 16:27:37]

I still think this is the wrong way to go about this.  Impl-side animations
should not be responsible for controlling when a layer paints, especially when
that layer is being painted on the main thread.

You should make pinch zoom scrollbars always painted.

Alternatively, you could write some other patch that lets you paint
ScrollbarLayerImpls from the compositor thread on platforms where that's
supported, and then you don't have to worry about this at all.

[wjmaclean, 2013/03/12 18:25:33]

OK, I've devised a way for the PZ scrollbars to always paint on the main thread,
and the method could be re-used in other layers that want to impl-side animate.

+}
+
+void LayerTreeImpl::FadeInPinchZoomScrollbars() {
+  if (!HasPinchZoomScrollbars() || page_scale_factor_ == 1)
+    return;
+
+  bool scrollbars_need_redraw = false;
+  if (!StartFadeInAnimation(PinchZoomScrollbarHorizontal()))
+    scrollbars_need_redraw = true;
+  if (!StartFadeInAnimation(PinchZoomScrollbarVertical()))
+    scrollbars_need_redraw = true;
+
+  if (scrollbars_need_redraw)
+    SetNeedsRedraw();
+}
+
+static void StartFadeOutAnimation(LayerImpl* layer) {
+  float opacity = layer->opacity();
+  if (!opacity)
+    return;
+
+  LayerAnimationController* controller = layer->layer_animation_controller();
+  // TODO(wjmaclean) 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(opacity, 0));
+}
+
+void LayerTreeImpl::FadeOutPinchZoomScrollbars() {
+  if (!HasPinchZoomScrollbars())
+    return;
+
+  StartFadeOutAnimation(PinchZoomScrollbarHorizontal());
+  StartFadeOutAnimation(PinchZoomScrollbarVertical());
+}
+
+bool LayerTreeImpl::HasPinchZoomScrollbars() const {
+  return pinch_zoom_scrollbar_horizontal_layer_id_ != Layer::INVALID_ID &&
+         pinch_zoom_scrollbar_vertical_layer_id_ != Layer::INVALID_ID;
+}
+
+
 } // namespace cc