Protoype Mac input event filter

content/browser/renderer_host/render_widget_host_view_mac.mm

 // 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/render_widget_host_view_mac.h"
 
 #import <objc/runtime.h>
 #include <OpenGL/gl.h>
 #include <QuartzCore/QuartzCore.h>
 
@@ skipping 57 matching lines @@
 #include "ui/base/layout.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
+#include "ui/gfx/geometry/vector2d_f.h"
 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
 #include "ui/gfx/screen.h"
 #include "ui/gl/gl_switches.h"
 
 using content::BrowserAccessibility;
 using content::BrowserAccessibilityManager;
 using content::EditCommand;
 using content::FrameTreeNode;
 using content::NativeWebKeyboardEvent;
 using content::RenderFrameHost;
@@ skipping 296 matching lines @@
   results.orientationType =
       content::RenderWidgetHostViewBase::GetOrientationTypeForDesktop(display);
 
   return results;
 }
 
 }  // namespace
 
 namespace content {
 
+class WheelEventRailFilterMac {
+ public:
+  WheelEventRailFilterMac() :
+      mode_(MODE_UNINITIALIZED) {
+  }
+
+  ~WheelEventRailFilterMac() {
+  }
+
+  WebMouseWheelEvent FilterWheelEvent(const WebMouseWheelEvent& event) {
+    // This number came from 0.5 feeling too big and 0.9 feeling too small.
+    const float kDecayConstant = 0.8f;
+    // Require a slightly-more-than-diagonal motion against the current
+    // scroll to break the rails.
+    const float kSinThetaToBreakRails = 0.8f;
+    // Require a consistently-unidirectional motion to reset the rails
+    // after they have been broken.
+    const float kSinThetaToResetRails = 0.02f;
+
+    if (event.phase == blink::WebMouseWheelEvent::PhaseBegan) {
+      mode_ = MODE_UNINITIALIZED;
+      decayed_delta_ = gfx::Vector2dF();
+    }
+    if (event.deltaX == 0 && event.deltaY == 0)
+      return event;
+
+    decayed_delta_.Scale(kDecayConstant);
+    decayed_delta_ += gfx::Vector2dF(fabsf(event.deltaX), fabsf(event.deltaY));
+
+    float sin_theta_horizontal = decayed_delta_.y() / decayed_delta_.Length();
+    float sin_theta_vertical = decayed_delta_.x() / decayed_delta_.Length();
+
+    switch (mode_) {
+      case MODE_UNINITIALIZED:
+        if (decayed_delta_.x() > decayed_delta_.y())
+          mode_ = MODE_HORIZONTAL;
+        else
+          mode_ = MODE_VERTICAL;
+        break;
+      case MODE_HORIZONTAL:
+        if (sin_theta_horizontal > kSinThetaToBreakRails)
+          mode_ = MODE_FREE;
+        break;
+      case MODE_VERTICAL:
+        if (sin_theta_vertical > kSinThetaToBreakRails)
+          mode_ = MODE_FREE;
+        break;
+      case MODE_FREE:
+        if (sin_theta_horizontal < kSinThetaToResetRails)
+          mode_ = MODE_HORIZONTAL;
+        if (sin_theta_vertical < kSinThetaToResetRails)
+          mode_ = MODE_VERTICAL;
+        break;
+    }
+
+    WebMouseWheelEvent result = event;
+    switch (mode_) {
+      case MODE_HORIZONTAL:
+        printf("mode:Horiz\n");
+        result.deltaY = 0;
+        break;
+      case MODE_VERTICAL:
+        printf("mode:Vert\n");
+        result.deltaX = 0;
+        break;
+      default:
+        printf("Free\n");
+        break;
+    }
+    return result;
+  }
+  
+ private:
+  enum Mode {
+    MODE_UNINITIALIZED,
+    MODE_HORIZONTAL,
+    MODE_VERTICAL,
+    MODE_FREE,
+  };
+  Mode mode_;
+  gfx::Vector2dF decayed_delta_;
+  gfx::Vector2dF decayed_delta_other_;
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, public:
 
 ui::Layer* RenderWidgetHostViewMac::DelegatedFrameHostGetLayer() const {
   return root_layer_.get();
 }
 
 bool RenderWidgetHostViewMac::DelegatedFrameHostIsVisible() const {
   return !render_widget_host_->is_hidden();
 }
@@ skipping 114 matching lines @@
 void RenderWidgetHostViewBase::GetDefaultScreenInfo(
     blink::WebScreenInfo* results) {
   *results = GetWebScreenInfo(NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewMac, public:
 
 RenderWidgetHostViewMac::RenderWidgetHostViewMac(RenderWidgetHost* widget,
                                                  bool is_guest_view_hack)
-    : render_widget_host_(RenderWidgetHostImpl::From(widget)),
+    : wheel_event_rail_filter_(new WheelEventRailFilterMac),
+      render_widget_host_(RenderWidgetHostImpl::From(widget)),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       can_compose_inline_(true),
       browser_compositor_state_(BrowserCompositorDestroyed),
       browser_compositor_placeholder_(new BrowserCompositorMacPlaceholder),
       is_loading_(false),
       allow_pause_for_resize_or_repaint_(true),
       is_guest_view_hack_(is_guest_view_hack),
       fullscreen_parent_host_view_(NULL),
       weak_factory_(this) {
   // |cocoa_view_| owns us and we will be deleted when |cocoa_view_|
@@ skipping 1711 matching lines @@
     return;
   }
 
   if (renderWidgetHostView_->render_widget_host_) {
     // History-swiping is not possible if the logic reaches this point.
     // Allow rubber-banding in both directions.
     bool canRubberbandLeft = true;
     bool canRubberbandRight = true;
     const WebMouseWheelEvent webEvent = WebInputEventFactory::mouseWheelEvent(
         event, self, canRubberbandLeft, canRubberbandRight);
-    renderWidgetHostView_->render_widget_host_->ForwardWheelEvent(webEvent);
+    renderWidgetHostView_->render_widget_host_->ForwardWheelEvent(
+        renderWidgetHostView_->wheel_event_rail_filter_->FilterWheelEvent(
+            webEvent));
   }
 
   if (endWheelMonitor_) {
     [NSEvent removeMonitor:endWheelMonitor_];
     endWheelMonitor_ = nil;
   }
 }
 
 - (void)beginGestureWithEvent:(NSEvent*)event {
   [responderDelegate_ beginGestureWithEvent:event];
@@ skipping 102 matching lines @@
           return blockEvent;
       }];
   }
 
   // This is responsible for content scrolling!
   if (renderWidgetHostView_->render_widget_host_) {
     BOOL canRubberbandLeft = [responderDelegate_ canRubberbandLeft:self];
     BOOL canRubberbandRight = [responderDelegate_ canRubberbandRight:self];
     const WebMouseWheelEvent webEvent = WebInputEventFactory::mouseWheelEvent(
         event, self, canRubberbandLeft, canRubberbandRight);
-    renderWidgetHostView_->render_widget_host_->ForwardWheelEvent(webEvent);
+    renderWidgetHostView_->render_widget_host_->ForwardWheelEvent(
+        renderWidgetHostView_->wheel_event_rail_filter_->FilterWheelEvent(
+            webEvent));
   }
 }
 
 // Called repeatedly during a pinch gesture, with incremental change values.
 - (void)magnifyWithEvent:(NSEvent*)event {
   if (!renderWidgetHostView_->render_widget_host_)
     return;
 
   // If, due to nesting of multiple gestures (e.g, from multiple touch
   // devices), the beginning of the gesture has been lost, skip the remainder
@@ skipping 1056 matching lines @@
 
 // "-webkit-app-region: drag | no-drag" is implemented on Mac by excluding
 // regions that are not draggable. (See ControlRegionView in
 // native_app_window_cocoa.mm). This requires the render host view to be
 // draggable by default.
 - (BOOL)mouseDownCanMoveWindow {
   return YES;
 }
 
 @end