Seperate horizontal and vertical overscrolling

content/browser/web_contents/aura/window_slider.cc

 // Copyright (c) 2013 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 "content/browser/web_contents/aura/window_slider.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 40 matching lines @@
 }  // namespace
 
 WindowSlider::WindowSlider(Delegate* delegate,
                            aura::Window* event_window,
                            aura::Window* owner)
     : delegate_(delegate),
       event_window_(event_window),
       owner_(owner),
       delta_x_(0.f),
       weak_factory_(this),
-      min_start_threshold_(content::GetOverscrollConfig(
-          content::OVERSCROLL_CONFIG_MIN_THRESHOLD_START)),
+      horiz_start_threshold_(content::GetOverscrollConfig(
+          content::OVERSCROLL_CONFIG_HORIZ_THRESHOLD_START)),
       complete_threshold_(content::GetOverscrollConfig(
           content::OVERSCROLL_CONFIG_HORIZ_THRESHOLD_COMPLETE)) {
   event_window_->AddPreTargetHandler(this);
 
   event_window_->AddObserver(this);
   owner_->AddObserver(this);
 }
 
 WindowSlider::~WindowSlider() {
   if (event_window_) {
     event_window_->RemovePreTargetHandler(this);
     event_window_->RemoveObserver(this);
   }
   if (owner_)
     owner_->RemoveObserver(this);
   delegate_->OnWindowSliderDestroyed();
 }
 
 void WindowSlider::ChangeOwner(aura::Window* new_owner) {
   if (owner_)
     owner_->RemoveObserver(this);
   owner_ = new_owner;
   if (owner_) {
     owner_->AddObserver(this);
     UpdateForScroll(0.f, 0.f);
   }
 }
 
 bool WindowSlider::IsSlideInProgress() const {
-  return fabs(delta_x_) >= min_start_threshold_ || slider_.get() ||
+  return fabs(delta_x_) >= horiz_start_threshold_ || slider_.get() ||
       weak_factory_.HasWeakPtrs();
 }
 
 void WindowSlider::SetupSliderLayer() {
   ui::Layer* parent = owner_->layer()->parent();
   parent->Add(slider_.get());
   if (delta_x_ < 0)
     parent->StackAbove(slider_.get(), owner_->layer());
   else
     parent->StackBelow(slider_.get(), owner_->layer());
   slider_->SetBounds(owner_->layer()->bounds());
   slider_->SetVisible(true);
 }
 
 void WindowSlider::UpdateForScroll(float x_offset, float y_offset) {
   float old_delta = delta_x_;
   delta_x_ += x_offset;
-  if (fabs(delta_x_) < min_start_threshold_ && !slider_.get())
+  if (fabs(delta_x_) < horiz_start_threshold_ && !slider_.get())
     return;
 
   if ((old_delta < 0 && delta_x_ > 0) ||
       (old_delta > 0 && delta_x_ < 0)) {
     slider_.reset();
     shadow_.reset();
   }
 
   float translate = 0.f;
   ui::Layer* translate_layer = NULL;
 
   if (!slider_.get()) {
     slider_.reset(delta_x_ < 0 ? delegate_->CreateFrontLayer() :
                                  delegate_->CreateBackLayer());
     if (!slider_.get())
       return;
     SetupSliderLayer();
   }
 
-  if (delta_x_ <= -min_start_threshold_) {
+  if (delta_x_ <= -horiz_start_threshold_) {
     translate = owner_->bounds().width() +
-        std::max(delta_x_ + min_start_threshold_,
+        std::max(delta_x_ + horiz_start_threshold_,
                  static_cast<float>(-owner_->bounds().width()));
     translate_layer = slider_.get();
-  } else if (delta_x_ >= min_start_threshold_) {
-    translate = std::min(delta_x_ - min_start_threshold_,
+  } else if (delta_x_ >= horiz_start_threshold_) {
+    translate = std::min(delta_x_ - horiz_start_threshold_,
                          static_cast<float>(owner_->bounds().width()));
     translate_layer = owner_->layer();
   } else {
     return;
   }
 
   if (!shadow_.get())
     shadow_.reset(new ShadowLayerDelegate(translate_layer));
 
   gfx::Transform transform;
   transform.Translate(translate, 0);
   translate_layer->SetTransform(transform);
 }
 
 void WindowSlider::UpdateForFling(float x_velocity, float y_velocity) {
   if (!slider_.get())
     return;
 
   int width = owner_->bounds().width();
-  float ratio = (fabs(delta_x_) - min_start_threshold_) / width;
+  float ratio = (fabs(delta_x_) - horiz_start_threshold_) / width;
   if (ratio < complete_threshold_) {
     ResetScroll();
     return;
   }
 
   ui::Layer* sliding = delta_x_ < 0 ? slider_.get() : owner_->layer();
   ui::ScopedLayerAnimationSettings settings(sliding->GetAnimator());
   settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   settings.SetTweenType(ui::Tween::EASE_OUT);
@@ skipping 127 matching lines @@
   } else if (window == owner_) {
     window->RemoveObserver(this);
     owner_ = NULL;
     delete this;
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace content