Update from https://crrev.com/314320

cc/trees/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/trees/layer_tree_impl.h"
 
 #include <limits>
 #include <set>
 
-#include "base/debug/trace_event.h"
-#include "base/debug/trace_event_argument.h"
+#include "base/trace_event/trace_event.h"
+#include "base/trace_event/trace_event_argument.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/animation/scrollbar_animation_controller_linear_fade.h"
 #include "cc/animation/scrollbar_animation_controller_thinning.h"
 #include "cc/base/math_util.h"
 #include "cc/base/synced_property.h"
 #include "cc/base/util.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/input/page_scale_animation.h"
@@ skipping 21 matching lines @@
                                  LayerScrollOffsetDelegate* delegate,
                                  LayerTreeImpl* layer_tree)
       : layer_(layer), delegate_(delegate), layer_tree_impl_(layer_tree) {}
   virtual ~LayerScrollOffsetDelegateProxy() {}
 
   gfx::ScrollOffset last_set_scroll_offset() const {
     return last_set_scroll_offset_;
   }
 
   // LayerScrollOffsetDelegate implementation.
-  void SetTotalScrollOffset(const gfx::ScrollOffset& new_offset) override {
+  void SetCurrentScrollOffset(const gfx::ScrollOffset& new_offset) override {
     last_set_scroll_offset_ = new_offset;
   }
 
-  gfx::ScrollOffset GetTotalScrollOffset() override {
+  gfx::ScrollOffset GetCurrentScrollOffset() override {
     return layer_tree_impl_->GetDelegatedScrollOffset(layer_);
   }
 
   bool IsExternalFlingActive() const override {
     return delegate_->IsExternalFlingActive();
   }
 
   void Update() const override {
     layer_tree_impl_->UpdateScrollOffsetDelegate();
   }
@@ skipping 79 matching lines @@
 }
 
 LayerImpl* LayerTreeImpl::OuterViewportScrollLayer() const {
   return outer_viewport_scroll_layer_;
 }
 
 gfx::ScrollOffset LayerTreeImpl::TotalScrollOffset() const {
   gfx::ScrollOffset offset;
 
   if (inner_viewport_scroll_layer_)
-    offset += inner_viewport_scroll_layer_->TotalScrollOffset();
+    offset += inner_viewport_scroll_layer_->CurrentScrollOffset();
 
   if (outer_viewport_scroll_layer_)
-    offset += outer_viewport_scroll_layer_->TotalScrollOffset();
+    offset += outer_viewport_scroll_layer_->CurrentScrollOffset();
 
   return offset;
 }
 
 gfx::ScrollOffset LayerTreeImpl::TotalMaxScrollOffset() const {
   gfx::ScrollOffset offset;
 
   if (inner_viewport_scroll_layer_)
     offset += inner_viewport_scroll_layer_->MaxScrollOffset();
 
   if (outer_viewport_scroll_layer_)
     offset += outer_viewport_scroll_layer_->MaxScrollOffset();
 
   return offset;
 }
-gfx::Vector2dF LayerTreeImpl::TotalScrollDelta() const {
-  DCHECK(inner_viewport_scroll_layer_);
-  gfx::Vector2dF delta = inner_viewport_scroll_layer_->ScrollDelta();
-
-  if (outer_viewport_scroll_layer_)
-    delta += outer_viewport_scroll_layer_->ScrollDelta();
-
-  return delta;
-}
 
 scoped_ptr<LayerImpl> LayerTreeImpl::DetachLayerTree() {
   // Clear all data structures that have direct references to the layer tree.
   scrolling_layer_id_from_previous_tree_ =
     currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0;
   if (inner_viewport_scroll_layer_)
     inner_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
   if (outer_viewport_scroll_layer_)
     outer_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
   inner_viewport_scroll_delegate_proxy_ = nullptr;
@@ skipping 193 matching lines @@
   set_needs_update_draw_properties();
 
   if (root_layer_scroll_offset_delegate_) {
     root_layer_scroll_offset_delegate_->UpdateRootLayerState(
         TotalScrollOffset(), TotalMaxScrollOffset(), ScrollableSize(),
         current_page_scale_factor(), min_page_scale_factor_,
         max_page_scale_factor_);
   }
 
   ForceScrollbarParameterUpdateAfterScaleChange(page_scale_layer());
+
+  HideInnerViewportScrollbarsIfNearMinimumScale();
+}
+
+void LayerTreeImpl::HideInnerViewportScrollbarsIfNearMinimumScale() {
+  if (!InnerViewportContainerLayer())
+    return;
+
+  LayerImpl::ScrollbarSet* scrollbars =
+      InnerViewportContainerLayer()->scrollbars();
+
+  if (!scrollbars)
+    return;
+
+  for (LayerImpl::ScrollbarSet::iterator it = scrollbars->begin();
+       it != scrollbars->end();
+       ++it) {
+    ScrollbarLayerImplBase* scrollbar = *it;
+    float minimum_scale_to_show_at =
+        min_page_scale_factor() * settings().scrollbar_show_scale_threshold;
+    scrollbar->SetHideLayerAndSubtree(
+        current_page_scale_factor() < minimum_scale_to_show_at);
+  }
 }
 
 SyncedProperty<ScaleGroup>* LayerTreeImpl::page_scale_factor() {
   return page_scale_factor_.get();
 }
 
 const SyncedProperty<ScaleGroup>* LayerTreeImpl::page_scale_factor() const {
   return page_scale_factor_.get();
 }
 
@@ skipping 30 matching lines @@
   top_controls_delta_ -= sent_top_controls_delta_;
   sent_top_controls_delta_ = 0.f;
 
   if (!root_layer())
     return;
 
   LayerTreeHostCommon::CallFunctionForSubtree(
       root_layer(), base::Bind(&ApplySentScrollDeltasFromAbortedCommitTo));
 }
 
-static void ApplyScrollDeltasSinceBeginMainFrameTo(LayerImpl* layer) {
-  layer->ApplyScrollDeltasSinceBeginMainFrame();
-}
-
-void LayerTreeImpl::ApplyScrollDeltasSinceBeginMainFrame() {
-  DCHECK(IsPendingTree());
-  if (!root_layer())
-    return;
-
-  LayerTreeHostCommon::CallFunctionForSubtree(
-      root_layer(), base::Bind(&ApplyScrollDeltasSinceBeginMainFrameTo));
-}
-
 void LayerTreeImpl::SetViewportLayersFromIds(
     int overscroll_elasticity_layer_id,
     int page_scale_layer_id,
     int inner_viewport_scroll_layer_id,
     int outer_viewport_scroll_layer_id) {
   overscroll_elasticity_layer_ = LayerById(overscroll_elasticity_layer_id);
   page_scale_layer_ = LayerById(page_scale_layer_id);
   DCHECK(page_scale_layer_);
 
   inner_viewport_scroll_layer_ =
       LayerById(inner_viewport_scroll_layer_id);
   DCHECK(inner_viewport_scroll_layer_);
 
   outer_viewport_scroll_layer_ =
       LayerById(outer_viewport_scroll_layer_id);
   DCHECK(outer_viewport_scroll_layer_ ||
          outer_viewport_scroll_layer_id == Layer::INVALID_ID);
 
+  HideInnerViewportScrollbarsIfNearMinimumScale();
+
   if (!root_layer_scroll_offset_delegate_)
     return;
 
   inner_viewport_scroll_delegate_proxy_ = make_scoped_ptr(
       new LayerScrollOffsetDelegateProxy(inner_viewport_scroll_layer_,
                                          root_layer_scroll_offset_delegate_,
                                          this));
 
   if (outer_viewport_scroll_layer_)
     outer_viewport_scroll_delegate_proxy_ = make_scoped_ptr(
@@ skipping 476 matching lines @@
     if (outer_viewport_scroll_layer_) {
       outer_viewport_scroll_delegate_proxy_ = make_scoped_ptr(
           new LayerScrollOffsetDelegateProxy(OuterViewportScrollLayer(),
                                              root_layer_scroll_offset_delegate_,
                                              this));
       outer_viewport_scroll_layer_->SetScrollOffsetDelegate(
           outer_viewport_scroll_delegate_proxy_.get());
     }
 
     if (inner_viewport_scroll_layer_)
+      inner_viewport_scroll_layer_->RefreshFromScrollDelegate();
+    if (outer_viewport_scroll_layer_)
+      outer_viewport_scroll_layer_->RefreshFromScrollDelegate();
+
+    if (inner_viewport_scroll_layer_)
       UpdateScrollOffsetDelegate();
   }
 }
 
 void LayerTreeImpl::OnRootLayerDelegatedScrollOffsetChanged() {
   DCHECK(root_layer_scroll_offset_delegate_);
   if (inner_viewport_scroll_layer_) {
-    inner_viewport_scroll_layer_->DidScroll();
+    inner_viewport_scroll_layer_->RefreshFromScrollDelegate();
   }
   if (outer_viewport_scroll_layer_) {
-    outer_viewport_scroll_layer_->DidScroll();
+    outer_viewport_scroll_layer_->RefreshFromScrollDelegate();
   }
 }
 
 void LayerTreeImpl::UpdateScrollOffsetDelegate() {
   DCHECK(InnerViewportScrollLayer());
   DCHECK(!OuterViewportScrollLayer() || outer_viewport_scroll_delegate_proxy_);
   DCHECK(root_layer_scroll_offset_delegate_);
 
   gfx::ScrollOffset offset =
       inner_viewport_scroll_delegate_proxy_->last_set_scroll_offset();
@@ skipping 403 matching lines @@
   // At this point, we think the point does hit the touch event handler region
   // on the layer, but we need to walk up the parents to ensure that the layer
   // was not clipped in such a way that the hit point actually should not hit
   // the layer.
   if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 
+struct FindWheelEventLayerFunctor {
+  bool operator()(LayerImpl* layer) const {
+    return layer->have_wheel_event_handlers();
+  }
+};
+
+LayerImpl* LayerTreeImpl::FindLayerWithWheelHandlerThatIsHitByPoint(
+    const gfx::PointF& screen_space_point) {
+  if (!root_layer())
+    return NULL;
+  if (!UpdateDrawProperties())
+    return NULL;
+  FindWheelEventLayerFunctor func;
+  FindClosestMatchingLayerDataForRecursion data_for_recursion;
+  FindClosestMatchingLayer(screen_space_point, root_layer(), func,
+                           &data_for_recursion);
+  return data_for_recursion.closest_match;
+}
+
 struct FindTouchEventLayerFunctor {
   bool operator()(LayerImpl* layer) const {
     return LayerHasTouchEventHandlersAt(screen_space_point, layer);
   }
   const gfx::PointF screen_space_point;
 };
 
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPointInTouchHandlerRegion(
     const gfx::PointF& screen_space_point) {
   if (!root_layer())
@@ skipping 104 matching lines @@
     scoped_ptr<PendingPageScaleAnimation> pending_animation) {
   pending_page_scale_animation_ = pending_animation.Pass();
 }
 
 scoped_ptr<PendingPageScaleAnimation>
     LayerTreeImpl::TakePendingPageScaleAnimation() {
   return pending_page_scale_animation_.Pass();
 }
 
 }  // namespace cc