overscroll: Introduce some prefs that can be configured in chrome://gesture

BUG=160668

Review URL: https://codereview.chromium.org/11413098

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@170145 0039d316-1c4b-4281-b951-d872f2087c98

11 files changed, 391 insertions, 117 deletions

diff --git a/chrome/browser/resources/gesture_config.js b/chrome/browser/resources/gesture_config.js
index 37d75d2..25e9ce6 100644
--- a/chrome/browser/resources/gesture_config.js
+++ b/chrome/browser/resources/gesture_config.js
@@ -8,17 +8,129 @@
 var $ = function(id) { return document.getElementById(id); };
 
 /**
- * WebUI for configuring gesture.* preference values used by
- * Chrome's gesture recognition system.
+ * A generic WebUI for configuring preference values used by Chrome's gesture
+ * recognition systems.
+ * @param {string} prefix The prefix for the configuration fields.
+ * @param {object} fields An array of fields that contain the name of the pref
+ *    and user-visible labels.
  */
-var gesture_config = (function() {
-  'use strict';
+function GeneralConfig(prefix, fields) {
+  this.prefix = prefix;
+  this.fields = fields;
+}
+
+GeneralConfig.prototype = {
+  /**
+   * Sets up the form for configuring all the preference values.
+   */
+  buildAll: function() {
+    this.buildForm();
+    this.loadForm();
+    this.initForm();
+  },
+
+  /**
+   * Dynamically builds web-form based on the list of preferences.
+   */
+  buildForm: function() {
+    var buf = [];
+
+    for (var i = 0; i < this.fields.length; i++) {
+      var field = this.fields[i];
+
+      var row = $('gesture-form-row').cloneNode(true);
+      var label = row.querySelector('.row-label');
+      var input = row.querySelector('.row-input');
+      var units = row.querySelector('.row-units');
+
+      label.setAttribute('for', field.key);
+      label.textContent = field.label;
+      input.id = field.key;
+      input.min = field.min || 0;
+
+      if (field.max) input.max = field.max;
+      if (field.step) input.step = field.step;
+
+      $('gesture-form').appendChild(row);
+      if (field.units)
+        units.innerHTML = field.units;
+    }
+  },
+
+  /**
+   * Initializes the form by adding 'onChange' listeners to all fields.
+   */
+  initForm: function() {
+    for (var i = 0; i < this.fields.length; i++) {
+      var field = this.fields[i];
+      var config = this;
+      $(field.key).onchange = (function(key) {
+        config.setPreferenceValue(key, $(key).value);
+      }).bind(null, field.key);
+    }
+  },
+
+  /**
+   * Requests preference values for all the relevant fields.
+   */
+  loadForm: function() {
+    for (var i = 0; i < this.fields.length; i++)
+      this.getPreferenceValue(this.fields[i].key);
+  },
+
+  /**
+   * Handles processing of "Reset" button.
+   * Causes all form values to be updated based on current preference values.
+   * @return {bool} Returns false.
+   */
+  onReset: function() {
+    for (var i = 0; i < this.fields.length; i++) {
+      var field = this.fields[i];
+      this.resetPreferenceValue(field.key);
+    }
+    return false;
+  },
+
+  /**
+   * Requests a preference setting's value.
+   * This method is asynchronous; the result is provided by a call to
+   * getPreferenceValueResult.
+   * @param {string} prefName The name of the preference value being requested.
+   */
+  getPreferenceValue: function(prefName) {
+    chrome.send('getPreferenceValue', [this.prefix + prefName]);
+  },
 
+  /**
+   * Sets a preference setting's value.
+   * @param {string} prefName The name of the preference value being set.
+   * @param {value} value The value to be associated with prefName.
+   */
+  setPreferenceValue: function(prefName, value) {
+    chrome.send('setPreferenceValue',
+        [this.prefix + prefName, parseFloat(value)]);
+  },
+
+  /**
+   * Resets a preference to its default value and get that callback
+   * to getPreferenceValueResult with the new value of the preference.
+   * @param {string} prefName The name of the requested preference.
+   */
+  resetPreferenceValue: function(prefName) {
+    chrome.send('resetPreferenceValue', [this.prefix + prefName]);
+  }
+};
+
+/**
+ * Returns a GeneralConfig for configuring gestures.* preferences.
+ * @return {object} A GeneralConfig object.
+ */
+function GestureConfig() {
   /** Common prefix of gesture preferences. **/
   /** @const */ var GESTURE_PREFIX = 'gesture.';
 
   /** List of fields used to dynamically build form. **/
-  var FIELDS = [
+  var GESTURE_FIELDS = [
     {
       key: 'long_press_time_in_seconds',
       label: 'Long Press Time',
@@ -135,56 +247,67 @@ var gesture_config = (function() {
     }
   ];
 
-  /**
-   * Dynamically builds web-form based on FIELDS list.
-   * @return {string} The form's HTML.
-   */
-  function buildForm() {
-    var buf = [];
-
-    for (var i = 0; i < FIELDS.length; i++) {
-      var field = FIELDS[i];
+  return new GeneralConfig(GESTURE_PREFIX, GESTURE_FIELDS);
+}
 
-      var row = $('gesture-form-row').cloneNode(true);
-      var label = row.querySelector('.row-label');
-      var input = row.querySelector('.row-input');
-      var units = row.querySelector('.row-units');
+/**
+ * Returns a GeneralConfig for configuring overscroll.* preferences.
+ * @return {object} A GeneralConfig object.
+ */
+function OverscrollConfig() {
+  var OVERSCROLL_PREFIX = 'overscroll.';
 
-      row.id = '';
-      label.setAttribute('for', field.key);
-      label.textContent = field.label;
-      input.id = field.key;
-      input.min = field.min || 0;
+  var OVERSCROLL_FIELDS = [
+    {
+      key: 'horizontal_threshold_complete',
+      label: 'Complete when overscrolled (horizontal)',
+      units: '%'
+    },
+    {
+      key: 'vertical_threshold_complete',
+      label: 'Complete when overscrolled (vertical)',
+      units: '%'
+    },
+    {
+      key: 'minimum_threshold_start',
+      label: 'Start overscroll gesture after scrolling',
+      units: 'pixels'
+    },
+    {
+      key: 'horizontal_resist_threshold',
+      label: 'Start resisting overscroll after (horizontal)',
+      units: 'pixels'
+    },
+    {
+      key: 'vertical_resist_threshold',
+      label: 'Start resisting overscroll after (vertical)',
+      units: 'pixels'
+    },
+  ];
 
-      if (field.max) input.max = field.max;
-      if (field.step) input.step = field.step;
+  return new GeneralConfig(OVERSCROLL_PREFIX, OVERSCROLL_FIELDS);
+}
 
-      $('gesture-form').appendChild(row);
-      if (field.units)
-        units.innerHTML = field.units;
-    }
-  }
+/**
+ * WebUI instance for configuring gesture.* and overscroll.* preference values
+ * used by Chrome's gesture recognition system.
+ */
+var gesture_config = (function() {
 
   /**
-   * Initialize the form by adding 'onChange' listeners to all fields.
+   * Build and initialize the gesture configuration form.
    */
-  function initForm() {
-    for (var i = 0; i < FIELDS.length; i++) {
-      var field = FIELDS[i];
-      $(field.key).onchange = (function(key) {
-        setPreferenceValue(key, $(key).value);
-      }).bind(null, field.key);
-    }
-  }
+  function initialize() {
+    var g = GestureConfig();
+    g.buildAll();
 
-  /**
-   * Request a preference setting's value.
-   * This method is asynchronous; the result is provided by a call to
-   * getPreferenceValueResult.
-   * @param {string} prefName The name of the preference value being requested.
-   */
-  function getPreferenceValue(prefName) {
-    chrome.send('getPreferenceValue', [GESTURE_PREFIX + prefName]);
+    var o = OverscrollConfig();
+    o.buildAll();
+
+    $('reset-button').onclick = function() {
+      g.onReset();
+      o.onReset();
+    };
   }
 
   /**
@@ -197,54 +320,6 @@ var gesture_config = (function() {
     $(prefName).value = value;
   }
 
-  /**
-   * Set a preference setting's value.
-   * @param {string} prefName The name of the preference value being set.
-   * @param {value} value The value to be associated with prefName.
-   */
-  function setPreferenceValue(prefName, value) {
-    chrome.send(
-        'setPreferenceValue',
-        [GESTURE_PREFIX + prefName, parseFloat(value)]);
-  }
-
-  /**
-   * Reset a preference to its default value and get that callback
-   * to getPreferenceValueResult with the new value of the preference.
-   * @param {string} prefName The name of the requested preference.
-   */
-  function resetPreferenceValue(prefName) {
-    chrome.send('resetPreferenceValue', [GESTURE_PREFIX + prefName]);
-  }
-
-  /**
-   * Handle processing of "Reset" button.
-   * Causes off form values to be updated based on current preference values.
-   */
-  function onReset() {
-    for (var i = 0; i < FIELDS.length; i++) {
-      var field = FIELDS[i];
-      resetPreferenceValue(field.key);
-    }
-    return false;
-  }
-
-  function loadForm() {
-    for (var i = 0; i < FIELDS.length; i++)
-      getPreferenceValue(FIELDS[i].key);
-  }
-
-  /**
-   * Build and initialize the gesture configuration form.
-   */
-  function initialize() {
-    buildForm();
-    loadForm();
-    initForm();
-
-    $('reset-button').onclick = onReset.bind(this);
-  }
-
   return {
     initialize: initialize,
     getPreferenceValueResult: getPreferenceValueResult
diff --git a/chrome/browser/ui/gesture_prefs_observer_factory_aura.cc b/chrome/browser/ui/gesture_prefs_observer_factory_aura.cc
index 6279f4e..5669fc7 100644
--- a/chrome/browser/ui/gesture_prefs_observer_factory_aura.cc
+++ b/chrome/browser/ui/gesture_prefs_observer_factory_aura.cc
@@ -13,12 +13,18 @@
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_observer.h"
+#include "content/public/browser/overscroll_configuration.h"
 #include "ui/base/gestures/gesture_configuration.h"
 
 using ui::GestureConfiguration;
 
 namespace {
 
+struct OverscrollPref {
+  const char* pref_name;
+  content::OverscrollConfig config;
+};
+
 // This class manages gesture configuration preferences.
 class GesturePrefsObserver : public PrefObserver,
                              public ProfileKeyedService {
@@ -26,6 +32,26 @@ class GesturePrefsObserver : public PrefObserver,
   explicit GesturePrefsObserver(PrefService* prefs);
   virtual ~GesturePrefsObserver();
 
+  static const OverscrollPref* GetOverscrollPrefs() {
+    using namespace content;
+    static OverscrollPref overscroll_prefs[] = {
+      { prefs::kOverscrollHorizontalThresholdComplete,
+        OVERSCROLL_CONFIG_HORIZ_THRESHOLD_COMPLETE },
+      { prefs::kOverscrollVerticalThresholdComplete,
+        OVERSCROLL_CONFIG_VERT_THRESHOLD_COMPLETE },
+      { prefs::kOverscrollMinimumThresholdStart,
+        OVERSCROLL_CONFIG_MIN_THRESHOLD_START },
+      { prefs::kOverscrollHorizontalResistThreshold,
+        OVERSCROLL_CONFIG_HORIZ_RESIST_AFTER },
+      { prefs::kOverscrollVerticalResistThreshold,
+        OVERSCROLL_CONFIG_VERT_RESIST_AFTER },
+      { NULL,
+        OVERSCROLL_CONFIG_NONE },
+    };
+
+    return overscroll_prefs;
+  }
+
   // ProfileKeyedService implementation.
   virtual void Shutdown() OVERRIDE;
 
@@ -36,6 +62,8 @@ class GesturePrefsObserver : public PrefObserver,
  private:
   void Update();
 
+  void UpdateOverscrollPrefs();
+
   PrefChangeRegistrar registrar_;
   PrefService* prefs_;
 
@@ -70,12 +98,22 @@ const char* kPrefsToObserve[] = {
   prefs::kSemiLongPressTimeInSeconds,
 };
 
+const char* kOverscrollPrefs[] = {
+  prefs::kOverscrollHorizontalThresholdComplete,
+  prefs::kOverscrollVerticalThresholdComplete,
+  prefs::kOverscrollMinimumThresholdStart,
+  prefs::kOverscrollHorizontalResistThreshold,
+  prefs::kOverscrollVerticalResistThreshold,
+};
+
 GesturePrefsObserver::GesturePrefsObserver(PrefService* prefs)
     : prefs_(prefs) {
   registrar_.Init(prefs);
   registrar_.RemoveAll();
   for (size_t i = 0; i < arraysize(kPrefsToObserve); ++i)
     registrar_.Add(kPrefsToObserve[i], this);
+  for (size_t i = 0; i < arraysize(kOverscrollPrefs); ++i)
+    registrar_.Add(kOverscrollPrefs[i], this);
 }
 
 GesturePrefsObserver::~GesturePrefsObserver() {}
@@ -155,6 +193,17 @@ void GesturePrefsObserver::Update() {
   GestureConfiguration::set_rail_start_proportion(
       prefs_->GetDouble(
           prefs::kRailStartProportion));
+
+  UpdateOverscrollPrefs();
+}
+
+void GesturePrefsObserver::UpdateOverscrollPrefs() {
+  const OverscrollPref* overscroll_prefs =
+      GesturePrefsObserver::GetOverscrollPrefs();
+  for (int i = 0; overscroll_prefs[i].pref_name; ++i) {
+    content::SetOverscrollConfig(overscroll_prefs[i].config,
+        static_cast<float>(prefs_->GetDouble(overscroll_prefs[i].pref_name)));
+  }
 }
 
 }  // namespace
@@ -176,6 +225,19 @@ ProfileKeyedService* GesturePrefsObserverFactoryAura::BuildServiceInstanceFor(
   return new GesturePrefsObserver(profile->GetPrefs());
 }
 
+void GesturePrefsObserverFactoryAura::RegisterOverscrollPrefs(
+    PrefService* prefs) {
+  const OverscrollPref* overscroll_prefs =
+      GesturePrefsObserver::GetOverscrollPrefs();
+
+  for (int i = 0; overscroll_prefs[i].pref_name; ++i) {
+    prefs->RegisterDoublePref(
+        overscroll_prefs[i].pref_name,
+        content::GetOverscrollConfig(overscroll_prefs[i].config),
+        PrefService::UNSYNCABLE_PREF);
+  }
+}
+
 void GesturePrefsObserverFactoryAura::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDoublePref(
       prefs::kFlingAccelerationCurveCoefficient0,
@@ -277,6 +339,8 @@ void GesturePrefsObserverFactoryAura::RegisterUserPrefs(PrefService* prefs) {
                             0.0,
                             PrefService::UNSYNCABLE_PREF);
   prefs->ClearPref(kTouchScreenFlingAccelerationAdjustment);
+
+  RegisterOverscrollPrefs(prefs);
 }
 
 bool GesturePrefsObserverFactoryAura::ServiceIsCreatedWithProfile() const {
diff --git a/chrome/browser/ui/gesture_prefs_observer_factory_aura.h b/chrome/browser/ui/gesture_prefs_observer_factory_aura.h
index c13ede1..686e0c6 100644
--- a/chrome/browser/ui/gesture_prefs_observer_factory_aura.h
+++ b/chrome/browser/ui/gesture_prefs_observer_factory_aura.h
@@ -23,6 +23,8 @@ class GesturePrefsObserverFactoryAura : public ProfileKeyedServiceFactory {
   GesturePrefsObserverFactoryAura();
   virtual ~GesturePrefsObserverFactoryAura();
 
+  void RegisterOverscrollPrefs(PrefService* prefs);
+
   // ProfileKeyedServiceFactory:
   virtual ProfileKeyedService* BuildServiceInstanceFor(
       Profile* profile) const OVERRIDE;
diff --git a/chrome/browser/ui/webui/gesture_config_ui.cc b/chrome/browser/ui/webui/gesture_config_ui.cc
index 1bdc72e..8f90f0d 100644
--- a/chrome/browser/ui/webui/gesture_config_ui.cc
+++ b/chrome/browser/ui/webui/gesture_config_ui.cc
@@ -80,7 +80,18 @@ void GestureConfigUI::ResetPreferenceValue(const base::ListValue* args) {
   double d;
   if (prefs->GetDefaultPrefValue(pref_name.c_str())->GetAsDouble(&d)) {
     base::FundamentalValue js_pref_value(d);
-    prefs->SetDouble(pref_name.c_str(), d);
+    const PrefService::Preference* pref =
+        prefs->FindPreference(pref_name.c_str());
+    switch (pref->GetType()) {
+      case base::Value::TYPE_INTEGER:
+        prefs->SetInteger(pref_name.c_str(), static_cast<int>(d));
+        break;
+      case base::Value::TYPE_DOUBLE:
+        prefs->SetDouble(pref_name.c_str(), d);
+        break;
+      default:
+        NOTREACHED();
+    }
     web_ui()->CallJavascriptFunction(
         "gesture_config.getPreferenceValueResult",
         js_pref_name,
diff --git a/chrome/common/pref_names.cc b/chrome/common/pref_names.cc
index 4f4f1273..f8d8c70 100644
--- a/chrome/common/pref_names.cc
+++ b/chrome/common/pref_names.cc
@@ -2130,6 +2130,17 @@ const char kFlingAccelerationCurveCoefficient2[] =
     "gesture.fling_acceleration_curve_coefficient_2";
 const char kFlingAccelerationCurveCoefficient3[] =
     "gesture.fling_acceleration_curve_coefficient_3";
+
+const char kOverscrollHorizontalThresholdComplete[] =
+    "overscroll.horizontal_threshold_complete";
+const char kOverscrollVerticalThresholdComplete[] =
+    "overscroll.vertical_threshold_complete";
+const char kOverscrollMinimumThresholdStart[] =
+    "overscroll.minimum_threshold_start";
+const char kOverscrollHorizontalResistThreshold[] =
+    "overscroll.horizontal_resist_threshold";
+const char kOverscrollVerticalResistThreshold[] =
+    "overscroll.vertical_resist_threshold";
 #endif
 
 // Indicates whether the browser is in managed mode.
diff --git a/chrome/common/pref_names.h b/chrome/common/pref_names.h
index 2e048f9..6a799a9 100644
--- a/chrome/common/pref_names.h
+++ b/chrome/common/pref_names.h
@@ -783,6 +783,11 @@ extern const char kFlingAccelerationCurveCoefficient0[];
 extern const char kFlingAccelerationCurveCoefficient1[];
 extern const char kFlingAccelerationCurveCoefficient2[];
 extern const char kFlingAccelerationCurveCoefficient3[];
+extern const char kOverscrollHorizontalThresholdComplete[];
+extern const char kOverscrollVerticalThresholdComplete[];
+extern const char kOverscrollMinimumThresholdStart[];
+extern const char kOverscrollHorizontalResistThreshold[];
+extern const char kOverscrollVerticalResistThreshold[];
 #endif
 
 extern const char kInManagedMode[];
diff --git a/content/browser/renderer_host/overscroll_configuration.cc b/content/browser/renderer_host/overscroll_configuration.cc
new file mode 100644
index 0000000..16733a4
--- /dev/null
+++ b/content/browser/renderer_host/overscroll_configuration.cc
@@ -0,0 +1,76 @@
+// Copyright (c) 2012 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/public/browser/overscroll_configuration.h"
+
+#include "base/logging.h"
+
+namespace {
+
+float g_horiz_threshold_complete = 0.25f;
+float g_vert_threshold_complete = 0.20f;
+
+float g_min_threshold_start = 30.f;
+
+float g_horiz_resist_after = 30.f;
+float g_vert_resist_after = 30.f;
+
+}
+
+namespace content {
+
+void SetOverscrollConfig(OverscrollConfig config, float value) {
+  switch (config) {
+    case OVERSCROLL_CONFIG_HORIZ_THRESHOLD_COMPLETE:
+      g_horiz_threshold_complete = value;
+      break;
+
+    case OVERSCROLL_CONFIG_VERT_THRESHOLD_COMPLETE:
+      g_vert_threshold_complete = value;
+      break;
+
+    case OVERSCROLL_CONFIG_MIN_THRESHOLD_START:
+      g_min_threshold_start = value;
+      break;
+
+    case OVERSCROLL_CONFIG_HORIZ_RESIST_AFTER:
+      g_horiz_resist_after = value;
+      break;
+
+    case OVERSCROLL_CONFIG_VERT_RESIST_AFTER:
+      g_vert_resist_after = value;
+      break;
+
+    case OVERSCROLL_CONFIG_NONE:
+    case OVERSCROLL_CONFIG_COUNT:
+      NOTREACHED();
+  }
+}
+
+float GetOverscrollConfig(OverscrollConfig config) {
+  switch (config) {
+    case OVERSCROLL_CONFIG_HORIZ_THRESHOLD_COMPLETE:
+      return g_horiz_threshold_complete;
+
+    case OVERSCROLL_CONFIG_VERT_THRESHOLD_COMPLETE:
+      return g_vert_threshold_complete;
+
+    case OVERSCROLL_CONFIG_MIN_THRESHOLD_START:
+      return g_min_threshold_start;
+
+    case OVERSCROLL_CONFIG_HORIZ_RESIST_AFTER:
+      return g_horiz_resist_after;
+
+    case OVERSCROLL_CONFIG_VERT_RESIST_AFTER:
+      return g_vert_resist_after;
+
+    case OVERSCROLL_CONFIG_NONE:
+    case OVERSCROLL_CONFIG_COUNT:
+      NOTREACHED();
+  }
+
+  return -1.f;
+}
+
+}  // namespace content
diff --git a/content/browser/renderer_host/overscroll_controller.cc b/content/browser/renderer_host/overscroll_controller.cc
index 322bae3..5c6691825 100644
--- a/content/browser/renderer_host/overscroll_controller.cc
+++ b/content/browser/renderer_host/overscroll_controller.cc
@@ -7,12 +7,9 @@
 #include "content/browser/renderer_host/gesture_event_filter.h"
 #include "content/browser/renderer_host/overscroll_controller_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "content/public/browser/overscroll_configuration.h"
 #include "content/public/browser/render_widget_host_view.h"
 
-// TODO(sad): There are a number of thresholds used by the controller to decide
-// when to start/complete/discard the overscroll actions. Make these thresholds
-// easily configurable.
-
 namespace {
 
 // Some gesture events can also be triggered from the trackpad. This function
@@ -129,16 +126,14 @@ bool OverscrollController::DispatchEventCompletesAction (
   if (bounds.IsEmpty())
     return false;
 
-  const float kOverscrollHorizontalThreshold = 0.25f;
-  const float kOverscrollVerticalThreshold = 0.20f;
   float ratio, threshold;
   if (overscroll_mode_ == OVERSCROLL_WEST ||
       overscroll_mode_ == OVERSCROLL_EAST) {
     ratio = fabs(overscroll_delta_x_) / bounds.width();
-    threshold = kOverscrollHorizontalThreshold;
+    threshold = GetOverscrollConfig(OVERSCROLL_CONFIG_HORIZ_THRESHOLD_COMPLETE);
   } else {
     ratio = fabs(overscroll_delta_y_) / bounds.height();
-    threshold = kOverscrollVerticalThreshold;
+    threshold = GetOverscrollConfig(OVERSCROLL_CONFIG_VERT_THRESHOLD_COMPLETE);
   }
   return ratio >= threshold;
 }
@@ -210,9 +205,9 @@ void OverscrollController::ProcessOverscroll(float delta_x, float delta_y) {
   overscroll_delta_x_ += delta_x;
   overscroll_delta_y_ += delta_y;
 
-  const float kMinOverscrollThreshold = 30.f;
-  if (fabs(overscroll_delta_x_) < kMinOverscrollThreshold &&
-      fabs(overscroll_delta_y_) < kMinOverscrollThreshold) {
+  float threshold = GetOverscrollConfig(OVERSCROLL_CONFIG_MIN_THRESHOLD_START);
+  if (fabs(overscroll_delta_x_) < threshold &&
+      fabs(overscroll_delta_y_) < threshold) {
     SetOverscrollMode(OVERSCROLL_NONE);
     return;
   }
@@ -233,21 +228,21 @@ void OverscrollController::ProcessOverscroll(float delta_x, float delta_y) {
     // Do not include the threshold amount when sending the deltas to the
     // delegate.
     float delegate_delta_x = overscroll_delta_x_;
-    if (fabs(delegate_delta_x) > kMinOverscrollThreshold) {
+    if (fabs(delegate_delta_x) > threshold) {
       if (delegate_delta_x < 0)
-        delegate_delta_x += kMinOverscrollThreshold;
+        delegate_delta_x += threshold;
       else
-        delegate_delta_x -= kMinOverscrollThreshold;
+        delegate_delta_x -= threshold;
     } else {
       delegate_delta_x = 0.f;
     }
 
     float delegate_delta_y = overscroll_delta_y_;
-    if (fabs(delegate_delta_y) > kMinOverscrollThreshold) {
+    if (fabs(delegate_delta_y) > threshold) {
       if (delegate_delta_y < 0)
-        delegate_delta_y += kMinOverscrollThreshold;
+        delegate_delta_y += threshold;
       else
-        delegate_delta_y -= kMinOverscrollThreshold;
+        delegate_delta_y -= threshold;
     } else {
       delegate_delta_y = 0.f;
     }
diff --git a/content/browser/web_contents/web_contents_view_aura.cc b/content/browser/web_contents/web_contents_view_aura.cc
index a773453..bd41383 100644
--- a/content/browser/web_contents/web_contents_view_aura.cc
+++ b/content/browser/web_contents/web_contents_view_aura.cc
@@ -16,6 +16,7 @@
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/overscroll_configuration.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
@@ -468,9 +469,10 @@ gfx::Vector2d WebContentsViewAura::GetTranslationForOverscroll(int delta_x,
   if (current_overscroll_gesture_ == OVERSCROLL_NORTH ||
       current_overscroll_gesture_ == OVERSCROLL_SOUTH) {
     // For vertical overscroll, always do a resisted drag.
-    const int kVerticalOverscrollAmount = 30;
+    const float threshold = GetOverscrollConfig(
+        OVERSCROLL_CONFIG_VERT_RESIST_AFTER);
     int scroll = GetResistedScrollAmount(abs(delta_y),
-                                         kVerticalOverscrollAmount);
+                                         static_cast<int>(threshold));
     return gfx::Vector2d(0, delta_y < 0 ? -scroll : scroll);
   }
 
@@ -485,9 +487,10 @@ gfx::Vector2d WebContentsViewAura::GetTranslationForOverscroll(int delta_x,
       return gfx::Vector2d(delta_x, 0);
   }
 
-  const int kHorizontalOverscrollAmount = 30;
+  const float threshold = GetOverscrollConfig(
+      OVERSCROLL_CONFIG_HORIZ_RESIST_AFTER);
   int scroll = GetResistedScrollAmount(abs(delta_x),
-                                       kHorizontalOverscrollAmount);
+                                       static_cast<int>(threshold));
   return gfx::Vector2d(delta_x < 0 ? -scroll : scroll, 0);
 }
 
diff --git a/content/content_browser.gypi b/content/content_browser.gypi
index 52a50e7..f35d9f1 100644
--- a/content/content_browser.gypi
+++ b/content/content_browser.gypi
@@ -119,6 +119,7 @@
     'public/browser/notification_service.h',
     'public/browser/notification_source.h',
     'public/browser/notification_types.h',
+    'public/browser/overscroll_configuration.h',
     'public/browser/page_navigator.cc',
     'public/browser/page_navigator.h',
     'public/browser/pepper_flash_settings_helper.h',
@@ -642,6 +643,7 @@
     'browser/renderer_host/native_web_keyboard_event_gtk.cc',
     'browser/renderer_host/native_web_keyboard_event_mac.mm',
     'browser/renderer_host/native_web_keyboard_event_win.cc',
+    'browser/renderer_host/overscroll_configuration.cc',
     'browser/renderer_host/overscroll_controller.cc',
     'browser/renderer_host/overscroll_controller.h',
     'browser/renderer_host/overscroll_controller_delegate.h',
diff --git a/content/public/browser/overscroll_configuration.h b/content/public/browser/overscroll_configuration.h
new file mode 100644
index 0000000..a8ca931
--- /dev/null
+++ b/content/public/browser/overscroll_configuration.h
@@ -0,0 +1,30 @@
+// Copyright (c) 2012 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.
+
+#ifndef CONTENT_PUBLIC_BROWSER_OVERSCROLL_CONFIGURATION_H_
+#define CONTENT_PUBLIC_BROWSER_OVERSCROLL_CONFIGURATION_H_
+
+#include "base/basictypes.h"
+#include "content/common/content_export.h"
+
+namespace content {
+
+// Sets and retrieves various overscroll related configuration values.
+enum OverscrollConfig {
+  OVERSCROLL_CONFIG_NONE,
+  OVERSCROLL_CONFIG_HORIZ_THRESHOLD_COMPLETE,
+  OVERSCROLL_CONFIG_VERT_THRESHOLD_COMPLETE,
+  OVERSCROLL_CONFIG_MIN_THRESHOLD_START,
+  OVERSCROLL_CONFIG_HORIZ_RESIST_AFTER,
+  OVERSCROLL_CONFIG_VERT_RESIST_AFTER,
+  OVERSCROLL_CONFIG_COUNT
+};
+
+CONTENT_EXPORT void SetOverscrollConfig(OverscrollConfig config, float value);
+
+CONTENT_EXPORT float GetOverscrollConfig(OverscrollConfig config);
+
+}  // namespace content
+
+#endif  // CONTENT_PUBLIC_BROWSER_OVERSCROLL_CONFIGURATION_H_