Switch to standard integer types in win8/.

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 <stdint.h>
 #include <windows.foundation.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/win/metro.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_switches.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_sender.h"
 #include "ui/events/gesture_detection/motion_event.h"
@@ skipping 175 matching lines @@
                    TERMINATE_USING_KEY_SEQUENCE));
   }
 
   void OnOpenURLOnDesktop(const base::FilePath& shortcut,
                           const base::string16& url) {
     ui_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ChromeAppViewAsh::OnOpenURLOnDesktop,
                               base::Unretained(app_view_), shortcut, url));
   }
 
-  void OnSetCursor(int64 cursor) {
+  void OnSetCursor(int64_t cursor) {
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&ChromeAppViewAsh::OnSetCursor, base::Unretained(app_view_),
                    reinterpret_cast<HCURSOR>(cursor)));
   }
 
   void OnDisplayFileOpenDialog(const base::string16& title,
                                const base::string16& filter,
                                const base::FilePath& default_path,
                                bool allow_multiple_files) {
@@ skipping 23 matching lines @@
                                          base::Unretained(app_view_), x, y));
   }
 
   void OnImeCancelComposition() {
     ui_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ChromeAppViewAsh::OnImeCancelComposition,
                               base::Unretained(app_view_)));
   }
 
   void OnImeTextInputClientChanged(
-      const std::vector<int32>& input_scopes,
+      const std::vector<int32_t>& input_scopes,
       const std::vector<metro_viewer::CharacterBounds>& character_bounds) {
     ui_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ChromeAppViewAsh::OnImeUpdateTextInputClient,
                               base::Unretained(app_view_), input_scopes,
                               character_bounds));
   }
 
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
   ChromeAppViewAsh* app_view_;
 };
@@ skipping 10 matching lines @@
   // 3-  Posting WM_CLOSE to the core window.
   dispatcher->ProcessEvents(
       winui::Core::CoreProcessEventsOption
           ::CoreProcessEventsOption_ProcessUntilQuit);
 
   // Wind down the thread's chrome message loop.
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
 // Helper to return the state of the shift/control/alt keys.
-uint32 GetKeyboardEventFlags() {
-  uint32 flags = 0;
+uint32_t GetKeyboardEventFlags() {
+  uint32_t flags = 0;
   if (ui::win::IsShiftPressed())
     flags |= ui::EF_SHIFT_DOWN;
   if (ui::win::IsCtrlPressed())
     flags |= ui::EF_CONTROL_DOWN;
   if (ui::win::IsAltPressed())
     flags |= ui::EF_ALT_DOWN;
   return flags;
 }
 
 bool LaunchChromeBrowserProcess(const wchar_t* additional_parameters,
@@ skipping 136 matching lines @@
   }
 
   bool IsMouse() const {
     return IsType(windevs::Input::PointerDeviceType_Mouse);
   }
 
   bool IsTouch() const {
     return IsType(windevs::Input::PointerDeviceType_Touch);
   }
 
-  int32 wheel_delta() const {
-    return wheel_delta_;
-  }
+  int32_t wheel_delta() const { return wheel_delta_; }
 
   // Identifies the button that changed.
   ui::EventFlags changed_button() const {
     switch (update_kind_) {
       case winui::Input::PointerUpdateKind_LeftButtonPressed:
         return ui::EF_LEFT_MOUSE_BUTTON;
       case winui::Input::PointerUpdateKind_LeftButtonReleased:
         return ui::EF_LEFT_MOUSE_BUTTON;
       case winui::Input::PointerUpdateKind_RightButtonPressed:
         return ui::EF_RIGHT_MOUSE_BUTTON;
       case winui::Input::PointerUpdateKind_RightButtonReleased:
         return ui::EF_RIGHT_MOUSE_BUTTON;
       case winui::Input::PointerUpdateKind_MiddleButtonPressed:
         return ui::EF_MIDDLE_MOUSE_BUTTON;
       case winui::Input::PointerUpdateKind_MiddleButtonReleased:
         return ui::EF_MIDDLE_MOUSE_BUTTON;
       default:
         return ui::EF_NONE;
     }
   }
 
-  uint32 mouse_down_flags() const { return mouse_down_flags_; }
+  uint32_t mouse_down_flags() const { return mouse_down_flags_; }
 
   int x() const { return x_; }
   int y() const { return y_; }
 
-  uint32 pointer_id() const {
-    return pointer_id_;
-  }
+  uint32_t pointer_id() const { return pointer_id_; }
 
-  uint64 timestamp() const { return timestamp_; }
+  uint64_t 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_;
+  uint32_t pointer_id_;
   winui::Input::PointerUpdateKind update_kind_;
   mswr::ComPtr<winui::Input::IPointerPoint> pointer_point_;
-  uint64 timestamp_;
+  uint64_t timestamp_;
 
   // Bitmask of ui::EventFlags corresponding to the buttons that are currently
   // down.
-  uint32 mouse_down_flags_;
+  uint32_t mouse_down_flags_;
 
   // Set to true for a horizontal wheel message.
   boolean is_horizontal_wheel_;
 
   // The metro device scale factor as reported by the winrt interfaces.
   float metro_dpi_scale_;
   // The win32 dpi scale which is queried via GetDeviceCaps. Please refer to
   // ui/gfx/win/dpi.cc for more information.
   float win32_dpi_scale_;
 
@@ skipping 364 matching lines @@
   delete folder_picker;
 }
 
 void ChromeAppViewAsh::OnImeCancelComposition() {
   if (!text_service_)
     return;
   text_service_->CancelComposition();
 }
 
 void ChromeAppViewAsh::OnImeUpdateTextInputClient(
-    const std::vector<int32>& input_scopes,
+    const std::vector<int32_t>& input_scopes,
     const std::vector<metro_viewer::CharacterBounds>& character_bounds) {
   if (!text_service_)
     return;
   text_service_->OnDocumentChanged(input_scopes, character_bounds);
 }
 
 void ChromeAppViewAsh::OnImePopupChanged(ImePopupObserver::EventType event) {
   if (!ui_channel_)
     return;
   switch (event) {
@@ skipping 51 matching lines @@
   if (!input_source_->GetActiveSource(&langid, &is_ime)) {
     LOG(ERROR) << "GetActiveSource failed";
     return;
   }
   ui_channel_->Send(new MetroViewerHostMsg_ImeInputSourceChanged(langid,
                                                                  is_ime));
 }
 
 void ChromeAppViewAsh::OnCompositionChanged(
     const base::string16& text,
-    int32 selection_start,
-    int32 selection_end,
+    int32_t selection_start,
+    int32_t selection_end,
     const std::vector<metro_viewer::UnderlineInfo>& underlines) {
   ui_channel_->Send(new MetroViewerHostMsg_ImeCompositionChanged(
       text, selection_start, selection_end, underlines));
 }
 
 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,
+                                       uint32_t flags,
                                        ui::EventFlags changed_button,
                                        bool is_horizontal_wheel) {
   if (!ui_channel_)
     return;
   MetroViewerHostMsg_MouseButtonParams params;
-  params.x = static_cast<int32>(x);
-  params.y = static_cast<int32>(y);
-  params.extra = static_cast<int32>(extra);
+  params.x = static_cast<int32_t>(x);
+  params.y = static_cast<int32_t>(y);
+  params.extra = static_cast<int32_t>(extra);
   params.event_type = event_type;
-  params.flags = static_cast<int32>(flags);
+  params.flags = static_cast<int32_t>(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_;
+  uint32_t 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:
@@ skipping 107 matching lines @@
     return S_OK;
 
   PointerInfoHandler pointer(metro_dpi_scale_, win32_dpi_scale_);
   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.is_horizontal_wheel());
+                    static_cast<uint32_t>(pointer.changed_button()) |
+                        GetKeyboardEventFlags(),
+                    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;
 }
 
@@ skipping 71 matching lines @@
   winui::Core::CorePhysicalKeyStatus status;
   hr = args->get_KeyStatus(&status);
   if (FAILED(hr))
     return hr;
 
   winui::Core::CoreAcceleratorKeyEventType event_type;
   hr = args->get_EventType(&event_type);
   if (FAILED(hr))
     return hr;
 
-  uint32 keyboard_flags = GetKeyboardEventFlags();
+  uint32_t keyboard_flags = GetKeyboardEventFlags();
 
   switch (event_type) {
     case winui::Core::CoreAcceleratorKeyEventType_SystemCharacter:
       ui_channel_->Send(new MetroViewerHostMsg_Character(virtual_key,
                                                          status.RepeatCount,
                                                          status.ScanCode,
                                                          keyboard_flags));
       break;
 
     case winui::Core::CoreAcceleratorKeyEventType_SystemKeyDown:
@@ skipping 153 matching lines @@
   if (!window_ || !ui_channel_) {
     return S_OK;
   }
 
   // winui::Core::IWindowSizeChangedEventArgs args->Size appears to return
   // scaled values under HiDPI. We will instead use GetWindowRect() which
   // should always return values in Pixels.
   RECT rect = {0};
   ::GetWindowRect(core_window_hwnd_, &rect);
 
-  uint32 cx = static_cast<uint32>(rect.right - rect.left);
-  uint32 cy = static_cast<uint32>(rect.bottom - rect.top);
+  uint32_t cx = static_cast<uint32_t>(rect.right - rect.left);
+  uint32_t cy = static_cast<uint32_t>(rect.bottom - rect.top);
 
   DVLOG(1) << "Window size changed: width=" << cx << ", height=" << cy;
   ui_channel_->Send(new MetroViewerHostMsg_WindowSizeChanged(cx, cy));
   return S_OK;
 }
 
 void ChromeAppViewAsh::StartChromeOSMode() {
   static int ms_elapsed = 0;
 
   if (!IPC::Channel::IsNamedServerInitialized(
@@ skipping 64 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;
 }