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

cc/layer_tree_host.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_host.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "cc/animation_registrar.h"
 #include "cc/heads_up_display_layer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_tree_host_client.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/math_util.h"
 #include "cc/occlusion_tracker.h"
 #include "cc/overdraw_metrics.h"
+#include "cc/pinch_zoom_scrollbar.h"
+#include "cc/pinch_zoom_scrollbar_geometry.h"
+#include "cc/pinch_zoom_scrollbar_painter.h"
 #include "cc/prioritized_resource_manager.h"
+#include "cc/scrollbar_layer.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/switches.h"
 #include "cc/thread.h"
 #include "cc/thread_proxy.h"
 #include "cc/top_controls_manager.h"
 #include "cc/tree_synchronizer.h"
 
 namespace {
 static int s_num_layer_tree_instances;
 }
@@ skipping 284 matching lines @@
   host_impl->SetDeviceScaleFactor(device_scale_factor_);
   host_impl->SetDebugState(debug_state_);
 
   DCHECK(!sync_tree->ViewportSizeInvalid());
 
   if (new_impl_tree_has_no_evicted_resources) {
     if (sync_tree->ContentsTexturesPurged())
       sync_tree->ResetContentsTexturesPurged();
   }
 
+  sync_tree->SetPinchZoomHorizontalLayerId(
+      pinch_zoom_scrollbar_horizontal_ ?
+          pinch_zoom_scrollbar_horizontal_->id() : Layer::INVALID_ID);
+
+  sync_tree->SetPinchZoomVerticalLayerId(
+      pinch_zoom_scrollbar_vertical_ ?
+          pinch_zoom_scrollbar_vertical_->id() : Layer::INVALID_ID);
+
   if (!settings_.implSidePainting) {
     // If we're not in impl-side painting, the tree is immediately
     // considered active.
     sync_tree->DidBecomeActive();
   }
 
   if (debug_state_.continuousPainting)
     host_impl->SavePaintTime(rendering_stats_.totalPaintTime, commit_number());
 
   commit_number_++;
 }
 
