cc: Do not allow gesture-scrolling 'overflow[-{x|y}]:hidden' layers.

cc/layers/layer_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/layers/layer_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/strings/stringprintf.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/scrollbar_animation_controller.h"
@@ skipping 24 matching lines @@
       mask_layer_id_(-1),
       replica_layer_id_(-1),
       layer_id_(id),
       layer_tree_impl_(tree_impl),
       anchor_point_(0.5f, 0.5f),
       anchor_point_z_(0.f),
       scroll_offset_delegate_(NULL),
       scrollable_(false),
       should_scroll_on_main_thread_(false),
       have_wheel_event_handlers_(false),
+      user_scrollable_horizontal_(true),
+      user_scrollable_vertical_(true),
       background_color_(0),
       stacking_order_changed_(false),
       double_sided_(true),
       layer_property_changed_(false),
       masks_to_bounds_(false),
       contents_opaque_(false),
       opacity_(1.0),
       preserves_3d_(false),
       use_parent_backface_visibility_(false),
       draw_checkerboard_for_missing_tiles_(false),
@@ skipping 279 matching lines @@
   DCHECK(layer_tree_impl()->IsActiveTree());
 
   if (sent_scroll_delta_ == sent_scroll_delta)
     return;
 
   sent_scroll_delta_ = sent_scroll_delta;
 }
 
 gfx::Vector2dF LayerImpl::ScrollBy(gfx::Vector2dF scroll) {
   DCHECK(scrollable());
+  gfx::Vector2dF scroll_hidden;
+  if (!user_scrollable_horizontal_) {
+    scroll_hidden.set_x(scroll.x());
+    scroll.set_x(0.f);
+  }
+  if (!user_scrollable_vertical_) {
+    scroll_hidden.set_y(scroll.y());
+    scroll.set_y(0.f);
+  }
 
   gfx::Vector2dF min_delta = -scroll_offset_;
   gfx::Vector2dF max_delta = max_scroll_offset_ - scroll_offset_;
   // Clamp new_delta so that position + delta stays within scroll bounds.
   gfx::Vector2dF new_delta = (ScrollDelta() + scroll);
   new_delta.SetToMax(min_delta);
   new_delta.SetToMin(max_delta);
-  gfx::Vector2dF unscrolled = ScrollDelta() + scroll - new_delta;
+  gfx::Vector2dF unscrolled =
+      ScrollDelta() + scroll + scroll_hidden - new_delta;
   SetScrollDelta(new_delta);
   return unscrolled;
 }
 
 void LayerImpl::ApplySentScrollDeltasFromAbortedCommit() {
   // Pending tree never has sent scroll deltas
   DCHECK(layer_tree_impl()->IsActiveTree());
 
   // Apply sent scroll deltas to scroll position / scroll delta as if the
   // main thread had applied them and then committed those values.
@@ skipping 80 matching lines @@
     return InputHandler::ScrollIgnored;
   }
 
   if (max_scroll_offset_.x() <= 0 && max_scroll_offset_.y() <= 0) {
     TRACE_EVENT0("cc",
                  "LayerImpl::tryScroll: Ignored. Technically scrollable,"
                  " but has no affordance in either direction.");
     return InputHandler::ScrollIgnored;
   }
 
+  if (!user_scrollable_horizontal_ && !user_scrollable_vertical_) {
+    TRACE_EVENT0("cc",
+                 "LayerImpl::TryScroll: Ignored. User gesture is not allowed"
+                 " to scroll this layer.");
+    return InputHandler::ScrollIgnored;
+  }
+
   return InputHandler::ScrollStarted;
 }
 
 bool LayerImpl::DrawCheckerboardForMissingTiles() const {
   return draw_checkerboard_for_missing_tiles_ &&
       !layer_tree_impl()->settings().background_color_instead_of_checkerboard;
 }
 
 gfx::Rect LayerImpl::LayerRectToContentRect(
     const gfx::RectF& layer_rect) const {
@@ skipping 45 matching lines @@
   layer->SetIsContainerForFixedPositionLayers(
       is_container_for_fixed_position_layers_);
   layer->SetFixedContainerSizeDelta(fixed_container_size_delta_);
   layer->SetPositionConstraint(position_constraint_);
   layer->SetPreserves3d(preserves_3d());
   layer->SetUseParentBackfaceVisibility(use_parent_backface_visibility_);
   layer->SetSublayerTransform(sublayer_transform_);
   layer->SetTransform(transform_);
 
   layer->SetScrollable(scrollable_);
+  layer->set_user_scrollable_horizontal(user_scrollable_horizontal_);
+  layer->set_user_scrollable_vertical(user_scrollable_vertical_);
   layer->SetScrollOffsetAndDelta(
       scroll_offset_, layer->ScrollDelta() - layer->sent_scroll_delta());
   layer->SetSentScrollDelta(gfx::Vector2d());
 
   layer->SetMaxScrollOffset(max_scroll_offset_);
 
   LayerImpl* scroll_parent = NULL;
   if (scroll_parent_)
     scroll_parent = layer->layer_tree_impl()->LayerById(scroll_parent_->id());
 
@@ skipping 778 matching lines @@
 
 size_t LayerImpl::GPUMemoryUsageInBytes() const { return 0; }
 
 scoped_ptr<base::Value> LayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   AsValueInto(state.get());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc