Adding support for sending horizonatal mouse wheel information in Chrome ASH on Windows 8.

win8/metro_driver/chrome_app_view_ash.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 "win8/metro_driver/stdafx.h"
 #include "win8/metro_driver/chrome_app_view_ash.h"
 
 #include <corewindow.h>
 #include <shellapi.h>
 #include <windows.foundation.h>
@@ skipping 355 matching lines @@
 // This class helps decoding the pointer properties of an event.
 class ChromeAppViewAsh::PointerInfoHandler {
  public:
   PointerInfoHandler()
       : x_(0),
         y_(0),
         wheel_delta_(0),
         update_kind_(winui::Input::PointerUpdateKind_Other),
         timestamp_(0),
         pointer_id_(0),
-        mouse_down_flags_(0) {}
+        mouse_down_flags_(0),
+        is_horizontal_wheel_(0) {}
 
   HRESULT Init(winui::Core::IPointerEventArgs* args) {
     HRESULT hr = args->get_CurrentPoint(&pointer_point_);
     if (FAILED(hr))
       return hr;
 
     winfoundtn::Point point;
     hr = pointer_point_->get_Position(&point);
     if (FAILED(hr))
       return hr;
 
     mswr::ComPtr<winui::Input::IPointerPointProperties> properties;
     hr = pointer_point_->get_Properties(&properties);
     if (FAILED(hr))
       return hr;
 
     hr = properties->get_PointerUpdateKind(&update_kind_);
     if (FAILED(hr))
       return hr;
 
     hr = properties->get_MouseWheelDelta(&wheel_delta_);
     if (FAILED(hr))
       return hr;
 
+    is_horizontal_wheel_ = 0;
+    properties->get_IsHorizontalMouseWheel(&is_horizontal_wheel_);
+
     x_ = point.X;
     y_ = point.Y;
+
     pointer_point_->get_Timestamp(&timestamp_);
     pointer_point_->get_PointerId(&pointer_id_);
     // Map the OS touch event id to a range allowed by the gesture recognizer.
     if (IsTouch())
       pointer_id_ %= ui::GestureSequence::kMaxGesturePoints;
 
     boolean left_button_state;
     hr = properties->get_IsLeftButtonPressed(&left_button_state);
     if (FAILED(hr))
       return hr;
@@ skipping 63 matching lines @@
   int y() const { return y_; }
 
   uint32 pointer_id() const {
     return pointer_id_;
   }
 
   uint64 timestamp() const { return timestamp_; }
 
   winui::Input::PointerUpdateKind update_kind() const { return update_kind_; }
 
+  bool is_horizontal_wheel() const { return !!is_horizontal_wheel_; }
+
  private:
   int x_;
   int y_;
   int wheel_delta_;
   uint32 pointer_id_;
   winui::Input::PointerUpdateKind update_kind_;
   mswr::ComPtr<winui::Input::IPointerPoint> pointer_point_;
   uint64 timestamp_;
 
   // Bitmask of ui::EventFlags corresponding to the buttons that are currently
   // down.
   uint32 mouse_down_flags_;
 
+  // Set to true for a horizontal wheel message.
+  boolean is_horizontal_wheel_;
+
   DISALLOW_COPY_AND_ASSIGN(PointerInfoHandler);
 };
 
 ChromeAppViewAsh::ChromeAppViewAsh()
     : mouse_down_flags_(ui::EF_NONE),
       ui_channel_(nullptr),
       core_window_hwnd_(NULL) {
   DVLOG(1) << __FUNCTION__;
   globals.previous_state =
       winapp::Activation::ApplicationExecutionState_NotRunning;
@@ skipping 426 matching lines @@
 
 void ChromeAppViewAsh::OnTextCommitted(const base::string16& text) {
   ui_channel_->Send(new MetroViewerHostMsg_ImeTextCommitted(text));
 }
 
 void ChromeAppViewAsh::SendMouseButton(int x,
                                        int y,
                                        int extra,
                                        ui::EventType event_type,
                                        uint32 flags,
-                                       ui::EventFlags changed_button) {
+                                       ui::EventFlags changed_button,
+                                       bool is_horizontal_wheel) {
   MetroViewerHostMsg_MouseButtonParams params;
   params.x = static_cast<int32>(x);
   params.y = static_cast<int32>(y);
   params.extra = static_cast<int32>(extra);
   params.event_type = event_type;
   params.flags = static_cast<int32>(flags);
   params.changed_button = changed_button;
+  params.is_horizontal_wheel = is_horizontal_wheel;
   ui_channel_->Send(new MetroViewerHostMsg_MouseButton(params));
 }
 
 void ChromeAppViewAsh::GenerateMouseEventFromMoveIfNecessary(
     const PointerInfoHandler& pointer) {
   ui::EventType event_type;
   // For aura we want the flags to include the button that was released, thus
   // we or the old and new.
   uint32 mouse_down_flags = pointer.mouse_down_flags() | mouse_down_flags_;
   mouse_down_flags_ = pointer.mouse_down_flags();
   switch (pointer.update_kind()) {
     case winui::Input::PointerUpdateKind_LeftButtonPressed:
     case winui::Input::PointerUpdateKind_RightButtonPressed:
     case winui::Input::PointerUpdateKind_MiddleButtonPressed:
       event_type = ui::ET_MOUSE_PRESSED;
       break;
     case winui::Input::PointerUpdateKind_LeftButtonReleased:
     case winui::Input::PointerUpdateKind_RightButtonReleased:
     case winui::Input::PointerUpdateKind_MiddleButtonReleased:
       event_type = ui::ET_MOUSE_RELEASED;
       break;
     default:
       return;
   }
   SendMouseButton(pointer.x(), pointer.y(), 0, event_type,
                   mouse_down_flags | GetKeyboardEventFlags(),
-                  pointer.changed_button());
+                  pointer.changed_button(), pointer.is_horizontal_wheel());
 }
 
 HRESULT ChromeAppViewAsh::OnActivate(
     winapp::Core::ICoreApplicationView*,
     winapp::Activation::IActivatedEventArgs* args) {
   DVLOG(1) << __FUNCTION__;
   // Note: If doing more work in this function, you migth need to call
   // get_PreviousExecutionState() and skip the work if  the result is
   // ApplicationExecutionState_Running and globals.previous_state is too.
   args->get_PreviousExecutionState(&globals.previous_state);
@@ skipping 53 matching lines @@
     winui::Core::IPointerEventArgs* args) {
   PointerInfoHandler pointer;
   HRESULT hr = pointer.Init(args);
   if (FAILED(hr))
     return hr;
 
   if (pointer.IsMouse()) {
     mouse_down_flags_ = pointer.mouse_down_flags();
     SendMouseButton(pointer.x(), pointer.y(), 0, ui::ET_MOUSE_PRESSED,
                     mouse_down_flags_ | GetKeyboardEventFlags(),
-                    pointer.changed_button());
+                    pointer.changed_button(), pointer.is_horizontal_wheel());
   } else {
     DCHECK(pointer.IsTouch());
     ui_channel_->Send(new MetroViewerHostMsg_TouchDown(pointer.x(),
                                                        pointer.y(),
                                                        pointer.timestamp(),
                                                        pointer.pointer_id()));
   }
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnPointerReleased(
     winui::Core::ICoreWindow* sender,
     winui::Core::IPointerEventArgs* args) {
   PointerInfoHandler pointer;
   HRESULT hr = pointer.Init(args);
   if (FAILED(hr))
     return hr;
 
   if (pointer.IsMouse()) {
     mouse_down_flags_ = ui::EF_NONE;
     SendMouseButton(pointer.x(), pointer.y(), 0, ui::ET_MOUSE_RELEASED,
                     static_cast<uint32>(pointer.changed_button()) |
                     GetKeyboardEventFlags(),
-                    pointer.changed_button());
+                    pointer.changed_button(),
+                    pointer.is_horizontal_wheel());
   } else {
     DCHECK(pointer.IsTouch());
     ui_channel_->Send(new MetroViewerHostMsg_TouchUp(pointer.x(),
                                                      pointer.y(),
                                                      pointer.timestamp(),
                                                      pointer.pointer_id()));
   }
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnWheel(
     winui::Core::ICoreWindow* sender,
     winui::Core::IPointerEventArgs* args) {
   PointerInfoHandler pointer;
   HRESULT hr = pointer.Init(args);
   if (FAILED(hr))
     return hr;
   DCHECK(pointer.IsMouse());
   SendMouseButton(pointer.x(), pointer.y(), pointer.wheel_delta(),
-                  ui::ET_MOUSEWHEEL, ui::EF_NONE, ui::EF_NONE);
+                  ui::ET_MOUSEWHEEL, ui::EF_NONE, ui::EF_NONE,
+                  pointer.is_horizontal_wheel());
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnKeyDown(
     winui::Core::ICoreWindow* sender,
     winui::Core::IKeyEventArgs* args) {
   winsys::VirtualKey virtual_key;
   HRESULT hr = args->get_VirtualKey(&virtual_key);
   if (FAILED(hr))
     return hr;
@@ skipping 213 matching lines @@
   mswr::ComPtr<winapp::Core::ICoreApplicationExit> app_exit;
   CheckHR(core_app.As(&app_exit));
   globals.app_exit = app_exit.Detach();
 }
 
 IFACEMETHODIMP
 ChromeAppViewFactory::CreateView(winapp::Core::IFrameworkView** view) {
   *view = mswr::Make<ChromeAppViewAsh>().Detach();
   return (*view) ? S_OK :  E_OUTOFMEMORY;
 }