Add viewport scrollbar class to support overlay scrollbars for pinch zoom virtual viewport.

cc/trees/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/trees/layer_tree_host.h"
 
 #include <algorithm>
 #include <stack>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/base/thread.h"
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
+#include "cc/input/inner_viewport_scrollbar.h"
 #include "cc/input/top_controls_manager.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/render_surface.h"
 #include "cc/layers/scrollbar_layer.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_common.h"
@@ skipping 274 matching lines @@
   } else {
     sync_tree->set_hud_layer(NULL);
   }
 
   sync_tree->set_source_frame_number(commit_number());
   sync_tree->set_background_color(background_color_);
   sync_tree->set_has_transparent_background(has_transparent_background_);
 
   sync_tree->FindRootScrollLayer();
 
+  if (settings_.use_pinch_virtual_viewport && page_scale_layer_) {
+    DCHECK(inner_viewport_scroll_layer_);
+    DCHECK(outer_viewport_scroll_layer_);
+    sync_tree->SetPinchViewportLayerIds(page_scale_layer_->id(),
+                                        inner_viewport_scroll_layer_->id(),
+                                        outer_viewport_scroll_layer_->id());
+  }
+
   float page_scale_delta, sent_page_scale_delta;
   if (settings_.impl_side_painting) {
     // Update the delta from the active tree, which may have
     // adjusted its delta prior to the pending tree being created.
     // This code is equivalent to that in LayerTreeImpl::SetPageScaleDelta.
     DCHECK_EQ(1.f, sync_tree->sent_page_scale_delta());
     page_scale_delta = host_impl->active_tree()->page_scale_delta();
     sent_page_scale_delta = host_impl->active_tree()->sent_page_scale_delta();
   } else {
     page_scale_delta = sync_tree->page_scale_delta();
@@ skipping 210 matching lines @@
   root_layer_ = root_layer;
   if (root_layer_.get())
     root_layer_->SetLayerTreeHost(this);
 
   if (hud_layer_.get())
     hud_layer_->RemoveFromParent();
 
   SetNeedsFullTreeSync();
 }
 
+static void SetupInnerViewportScrollbar(Layer* parent,
+                                        scoped_refptr<Layer>& scrollbar,
+                                        scoped_refptr<Layer> scroll_layer,
+                                        scoped_refptr<Layer> clip_layer,
+                                        ScrollbarOrientation orientation) {
+  int scrollbar_thickness =
+      orientation == HORIZONTAL ? parent->bounds().height()
+                                : parent->bounds().width();
+  scrollbar = ScrollbarLayer::Create(
+      make_scoped_ptr(new InnerViewportScrollbar(
+          scroll_layer, clip_layer, orientation, scrollbar_thickness))
+          .PassAs<Scrollbar>(),
+      scroll_layer->id());
+  parent->RemoveAllChildren();
+  parent->AddChild(scrollbar);
+  scrollbar->SetBounds(parent->bounds());
+  scrollbar->SetIsDrawable(true);
+}
+
+void LayerTreeHost::RegisterPinchViewportLayers(
+      scoped_refptr<Layer> inner_viewport_clip_layer,
+      scoped_refptr<Layer> page_scale_layer,
+      scoped_refptr<Layer> inner_viewport_scroll_layer,
+      scoped_refptr<Layer> outer_viewport_scroll_layer,
+      scoped_refptr<Layer> inner_viewport_horizontal_scrollbar_layer,
+      scoped_refptr<Layer> inner_viewport_vertical_scrollbar_layer) {
+  inner_viewport_clip_layer_ = inner_viewport_clip_layer;
+  page_scale_layer_ = page_scale_layer;
+  inner_viewport_scroll_layer_ = inner_viewport_scroll_layer;
+  outer_viewport_scroll_layer_ = outer_viewport_scroll_layer;
+
+  if (inner_viewport_horizontal_scrollbar_layer) {
+    SetupInnerViewportScrollbar(inner_viewport_horizontal_scrollbar_layer,
+        inner_viewport_horizontal_scrollbar_layer_,
+        inner_viewport_scroll_layer,
+        inner_viewport_clip_layer,
+        HORIZONTAL);
+  } else {
+    inner_viewport_horizontal_scrollbar_layer_ = nullptr;
+  }
+
+  if (inner_viewport_vertical_scrollbar_layer) {
+    SetupInnerViewportScrollbar(inner_viewport_vertical_scrollbar_layer,
+        inner_viewport_vertical_scrollbar_layer_,
+        inner_viewport_scroll_layer,
+        inner_viewport_clip_layer,
+        VERTICAL);
+  } else {
+    inner_viewport_vertical_scrollbar_layer_ = nullptr;
+  }
+}
+
 void LayerTreeHost::SetDebugState(const LayerTreeDebugState& debug_state) {
   LayerTreeDebugState new_debug_state =
       LayerTreeDebugState::Unite(settings_.initial_debug_state, debug_state);
 
   if (LayerTreeDebugState::Equal(debug_state_, new_debug_state))
     return;
 
   debug_state_ = new_debug_state;
 
   rendering_stats_instrumentation_->set_record_rendering_stats(
@@ skipping 153 matching lines @@
 void LayerTreeHost::UpdateLayers(Layer* root_layer,
                                  ResourceUpdateQueue* queue) {
   TRACE_EVENT1("cc", "LayerTreeHost::UpdateLayers",
                "commit_number", commit_number());
 
   LayerList update_list;
   {
     UpdateHudLayer();
 
     Layer* root_scroll = FindFirstScrollableLayer(root_layer);
+    Layer* page_scale_layer =
+        page_scale_layer_ ? page_scale_layer_.get() : root_scroll;
 
     TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers::CalcDrawProps");
     LayerTreeHostCommon::CalculateDrawProperties(
         root_layer,
         device_viewport_size(),
         gfx::Transform(),
         device_scale_factor_,
         page_scale_factor_,
-        root_scroll,
+        page_scale_layer,
         GetRendererCapabilities().max_texture_size,
         settings_.can_use_lcd_text,
         settings_.layer_transforms_should_scale_layer_contents,
         &update_list);
 
     if (total_frames_used_for_lcd_text_metrics_ <=
         kTotalFramesToUseForLCDTextMetrics) {
       LayerTreeHostCommon::CallFunctionForSubtree<
           CalculateLCDTextMetricsFunctor, Layer>(root_layer);
       total_frames_used_for_lcd_text_metrics_++;
@@ skipping 341 matching lines @@
     bool start_ready_animations = true;
     (*iter).second->UpdateState(start_ready_animations, NULL);
   }
 }
 
 skia::RefPtr<SkPicture> LayerTreeHost::CapturePicture() {
   return proxy_->CapturePicture();
 }
 
 }  // namespace cc