Cleans up events to just the parts we're actually using

services/native_viewport/platform_viewport_x11.cc

 // Copyright 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 "services/native_viewport/platform_viewport.h"
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
+#include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/converters/input_events/mojo_extended_key_event_data.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/gfx/rect.h"
 #include "ui/platform_window/platform_window.h"
 #include "ui/platform_window/platform_window_delegate.h"
 #include "ui/platform_window/x11/x11_window.h"
 
 namespace native_viewport {
+namespace {
+
+float ConvertUIWheelValueToMojoValue(int offset) {
+  // Mojo's event type takes a value between -1 and 1. Normalize by allowing
+  // up to 20 of ui's offset. This is a bit arbitrary.
+  return std::max(
+      -1.0f, std::min(1.0f, static_cast<float>(offset) /
+                                (20 * static_cast<float>(
+                                          ui::MouseWheelEvent::kWheelDelta))));
+}
+}  // namespace
 
 class PlatformViewportX11 : public PlatformViewport,
                             public ui::PlatformWindowDelegate {
  public:
   explicit PlatformViewportX11(Delegate* delegate) : delegate_(delegate) {
   }
 
   ~PlatformViewportX11() override {
     // Destroy the platform-window while |this| is still alive.
     platform_window_.reset();
@@ skipping 19 matching lines @@
   void Hide() override { platform_window_->Hide(); }
 
   void Close() override { platform_window_->Close(); }
 
   gfx::Size GetSize() override { return metrics_->size.To<gfx::Size>(); }
 
   void SetBounds(const gfx::Rect& bounds) override {
     platform_window_->SetBounds(bounds);
   }
 
-  void SetCapture() override { platform_window_->SetCapture(); }
-
-  void ReleaseCapture() override { platform_window_->ReleaseCapture(); }
-
   // ui::PlatformWindowDelegate:
   void OnBoundsChanged(const gfx::Rect& new_bounds) override {
     metrics_->size = mojo::Size::From(new_bounds.size());
     delegate_->OnMetricsChanged(metrics_.Clone());
   }
 
   void OnDamageRect(const gfx::Rect& damaged_region) override {}
 
   void DispatchEvent(ui::Event* event) override {
-    delegate_->OnEvent(event);
+    mojo::EventPtr mojo_event(mojo::Event::From(*event));
+    if (event->IsMouseWheelEvent()) {
+      // Mojo's event type has a different meaning for wheel events. Convert
+      // between the two.
+      ui::MouseWheelEvent* wheel_event =
+          static_cast<ui::MouseWheelEvent*>(event);
+      DCHECK(mojo_event->pointer_data);
+      mojo_event->pointer_data->horizontal_wheel =
+          ConvertUIWheelValueToMojoValue(wheel_event->x_offset());
+      mojo_event->pointer_data->horizontal_wheel =
+          ConvertUIWheelValueToMojoValue(wheel_event->y_offset());
+    }
+    delegate_->OnEvent(mojo_event.Pass());
+
+    switch (event->type()) {
+      case ui::ET_MOUSE_PRESSED:
+      case ui::ET_TOUCH_PRESSED:
+        platform_window_->SetCapture();
+        break;
+      case ui::ET_MOUSE_RELEASED:
+      case ui::ET_TOUCH_RELEASED:
+        platform_window_->ReleaseCapture();
+        break;
+      default:
+        break;
+    }
 
     // We want to emulate the WM_CHAR generation behaviour of Windows.
     //
     // On Linux, we've previously inserted characters by having
     // InputMethodAuraLinux take all key down events and send a character event
     // to the TextInputClient. This causes a mismatch in code that has to be
     // shared between Windows and Linux, including blink code. Now that we're
     // trying to have one way of doing things, we need to standardize on and
     // emulate Windows character events.
     //
     // This is equivalent to what we're doing in the current Linux port, but
     // done once instead of done multiple times in different places.
     if (event->type() == ui::ET_KEY_PRESSED) {
       ui::KeyEvent* key_press_event = static_cast<ui::KeyEvent*>(event);
       ui::KeyEvent char_event(key_press_event->GetCharacter(),
                               key_press_event->key_code(),
                               key_press_event->flags());
 
       DCHECK_EQ(key_press_event->GetCharacter(), char_event.GetCharacter());
       DCHECK_EQ(key_press_event->key_code(), char_event.key_code());
       DCHECK_EQ(key_press_event->flags(), char_event.flags());
 
       char_event.SetExtendedKeyEventData(
           make_scoped_ptr(new mojo::MojoExtendedKeyEventData(
               key_press_event->GetLocatedWindowsKeyboardCode(),
               key_press_event->GetText(),
               key_press_event->GetUnmodifiedText())));
       char_event.set_platform_keycode(key_press_event->platform_keycode());
 
-      delegate_->OnEvent(&char_event);
+      delegate_->OnEvent(mojo::Event::From(char_event));
     }
   }
 
   void OnCloseRequest() override { platform_window_->Close(); }
 
   void OnClosed() override { delegate_->OnDestroyed(); }
 
   void OnWindowStateChanged(ui::PlatformWindowState state) override {}
 
   void OnLostCapture() override {}
@@ skipping 11 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PlatformViewportX11);
 };
 
 // static
 scoped_ptr<PlatformViewport> PlatformViewport::Create(Delegate* delegate) {
   return make_scoped_ptr(new PlatformViewportX11(delegate));
 }
 
 }  // namespace native_viewport