+void LayerTreeHost::SetPinchZoomScrollbarsBoundsAndPosition()
+{
+    if (!pinch_zoom_scrollbar_horizontal_ || !pinch_zoom_scrollbar_vertical_)
+        return;
+
+    gfx::Size size = layout_viewport_size();
+    int track_width = PinchZoomScrollbarGeometry::kTrackWidth;
+
+    pinch_zoom_scrollbar_horizontal_->SetBounds(
+        gfx::Size(size.width() - track_width, track_width));
+    pinch_zoom_scrollbar_horizontal_->SetPosition(
+        gfx::PointF(0, size.height() - track_width));
+
+    pinch_zoom_scrollbar_vertical_->SetBounds(
+        gfx::Size(track_width, size.height() - track_width));
+    pinch_zoom_scrollbar_vertical_->SetPosition(
+        gfx::PointF(size.width() - track_width, 0));
+}
+
+static scoped_refptr<ScrollbarLayer> CreatePinchZoomScrollbar(
+    WebKit::WebScrollbar::Orientation orientation, LayerTreeHost* owner)
+{
+  scoped_refptr<ScrollbarLayer> scrollbar_layer = ScrollbarLayer::Create(
+      make_scoped_ptr(
+          new PinchZoomScrollbar(orientation, owner))
+            .PassAs<WebKit::WebScrollbar>(),
+      scoped_ptr<ScrollbarThemePainter>(new PinchZoomScrollbarPainter).Pass(),
+      scoped_ptr<WebKit::WebScrollbarThemeGeometry>(
+          new PinchZoomScrollbarGeometry).Pass(),
+      Layer::PINCH_ZOOM_ROOT_SCROLL_LAYER_ID);
+  scrollbar_layer->SetIsDrawable(true);
+  scrollbar_layer->SetOpacity(0.f);
+  return scrollbar_layer;
+}
+
+void LayerTreeHost::CreateAndAddPinchZoomScrollbars()
+{
+  bool needs_properties_updated = false;
+
+  if (!pinch_zoom_scrollbar_horizontal_ || !pinch_zoom_scrollbar_vertical_) {
+    pinch_zoom_scrollbar_horizontal_ =
+        CreatePinchZoomScrollbar(WebKit::WebScrollbar::Horizontal, this);
+    pinch_zoom_scrollbar_vertical_ =
+        CreatePinchZoomScrollbar( WebKit::WebScrollbar::Vertical, this);
+    needs_properties_updated = true;
+  }
+
+  DCHECK(pinch_zoom_scrollbar_horizontal_ && pinch_zoom_scrollbar_vertical_);
+
+  if (!pinch_zoom_scrollbar_horizontal_->parent())
+      root_layer_->AddChild(pinch_zoom_scrollbar_horizontal_);
+
+  if (!pinch_zoom_scrollbar_vertical_->parent())
+      root_layer_->AddChild(pinch_zoom_scrollbar_vertical_);
+
+  if (needs_properties_updated)
+      SetPinchZoomScrollbarsBoundsAndPosition();
+}
+
 void LayerTreeHost::WillCommit() {
   client_->willCommit();
+
+  if (settings().usePinchZoomScrollbars)
+    CreateAndAddPinchZoomScrollbars();
 }
 
 void LayerTreeHost::UpdateHudLayer() {
   if (debug_state_.showHudInfo()) {
     if (!hud_layer_)
       hud_layer_ = HeadsUpDisplayLayer::Create();
 
     if (root_layer_ && !hud_layer_->parent())
       root_layer_->AddChild(hud_layer_);
   } else if (hud_layer_) {
@@ skipping 108 matching lines @@
 
   if (root_layer_)
     root_layer_->SetLayerTreeHost(NULL);
   root_layer_ = root_layer;
   if (root_layer_)
     root_layer_->SetLayerTreeHost(this);
 
   if (hud_layer_)
     hud_layer_->RemoveFromParent();
 
+  if (pinch_zoom_scrollbar_horizontal_)
+    pinch_zoom_scrollbar_horizontal_->RemoveFromParent();
+
+  if (pinch_zoom_scrollbar_vertical_)
+    pinch_zoom_scrollbar_vertical_->RemoveFromParent();
+
   SetNeedsFullTreeSync();
 }
 
 void LayerTreeHost::SetDebugState(const LayerTreeDebugState& debug_state) {
   LayerTreeDebugState new_debug_state =
       LayerTreeDebugState::unite(settings_.initialDebugState, debug_state);
 
   if (LayerTreeDebugState::equal(debug_state_, new_debug_state))
     return;
 
   debug_state_ = new_debug_state;
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetViewportSize(gfx::Size layout_viewport_size,
                                     gfx::Size device_viewport_size) {
   if (layout_viewport_size == layout_viewport_size_ &&
       device_viewport_size == device_viewport_size_)
     return;
 
   layout_viewport_size_ = layout_viewport_size;
   device_viewport_size_ = device_viewport_size;
 
+  SetPinchZoomScrollbarsBoundsAndPosition();
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetPageScaleFactorAndLimits(float page_scale_factor,
                                                 float min_page_scale_factor,
                                                 float max_page_scale_factor) {
   if (page_scale_factor == page_scale_factor_ &&
       min_page_scale_factor == min_page_scale_factor_ &&
       max_page_scale_factor == max_page_scale_factor_)
     return;
@@ skipping 71 matching lines @@
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     Layer* found = FindFirstScrollableLayer(layer->children()[i].get());
     if (found)
       return found;
   }
 
   return NULL;
 }
 
+const Layer* LayerTreeHost::RootScrollLayer() const {
+  return FindFirstScrollableLayer(root_layer_.get());
+}
+
 void LayerTreeHost::UpdateLayers(Layer* root_layer,
                                  ResourceUpdateQueue* queue) {
   TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers");
 
   LayerList update_list; {
     Layer* root_scroll = FindFirstScrollableLayer(root_layer);
     if (root_scroll)
       root_scroll->SetImplTransform(impl_transform_);
 
     UpdateHudLayer();
@@ skipping 342 matching lines @@
     SetAnimationEventsRecursive(events,
                                 layer->children()[child_index].get(),
                                 wall_clock_time);
 }
 
 skia::RefPtr<SkPicture> LayerTreeHost::CapturePicture() {
   return proxy_->CapturePicture();
 }
 
 }  // namespace cc