Update EventExecutorLinux to use mouse wheel deltas if present.

remoting/host/event_executor_linux.cc

 // 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 "remoting/host/event_executor.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/XTest.h>
 #include <X11/extensions/XInput.h>
 
@@ skipping 15 matching lines @@
 
 using protocol::ClipboardEvent;
 using protocol::KeyEvent;
 using protocol::MouseEvent;
 
 // USB to XKB keycode map table.
 #define USB_KEYMAP(usb, xkb, win, mac) {usb, xkb}
 #include "ui/base/keycodes/usb_keycode_map.h"
 #undef USB_KEYMAP
 
+// Pixel-to-wheel-ticks conversion ratio used by GTK.
+const float kWheelTicksPerPixel = 3.0f / 160.0f;

[garykac, 2012/10/13 01:46:28]

nit: Add // From Source/WebKit/chromium/src/gtk/WebInputFactory.cc.

[Wez, 2012/10/13 02:50:46]

Done.

+
 // A class to generate events on Linux.
 class EventExecutorLinux : public EventExecutor {
  public:
   explicit EventExecutorLinux(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   virtual ~EventExecutorLinux();
 
   bool Init();
 
   // Clipboard stub interface.
@@ skipping 24 matching lines @@
   // Compensates for global button mappings and resets the XTest device mapping.
   void InitMouseButtonMap();
   int MouseButtonToX11ButtonNumber(MouseEvent::MouseButton button);
   int HorizontalScrollWheelToX11ButtonNumber(int dx);
   int VerticalScrollWheelToX11ButtonNumber(int dy);
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   std::set<int> pressed_keys_;
   SkIPoint latest_mouse_position_;
+  float wheel_ticks_x_;
+  float wheel_ticks_y_;
 
   // X11 graphics context.
   Display* display_;
   Window root_window_;
 
   int test_event_base_;
   int test_error_base_;
 
   int pointer_button_map_[kNumPointerButtons];
 
   scoped_ptr<Clipboard> clipboard_;
 
   DISALLOW_COPY_AND_ASSIGN(EventExecutorLinux);
 };
 
 EventExecutorLinux::EventExecutorLinux(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : task_runner_(task_runner),
       latest_mouse_position_(SkIPoint::Make(-1, -1)),
+      wheel_ticks_x_(0.0f),
+      wheel_ticks_y_(0.0f),
       display_(XOpenDisplay(NULL)),
       root_window_(BadValue) {
 #if defined(REMOTING_HOST_LINUX_CLIPBOARD)
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&EventExecutorLinux::InitClipboard, base::Unretained(this)));
   }
 #endif  // REMOTING_HOST_LINUX_CLIPBOARD
 }
@@ skipping 148 matching lines @@
     }
 
     VLOG(3) << "Button " << event.button()
             << " received, sending "
             << (event.button_down() ? "down " : "up ")
             << button_number;
     XTestFakeButtonEvent(display_, button_number, event.button_down(),
                          CurrentTime);
   }
 
-  if (event.has_wheel_offset_y() && event.wheel_offset_y() != 0) {
-    int dy = event.wheel_offset_y();
-    InjectScrollWheelClicks(VerticalScrollWheelToX11ButtonNumber(dy), abs(dy));
+  int ticks_y = 0;
+  if (event.has_wheel_delta_y()) {
+    wheel_ticks_y_ += event.wheel_delta_y() * kWheelTicksPerPixel;

[garykac, 2012/10/13 01:46:28]

Since we're using floats, do we need to be concerned about wheel_ticks_y_ =
0.99999 not firing a wheel event (when it probably should)?

[Wez, 2012/10/13 02:50:46]

That sounds like a good improvement for a future CL to me. :)

+    ticks_y = static_cast<int>(wheel_ticks_y_);
+    wheel_ticks_y_ -= ticks_y;
+  } else if (event.has_wheel_offset_y()) {
+    ticks_y = event.wheel_offset_y();
   }
-  if (event.has_wheel_offset_x() && event.wheel_offset_x() != 0) {
-    int dx = event.wheel_offset_x();
-    InjectScrollWheelClicks(HorizontalScrollWheelToX11ButtonNumber(dx),
-                            abs(dx));
+  if (ticks_y != 0) {
+    InjectScrollWheelClicks(VerticalScrollWheelToX11ButtonNumber(ticks_y),
+                            abs(ticks_y));
+  }
+
+  int ticks_x = 0;
+  if (event.has_wheel_delta_x()) {
+    wheel_ticks_x_ += event.wheel_delta_x() * kWheelTicksPerPixel;
+    ticks_x = static_cast<int>(wheel_ticks_x_);
+    wheel_ticks_x_ -= ticks_x;
+  } else if (event.has_wheel_offset_x()) {
+    ticks_x = event.wheel_offset_x();
+  }
+  if (ticks_x != 0) {
+    InjectScrollWheelClicks(HorizontalScrollWheelToX11ButtonNumber(ticks_x),
+                            abs(ticks_x));
   }
 
   XFlush(display_);
 }
 
 void EventExecutorLinux::InitMouseButtonMap() {
   // TODO(rmsousa): Run this on global/device mapping change events.
 
   // Do not touch global pointer mapping, since this may affect the local user.
   // Instead, try to work around it by reversing the mapping.
@@ skipping 125 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   scoped_ptr<EventExecutorLinux> executor(
       new EventExecutorLinux(main_task_runner));
   if (!executor->Init())
     return scoped_ptr<EventExecutor>(NULL);
   return executor.PassAs<EventExecutor>();
 }
 
 }  // namespace remoting