content/browser/renderer_host/overscroll_controller.cc - chromium/src.git - Git at Google

 // 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/browser/renderer_host/overscroll_controller.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"

 using WebKit::WebInputEvent;

 namespace content {

 OverscrollController::OverscrollController(
     RenderWidgetHostImpl* render_widget_host)
     : render_widget_host_(render_widget_host),
       overscroll_mode_(OVERSCROLL_NONE),
       scroll_state_(STATE_UNKNOWN),
       overscroll_delta_x_(0.f),
       overscroll_delta_y_(0.f),
       delegate_(NULL) {
 }

 OverscrollController::~OverscrollController() {
 }

 OverscrollController::Disposition OverscrollController::DispatchEvent(
     const WebKit::WebInputEvent& event,
     const ui::LatencyInfo& latency_info) {
   if (scroll_state_ != STATE_UNKNOWN) {
     switch (event.type) {
       case WebKit::WebInputEvent::GestureScrollEnd:
       case WebKit::WebInputEvent::GestureFlingStart:
         scroll_state_ = STATE_UNKNOWN;
         break;

       case WebKit::WebInputEvent::MouseWheel: {
         const WebKit::WebMouseWheelEvent& wheel =
             static_cast<const WebKit::WebMouseWheelEvent&>(event);
         if (!wheel.hasPreciseScrollingDeltas ||
             wheel.phase == WebKit::WebMouseWheelEvent::PhaseEnded ||
             wheel.phase == WebKit::WebMouseWheelEvent::PhaseCancelled) {
           scroll_state_ = STATE_UNKNOWN;
         }
         break;
       }

       default:
         if (WebKit::WebInputEvent::isMouseEventType(event.type) ||
             WebKit::WebInputEvent::isKeyboardEventType(event.type)) {
           scroll_state_ = STATE_UNKNOWN;
         }
         break;
     }
   }

   if (DispatchEventCompletesAction(event)) {
     CompleteAction();

     // If the overscroll was caused by touch-scrolling, then the gesture event
     // that completes the action needs to be sent to the renderer, because the
     // touch-scrolls maintain state in the renderer side (in the compositor, for
     // example), and the event that completes this action needs to be sent to
     // the renderer so that those states can be updated/reset appropriately.
     if (WebKit::WebInputEvent::isGestureEventType(event.type)) {
       // A gesture-event isn't sent to the GestureEventFilter when overscroll is
       // in progress. So dispatch the event through the RenderWidgetHost so that
       // it can reach the GestureEventFilter.
       return SHOULD_FORWARD_TO_GESTURE_FILTER;
     }

     return SHOULD_FORWARD_TO_RENDERER;
   }

   if (overscroll_mode_ != OVERSCROLL_NONE && DispatchEventResetsState(event)) {
     SetOverscrollMode(OVERSCROLL_NONE);
     if (WebKit::WebInputEvent::isGestureEventType(event.type)) {
       // A gesture-event isn't sent to the GestureEventFilter when overscroll is
       // in progress. So dispatch the event through the RenderWidgetHost so that
       // it can reach the GestureEventFilter.
       return SHOULD_FORWARD_TO_GESTURE_FILTER;
     }

     // Let the event be dispatched to the renderer.
     return SHOULD_FORWARD_TO_RENDERER;
   }

   if (overscroll_mode_ != OVERSCROLL_NONE) {
     // Consume the event only if it updates the overscroll state.
     if (ProcessEventForOverscroll(event))
       return CONSUMED;
   }

   return SHOULD_FORWARD_TO_RENDERER;
 }

 void OverscrollController::ReceivedEventACK(const WebKit::WebInputEvent& event,
                                             bool processed) {
   if (processed) {
     // If a scroll event is consumed by the page, i.e. some content on the page
     // has been scrolled, then there is not going to be an overscroll gesture,
     // until the current scroll ends, and a new scroll gesture starts.
     if (scroll_state_ == STATE_UNKNOWN &&
         (event.type == WebKit::WebInputEvent::MouseWheel ||
          event.type == WebKit::WebInputEvent::GestureScrollUpdate)) {
       scroll_state_ = STATE_CONTENT_SCROLLING;
     }
     return;
   }
   ProcessEventForOverscroll(event);
 }

 void OverscrollController::DiscardingGestureEvent(
     const WebKit::WebGestureEvent& gesture) {
   if (scroll_state_ != STATE_UNKNOWN &&
       (gesture.type == WebKit::WebInputEvent::GestureScrollEnd ||
        gesture.type == WebKit::WebInputEvent::GestureFlingStart)) {
     scroll_state_ = STATE_UNKNOWN;
   }
 }

 void OverscrollController::Reset() {
   overscroll_mode_ = OVERSCROLL_NONE;
   overscroll_delta_x_ = overscroll_delta_y_ = 0.f;
   scroll_state_ = STATE_UNKNOWN;
 }

 void OverscrollController::Cancel() {
   SetOverscrollMode(OVERSCROLL_NONE);
   overscroll_delta_x_ = overscroll_delta_y_ = 0.f;
   scroll_state_ = STATE_UNKNOWN;
 }

 bool OverscrollController::DispatchEventCompletesAction (
     const WebKit::WebInputEvent& event) const {
   if (overscroll_mode_ == OVERSCROLL_NONE)
     return false;

   // Complete the overscroll gesture if there was a mouse move or a scroll-end
   // after the threshold.
   if (event.type != WebKit::WebInputEvent::MouseMove &&
       event.type != WebKit::WebInputEvent::GestureScrollEnd &&
       event.type != WebKit::WebInputEvent::GestureFlingStart)
     return false;

   RenderWidgetHostView* view = render_widget_host_->GetView();
   if (!view->IsShowing())
     return false;

   const gfx::Rect& bounds = view->GetViewBounds();
   if (bounds.IsEmpty())
     return false;

   if (event.type == WebKit::WebInputEvent::GestureFlingStart) {
     // Check to see if the fling is in the same direction of the overscroll.
     const WebKit::WebGestureEvent gesture =
         static_cast<const WebKit::WebGestureEvent&>(event);
     switch (overscroll_mode_) {
       case OVERSCROLL_EAST:
         if (gesture.data.flingStart.velocityX < 0)
           return false;
         break;
       case OVERSCROLL_WEST:
         if (gesture.data.flingStart.velocityX > 0)
           return false;
         break;
       case OVERSCROLL_NORTH:
         if (gesture.data.flingStart.velocityY > 0)
           return false;
         break;
       case OVERSCROLL_SOUTH:
         if (gesture.data.flingStart.velocityY < 0)
           return false;
         break;
       case OVERSCROLL_NONE:
       case OVERSCROLL_COUNT:
         NOTREACHED();
     }
   }

   float ratio, threshold;
   if (overscroll_mode_ == OVERSCROLL_WEST ||
       overscroll_mode_ == OVERSCROLL_EAST) {
     ratio = fabs(overscroll_delta_x_) / bounds.width();
     threshold = GetOverscrollConfig(OVERSCROLL_CONFIG_HORIZ_THRESHOLD_COMPLETE);
   } else {
     ratio = fabs(overscroll_delta_y_) / bounds.height();
     threshold = GetOverscrollConfig(OVERSCROLL_CONFIG_VERT_THRESHOLD_COMPLETE);
   }

   return ratio >= threshold;
 }

 bool OverscrollController::DispatchEventResetsState(
     const WebKit::WebInputEvent& event) const {
   switch (event.type) {
     case WebKit::WebInputEvent::MouseWheel: {
       // Only wheel events with precise deltas (i.e. from trackpad) contribute
       // to the overscroll gesture.
       const WebKit::WebMouseWheelEvent& wheel =
           static_cast<const WebKit::WebMouseWheelEvent&>(event);
       return !wheel.hasPreciseScrollingDeltas;
     }

     case WebKit::WebInputEvent::GestureScrollUpdate:
     case WebKit::WebInputEvent::GestureFlingCancel:
       return false;

     default:
       // Touch events can arrive during an overscroll gesture initiated by
       // touch-scrolling. These events should not reset the overscroll state.
       return !WebKit::WebInputEvent::isTouchEventType(event.type);
   }
 }

 bool OverscrollController::ProcessEventForOverscroll(
     const WebKit::WebInputEvent& event) {
   bool event_processed = false;
   switch (event.type) {
     case WebKit::WebInputEvent::MouseWheel: {
       const WebKit::WebMouseWheelEvent& wheel =
           static_cast<const WebKit::WebMouseWheelEvent&>(event);
       if (!wheel.hasPreciseScrollingDeltas)
         break;

       ProcessOverscroll(wheel.deltaX * wheel.accelerationRatioX,
                         wheel.deltaY * wheel.accelerationRatioY,
                         wheel.type);
       event_processed = true;
       break;
     }
     case WebKit::WebInputEvent::GestureScrollUpdate: {
       const WebKit::WebGestureEvent& gesture =
           static_cast<const WebKit::WebGestureEvent&>(event);
       ProcessOverscroll(gesture.data.scrollUpdate.deltaX,
                         gesture.data.scrollUpdate.deltaY,
                         gesture.type);
       event_processed = true;
       break;
     }
     case WebKit::WebInputEvent::GestureFlingStart: {
       const float kFlingVelocityThreshold = 1100.f;
       const WebKit::WebGestureEvent& gesture =
           static_cast<const WebKit::WebGestureEvent&>(event);
       float velocity_x = gesture.data.flingStart.velocityX;
       float velocity_y = gesture.data.flingStart.velocityY;
       if (fabs(velocity_x) > kFlingVelocityThreshold) {
         if ((overscroll_mode_ == OVERSCROLL_WEST && velocity_x < 0) ||
             (overscroll_mode_ == OVERSCROLL_EAST && velocity_x > 0)) {
           CompleteAction();
           event_processed = true;
           break;
         }
       } else if (fabs(velocity_y) > kFlingVelocityThreshold) {
         if ((overscroll_mode_ == OVERSCROLL_NORTH && velocity_y < 0) ||
             (overscroll_mode_ == OVERSCROLL_SOUTH && velocity_y > 0)) {
           CompleteAction();
           event_processed = true;
           break;
         }
       }

       // Reset overscroll state if fling didn't complete the overscroll gesture.
       SetOverscrollMode(OVERSCROLL_NONE);
       break;
     }

     default:
       DCHECK(WebKit::WebInputEvent::isGestureEventType(event.type) ||
              WebKit::WebInputEvent::isTouchEventType(event.type))
           << "Received unexpected event: " << event.type;
   }
   return event_processed;
 }

 void OverscrollController::ProcessOverscroll(float delta_x,
                                              float delta_y,
                                              WebKit::WebInputEvent::Type type) {
   if (scroll_state_ != STATE_CONTENT_SCROLLING)
     overscroll_delta_x_ += delta_x;
   overscroll_delta_y_ += delta_y;

   float horiz_threshold = GetOverscrollConfig(
       WebInputEvent::isGestureEventType(type) ?
           OVERSCROLL_CONFIG_HORIZ_THRESHOLD_START_TOUCHSCREEN :
           OVERSCROLL_CONFIG_HORIZ_THRESHOLD_START_TOUCHPAD);
   float vert_threshold = GetOverscrollConfig(
       OVERSCROLL_CONFIG_VERT_THRESHOLD_START);
   if (fabs(overscroll_delta_x_) <= horiz_threshold &&
       fabs(overscroll_delta_y_) <= vert_threshold) {
     SetOverscrollMode(OVERSCROLL_NONE);
     return;
   }

   // Compute the current overscroll direction. If the direction is different
   // from the current direction, then always switch to no-overscroll mode first
   // to make sure that subsequent scroll events go through to the page first.
   OverscrollMode new_mode = OVERSCROLL_NONE;
   const float kMinRatio = 2.5;
   if (fabs(overscroll_delta_x_) > horiz_threshold &&
       fabs(overscroll_delta_x_) > fabs(overscroll_delta_y_) * kMinRatio)
     new_mode = overscroll_delta_x_ > 0.f ? OVERSCROLL_EAST : OVERSCROLL_WEST;
   else if (fabs(overscroll_delta_y_) > vert_threshold &&
            fabs(overscroll_delta_y_) > fabs(overscroll_delta_x_) * kMinRatio)
     new_mode = overscroll_delta_y_ > 0.f ? OVERSCROLL_SOUTH : OVERSCROLL_NORTH;

   if (overscroll_mode_ == OVERSCROLL_NONE)
     SetOverscrollMode(new_mode);
   else if (new_mode != overscroll_mode_)
     SetOverscrollMode(OVERSCROLL_NONE);

   if (overscroll_mode_ == OVERSCROLL_NONE)
     return;

   // Tell the delegate about the overscroll update so that it can update
   // the display accordingly (e.g. show history preview etc.).
   if (delegate_) {
     // 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) > horiz_threshold) {
       if (delegate_delta_x < 0)
         delegate_delta_x += horiz_threshold;
       else
         delegate_delta_x -= horiz_threshold;
     } else {
       delegate_delta_x = 0.f;
     }

     float delegate_delta_y = overscroll_delta_y_;
     if (fabs(delegate_delta_y) > vert_threshold) {
       if (delegate_delta_y < 0)
         delegate_delta_y += vert_threshold;
       else
         delegate_delta_y -= vert_threshold;
     } else {
       delegate_delta_y = 0.f;
     }
     delegate_->OnOverscrollUpdate(delegate_delta_x, delegate_delta_y);
   }
 }

 void OverscrollController::CompleteAction() {
   if (delegate_)
     delegate_->OnOverscrollComplete(overscroll_mode_);
   overscroll_mode_ = OVERSCROLL_NONE;
   overscroll_delta_x_ = overscroll_delta_y_ = 0.f;
 }

 void OverscrollController::SetOverscrollMode(OverscrollMode mode) {
   if (overscroll_mode_ == mode)
     return;
   OverscrollMode old_mode = overscroll_mode_;
   overscroll_mode_ = mode;
   if (overscroll_mode_ == OVERSCROLL_NONE)
     overscroll_delta_x_ = overscroll_delta_y_ = 0.f;
   else
     scroll_state_ = STATE_OVERSCROLLING;
   if (delegate_)
     delegate_->OnOverscrollModeChange(old_mode, overscroll_mode_);
 }

 }  // namespace content
	// 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/browser/renderer_host/overscroll_controller.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"

	using WebKit::WebInputEvent;

	namespace content {

	OverscrollController::OverscrollController(
	RenderWidgetHostImpl* render_widget_host)
	: render_widget_host_(render_widget_host),
	overscroll_mode_(OVERSCROLL_NONE),
	scroll_state_(STATE_UNKNOWN),
	overscroll_delta_x_(0.f),
	overscroll_delta_y_(0.f),
	delegate_(NULL) {
	}

	OverscrollController::~OverscrollController() {
	}

	OverscrollController::Disposition OverscrollController::DispatchEvent(
	const WebKit::WebInputEvent& event,
	const ui::LatencyInfo& latency_info) {
	if (scroll_state_ != STATE_UNKNOWN) {
	switch (event.type) {
	case WebKit::WebInputEvent::GestureScrollEnd:
	case WebKit::WebInputEvent::GestureFlingStart:
	scroll_state_ = STATE_UNKNOWN;
	break;

	case WebKit::WebInputEvent::MouseWheel: {
	const WebKit::WebMouseWheelEvent& wheel =
	static_cast<const WebKit::WebMouseWheelEvent&>(event);
	if (!wheel.hasPreciseScrollingDeltas \|\|
	wheel.phase == WebKit::WebMouseWheelEvent::PhaseEnded \|\|
	wheel.phase == WebKit::WebMouseWheelEvent::PhaseCancelled) {
	scroll_state_ = STATE_UNKNOWN;
	}
	break;
	}

	default:
	if (WebKit::WebInputEvent::isMouseEventType(event.type) \|\|
	WebKit::WebInputEvent::isKeyboardEventType(event.type)) {
	scroll_state_ = STATE_UNKNOWN;
	}
	break;
	}
	}

	if (DispatchEventCompletesAction(event)) {
	CompleteAction();

	// If the overscroll was caused by touch-scrolling, then the gesture event
	// that completes the action needs to be sent to the renderer, because the
	// touch-scrolls maintain state in the renderer side (in the compositor, for
	// example), and the event that completes this action needs to be sent to
	// the renderer so that those states can be updated/reset appropriately.
	if (WebKit::WebInputEvent::isGestureEventType(event.type)) {
	// A gesture-event isn't sent to the GestureEventFilter when overscroll is
	// in progress. So dispatch the event through the RenderWidgetHost so that
	// it can reach the GestureEventFilter.
	return SHOULD_FORWARD_TO_GESTURE_FILTER;
	}

	return SHOULD_FORWARD_TO_RENDERER;
	}

	if (overscroll_mode_ != OVERSCROLL_NONE && DispatchEventResetsState(event)) {
	SetOverscrollMode(OVERSCROLL_NONE);
	if (WebKit::WebInputEvent::isGestureEventType(event.type)) {
	// A gesture-event isn't sent to the GestureEventFilter when overscroll is
	// in progress. So dispatch the event through the RenderWidgetHost so that
	// it can reach the GestureEventFilter.
	return SHOULD_FORWARD_TO_GESTURE_FILTER;
	}

	// Let the event be dispatched to the renderer.
	return SHOULD_FORWARD_TO_RENDERER;
	}

	if (overscroll_mode_ != OVERSCROLL_NONE) {
	// Consume the event only if it updates the overscroll state.
	if (ProcessEventForOverscroll(event))
	return CONSUMED;
	}

	return SHOULD_FORWARD_TO_RENDERER;
	}

	void OverscrollController::ReceivedEventACK(const WebKit::WebInputEvent& event,
	bool processed) {
	if (processed) {
	// If a scroll event is consumed by the page, i.e. some content on the page
	// has been scrolled, then there is not going to be an overscroll gesture,
	// until the current scroll ends, and a new scroll gesture starts.
	if (scroll_state_ == STATE_UNKNOWN &&
	(event.type == WebKit::WebInputEvent::MouseWheel \|\|
	event.type == WebKit::WebInputEvent::GestureScrollUpdate)) {
	scroll_state_ = STATE_CONTENT_SCROLLING;
	}
	return;
	}
	ProcessEventForOverscroll(event);
	}

	void OverscrollController::DiscardingGestureEvent(
	const WebKit::WebGestureEvent& gesture) {
	if (scroll_state_ != STATE_UNKNOWN &&
	(gesture.type == WebKit::WebInputEvent::GestureScrollEnd \|\|
	gesture.type == WebKit::WebInputEvent::GestureFlingStart)) {
	scroll_state_ = STATE_UNKNOWN;
	}
	}

	void OverscrollController::Reset() {
	overscroll_mode_ = OVERSCROLL_NONE;
	overscroll_delta_x_ = overscroll_delta_y_ = 0.f;
	scroll_state_ = STATE_UNKNOWN;
	}

	void OverscrollController::Cancel() {
	SetOverscrollMode(OVERSCROLL_NONE);
	overscroll_delta_x_ = overscroll_delta_y_ = 0.f;
	scroll_state_ = STATE_UNKNOWN;
	}

	bool OverscrollController::DispatchEventCompletesAction (
	const WebKit::WebInputEvent& event) const {
	if (overscroll_mode_ == OVERSCROLL_NONE)
	return false;

	// Complete the overscroll gesture if there was a mouse move or a scroll-end
	// after the threshold.
	if (event.type != WebKit::WebInputEvent::MouseMove &&
	event.type != WebKit::WebInputEvent::GestureScrollEnd &&
	event.type != WebKit::WebInputEvent::GestureFlingStart)
	return false;

	RenderWidgetHostView* view = render_widget_host_->GetView();
	if (!view->IsShowing())
	return false;

	const gfx::Rect& bounds = view->GetViewBounds();
	if (bounds.IsEmpty())
	return false;

	if (event.type == WebKit::WebInputEvent::GestureFlingStart) {
	// Check to see if the fling is in the same direction of the overscroll.
	const WebKit::WebGestureEvent gesture =
	static_cast<const WebKit::WebGestureEvent&>(event);
	switch (overscroll_mode_) {
	case OVERSCROLL_EAST:
	if (gesture.data.flingStart.velocityX < 0)
	return false;
	break;
	case OVERSCROLL_WEST:
	if (gesture.data.flingStart.velocityX > 0)
	return false;
	break;
	case OVERSCROLL_NORTH:
	if (gesture.data.flingStart.velocityY > 0)
	return false;
	break;
	case OVERSCROLL_SOUTH:
	if (gesture.data.flingStart.velocityY < 0)
	return false;
	break;
	case OVERSCROLL_NONE:
	case OVERSCROLL_COUNT:
	NOTREACHED();
	}
	}

	float ratio, threshold;
	if (overscroll_mode_ == OVERSCROLL_WEST \|\|
	overscroll_mode_ == OVERSCROLL_EAST) {
	ratio = fabs(overscroll_delta_x_) / bounds.width();
	threshold = GetOverscrollConfig(OVERSCROLL_CONFIG_HORIZ_THRESHOLD_COMPLETE);
	} else {
	ratio = fabs(overscroll_delta_y_) / bounds.height();
	threshold = GetOverscrollConfig(OVERSCROLL_CONFIG_VERT_THRESHOLD_COMPLETE);
	}

	return ratio >= threshold;
	}

	bool OverscrollController::DispatchEventResetsState(
	const WebKit::WebInputEvent& event) const {
	switch (event.type) {
	case WebKit::WebInputEvent::MouseWheel: {
	// Only wheel events with precise deltas (i.e. from trackpad) contribute
	// to the overscroll gesture.
	const WebKit::WebMouseWheelEvent& wheel =
	static_cast<const WebKit::WebMouseWheelEvent&>(event);
	return !wheel.hasPreciseScrollingDeltas;
	}

	case WebKit::WebInputEvent::GestureScrollUpdate:
	case WebKit::WebInputEvent::GestureFlingCancel:
	return false;

	default:
	// Touch events can arrive during an overscroll gesture initiated by
	// touch-scrolling. These events should not reset the overscroll state.
	return !WebKit::WebInputEvent::isTouchEventType(event.type);
	}
	}

	bool OverscrollController::ProcessEventForOverscroll(
	const WebKit::WebInputEvent& event) {
	bool event_processed = false;
	switch (event.type) {
	case WebKit::WebInputEvent::MouseWheel: {
	const WebKit::WebMouseWheelEvent& wheel =
	static_cast<const WebKit::WebMouseWheelEvent&>(event);
	if (!wheel.hasPreciseScrollingDeltas)
	break;

	ProcessOverscroll(wheel.deltaX * wheel.accelerationRatioX,
	wheel.deltaY * wheel.accelerationRatioY,
	wheel.type);
	event_processed = true;
	break;
	}
	case WebKit::WebInputEvent::GestureScrollUpdate: {
	const WebKit::WebGestureEvent& gesture =
	static_cast<const WebKit::WebGestureEvent&>(event);
	ProcessOverscroll(gesture.data.scrollUpdate.deltaX,
	gesture.data.scrollUpdate.deltaY,
	gesture.type);
	event_processed = true;
	break;
	}
	case WebKit::WebInputEvent::GestureFlingStart: {
	const float kFlingVelocityThreshold = 1100.f;
	const WebKit::WebGestureEvent& gesture =
	static_cast<const WebKit::WebGestureEvent&>(event);
	float velocity_x = gesture.data.flingStart.velocityX;
	float velocity_y = gesture.data.flingStart.velocityY;
	if (fabs(velocity_x) > kFlingVelocityThreshold) {
	if ((overscroll_mode_ == OVERSCROLL_WEST && velocity_x < 0) \|\|
	(overscroll_mode_ == OVERSCROLL_EAST && velocity_x > 0)) {
	CompleteAction();
	event_processed = true;
	break;
	}
	} else if (fabs(velocity_y) > kFlingVelocityThreshold) {
	if ((overscroll_mode_ == OVERSCROLL_NORTH && velocity_y < 0) \|\|
	(overscroll_mode_ == OVERSCROLL_SOUTH && velocity_y > 0)) {
	CompleteAction();
	event_processed = true;
	break;
	}
	}

	// Reset overscroll state if fling didn't complete the overscroll gesture.
	SetOverscrollMode(OVERSCROLL_NONE);
	break;
	}

	default:
	DCHECK(WebKit::WebInputEvent::isGestureEventType(event.type) \|\|
	WebKit::WebInputEvent::isTouchEventType(event.type))
	<< "Received unexpected event: " << event.type;
	}
	return event_processed;
	}

	void OverscrollController::ProcessOverscroll(float delta_x,
	float delta_y,
	WebKit::WebInputEvent::Type type) {
	if (scroll_state_ != STATE_CONTENT_SCROLLING)
	overscroll_delta_x_ += delta_x;
	overscroll_delta_y_ += delta_y;

	float horiz_threshold = GetOverscrollConfig(
	WebInputEvent::isGestureEventType(type) ?
	OVERSCROLL_CONFIG_HORIZ_THRESHOLD_START_TOUCHSCREEN :
	OVERSCROLL_CONFIG_HORIZ_THRESHOLD_START_TOUCHPAD);
	float vert_threshold = GetOverscrollConfig(
	OVERSCROLL_CONFIG_VERT_THRESHOLD_START);
	if (fabs(overscroll_delta_x_) <= horiz_threshold &&
	fabs(overscroll_delta_y_) <= vert_threshold) {
	SetOverscrollMode(OVERSCROLL_NONE);
	return;
	}

	// Compute the current overscroll direction. If the direction is different
	// from the current direction, then always switch to no-overscroll mode first
	// to make sure that subsequent scroll events go through to the page first.
	OverscrollMode new_mode = OVERSCROLL_NONE;
	const float kMinRatio = 2.5;
	if (fabs(overscroll_delta_x_) > horiz_threshold &&
	fabs(overscroll_delta_x_) > fabs(overscroll_delta_y_) * kMinRatio)
	new_mode = overscroll_delta_x_ > 0.f ? OVERSCROLL_EAST : OVERSCROLL_WEST;
	else if (fabs(overscroll_delta_y_) > vert_threshold &&
	fabs(overscroll_delta_y_) > fabs(overscroll_delta_x_) * kMinRatio)
	new_mode = overscroll_delta_y_ > 0.f ? OVERSCROLL_SOUTH : OVERSCROLL_NORTH;

	if (overscroll_mode_ == OVERSCROLL_NONE)
	SetOverscrollMode(new_mode);
	else if (new_mode != overscroll_mode_)
	SetOverscrollMode(OVERSCROLL_NONE);

	if (overscroll_mode_ == OVERSCROLL_NONE)
	return;

	// Tell the delegate about the overscroll update so that it can update
	// the display accordingly (e.g. show history preview etc.).
	if (delegate_) {
	// 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) > horiz_threshold) {
	if (delegate_delta_x < 0)
	delegate_delta_x += horiz_threshold;
	else
	delegate_delta_x -= horiz_threshold;
	} else {
	delegate_delta_x = 0.f;
	}

	float delegate_delta_y = overscroll_delta_y_;
	if (fabs(delegate_delta_y) > vert_threshold) {
	if (delegate_delta_y < 0)
	delegate_delta_y += vert_threshold;
	else
	delegate_delta_y -= vert_threshold;
	} else {
	delegate_delta_y = 0.f;
	}
	delegate_->OnOverscrollUpdate(delegate_delta_x, delegate_delta_y);
	}
	}

	void OverscrollController::CompleteAction() {
	if (delegate_)
	delegate_->OnOverscrollComplete(overscroll_mode_);
	overscroll_mode_ = OVERSCROLL_NONE;
	overscroll_delta_x_ = overscroll_delta_y_ = 0.f;
	}

	void OverscrollController::SetOverscrollMode(OverscrollMode mode) {
	if (overscroll_mode_ == mode)
	return;
	OverscrollMode old_mode = overscroll_mode_;
	overscroll_mode_ = mode;
	if (overscroll_mode_ == OVERSCROLL_NONE)
	overscroll_delta_x_ = overscroll_delta_y_ = 0.f;
	else
	scroll_state_ = STATE_OVERSCROLLING;
	if (delegate_)
	delegate_->OnOverscrollModeChange(old_mode, overscroll_mode_);
	}

	} // namespace content