win8/metro_driver/chrome_app_view_ash.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "win8/metro_driver/stdafx.h"
   6 #include "win8/metro_driver/chrome_app_view_ash.h"
   7
   8 #include <corewindow.h>
   9 #include <shellapi.h>
  10 #include <windows.foundation.h>
  11
  12 #include "base/bind.h"
  13 #include "base/command_line.h"
  14 #include "base/files/file_path.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/path_service.h"
  17 #include "base/single_thread_task_runner.h"
  18 #include "base/win/metro.h"
  19 #include "base/win/win_util.h"
  20 #include "base/win/windows_version.h"
  21 #include "chrome/common/chrome_switches.h"
  22 #include "ipc/ipc_channel.h"
  23 #include "ipc/ipc_channel_proxy.h"
  24 #include "ipc/ipc_sender.h"
  25 #include "ui/events/gesture_detection/motion_event.h"
  26 #include "ui/gfx/geometry/point_conversions.h"
  27 #include "ui/gfx/win/dpi.h"
  28 #include "ui/metro_viewer/metro_viewer_messages.h"
  29 #include "win8/metro_driver/file_picker_ash.h"
  30 #include "win8/metro_driver/ime/ime_popup_monitor.h"
  31 #include "win8/metro_driver/ime/input_source.h"
  32 #include "win8/metro_driver/ime/text_service.h"
  33 #include "win8/metro_driver/metro_driver.h"
  34 #include "win8/metro_driver/winrt_utils.h"
  35 #include "win8/viewer/metro_viewer_constants.h"
  36
  37 typedef winfoundtn::ITypedEventHandler<
  38     winapp::Core::CoreApplicationView*,
  39     winapp::Activation::IActivatedEventArgs*> ActivatedHandler;
  40
  41 typedef winfoundtn::ITypedEventHandler<
  42     winui::Core::CoreWindow*,
  43     winui::Core::PointerEventArgs*> PointerEventHandler;
  44
  45 typedef winfoundtn::ITypedEventHandler<
  46     winui::Core::CoreWindow*,
  47     winui::Core::KeyEventArgs*> KeyEventHandler;
  48
  49 typedef winfoundtn::ITypedEventHandler<
  50     winui::Core::CoreDispatcher*,
  51     winui::Core::AcceleratorKeyEventArgs*> AcceleratorKeyEventHandler;
  52
  53 typedef winfoundtn::ITypedEventHandler<
  54     winui::Core::CoreWindow*,
  55     winui::Core::CharacterReceivedEventArgs*> CharEventHandler;
  56
  57 typedef winfoundtn::ITypedEventHandler<
  58     winui::Core::CoreWindow*,
  59     winui::Core::WindowActivatedEventArgs*> WindowActivatedHandler;
  60
  61 typedef winfoundtn::ITypedEventHandler<
  62     winui::Core::CoreWindow*,
  63     winui::Core::WindowSizeChangedEventArgs*> SizeChangedHandler;
  64
  65 typedef winfoundtn::ITypedEventHandler<
  66     winui::Input::EdgeGesture*,
  67     winui::Input::EdgeGestureEventArgs*> EdgeEventHandler;
  68
  69 // This function is exported by chrome.exe.
  70 typedef int (__cdecl *BreakpadExceptionHandler)(EXCEPTION_POINTERS* info);
  71
  72 // Global information used across the metro driver.
  73 struct Globals {
  74   winapp::Activation::ApplicationExecutionState previous_state;
  75   winapp::Core::ICoreApplicationExit* app_exit;
  76   BreakpadExceptionHandler breakpad_exception_handler;
  77 } globals;
  78
  79 extern float GetModernUIScale();
  80
  81 namespace {
  82
  83 enum KeyModifier {
  84   NONE,
  85   SHIFT = 1,
  86   CONTROL = 2,
  87   ALT = 4
  88 };
  89
  90 const int kChromeChannelPollTimerMs = 100;
  91
  92 // Helper function to send keystrokes via the SendInput function.
  93 // mnemonic_char: The keystroke to be sent.
  94 // modifiers: Combination with Alt, Ctrl, Shift, etc.
  95 void SendKeySequence(
  96     WORD mnemonic_char, KeyModifier modifiers) {
  97   INPUT keys[4] = {};  // Keyboard events
  98   int key_count = 0;  // Number of generated events
  99
 100   if (modifiers & SHIFT) {
 101     keys[key_count].type = INPUT_KEYBOARD;
 102     keys[key_count].ki.wVk = VK_SHIFT;
 103     keys[key_count].ki.wScan = MapVirtualKey(VK_SHIFT, 0);
 104     key_count++;
 105   }
 106
 107   if (modifiers & CONTROL) {
 108     keys[key_count].type = INPUT_KEYBOARD;
 109     keys[key_count].ki.wVk = VK_CONTROL;
 110     keys[key_count].ki.wScan = MapVirtualKey(VK_CONTROL, 0);
 111     key_count++;
 112   }
 113
 114   if (modifiers & ALT) {
 115     keys[key_count].type = INPUT_KEYBOARD;
 116     keys[key_count].ki.wVk = VK_MENU;
 117     keys[key_count].ki.wScan = MapVirtualKey(VK_MENU, 0);
 118     key_count++;
 119   }
 120
 121   keys[key_count].type = INPUT_KEYBOARD;
 122   keys[key_count].ki.wVk = mnemonic_char;
 123   keys[key_count].ki.wScan = MapVirtualKey(mnemonic_char, 0);
 124   key_count++;
 125
 126   bool should_sleep = key_count > 1;
 127
 128   // Send key downs.
 129   for (int i = 0; i < key_count; i++) {
 130     SendInput(1, &keys[ i ], sizeof(keys[0]));
 131     keys[i].ki.dwFlags |= KEYEVENTF_KEYUP;
 132     if (should_sleep)
 133       Sleep(10);
 134   }
 135
 136   // Now send key ups in reverse order.
 137   for (int i = key_count; i; i--) {
 138     SendInput(1, &keys[ i - 1 ], sizeof(keys[0]));
 139     if (should_sleep)
 140       Sleep(10);
 141   }
 142 }
 143
 144 class ChromeChannelListener : public IPC::Listener {
 145  public:
 146   ChromeChannelListener(base::MessageLoop* ui_loop, ChromeAppViewAsh* app_view)
 147       : ui_task_runner_(ui_loop->task_runner()), app_view_(app_view) {}
 148
 149   bool OnMessageReceived(const IPC::Message& message) override {
 150     IPC_BEGIN_MESSAGE_MAP(ChromeChannelListener, message)
 151       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ActivateDesktop,
 152                           OnActivateDesktop)
 153       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_MetroExit, OnMetroExit)
 154       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_OpenURLOnDesktop,
 155                           OnOpenURLOnDesktop)
 156       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_SetCursor, OnSetCursor)
 157       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_DisplayFileOpen,
 158                           OnDisplayFileOpenDialog)
 159       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_DisplayFileSaveAs,
 160                           OnDisplayFileSaveAsDialog)
 161       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_DisplaySelectFolder,
 162                           OnDisplayFolderPicker)
 163       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_SetCursorPos, OnSetCursorPos)
 164       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ImeCancelComposition,
 165                           OnImeCancelComposition)
 166       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ImeTextInputClientUpdated,
 167                           OnImeTextInputClientChanged)
 168       IPC_MESSAGE_UNHANDLED(__debugbreak())
 169     IPC_END_MESSAGE_MAP()
 170     return true;
 171   }
 172
 173   void OnChannelError() override {
 174     DVLOG(1) << "Channel error. Exiting.";
 175     ui_task_runner_->PostTask(
 176         FROM_HERE,
 177         base::Bind(&ChromeAppViewAsh::OnMetroExit, base::Unretained(app_view_),
 178                    TERMINATE_USING_KEY_SEQUENCE));
 179
 180     // In early Windows 8 versions the code above sometimes fails so we call
 181     // it a second time with a NULL window which just calls Exit().
 182     ui_task_runner_->PostDelayedTask(
 183         FROM_HERE,
 184         base::Bind(&ChromeAppViewAsh::OnMetroExit, base::Unretained(app_view_),
 185                    TERMINATE_USING_PROCESS_EXIT),
 186         base::TimeDelta::FromMilliseconds(100));
 187   }
 188
 189  private:
 190   void OnActivateDesktop(const base::FilePath& shortcut, bool ash_exit) {
 191     ui_task_runner_->PostTask(
 192         FROM_HERE, base::Bind(&ChromeAppViewAsh::OnActivateDesktop,
 193                               base::Unretained(app_view_), shortcut, ash_exit));
 194   }
 195
 196   void OnMetroExit() {
 197     ui_task_runner_->PostTask(
 198         FROM_HERE,
 199         base::Bind(&ChromeAppViewAsh::OnMetroExit, base::Unretained(app_view_),
 200                    TERMINATE_USING_KEY_SEQUENCE));
 201   }
 202
 203   void OnOpenURLOnDesktop(const base::FilePath& shortcut,
 204                           const base::string16& url) {
 205     ui_task_runner_->PostTask(
 206         FROM_HERE, base::Bind(&ChromeAppViewAsh::OnOpenURLOnDesktop,
 207                               base::Unretained(app_view_), shortcut, url));
 208   }
 209
 210   void OnSetCursor(int64 cursor) {
 211     ui_task_runner_->PostTask(
 212         FROM_HERE,
 213         base::Bind(&ChromeAppViewAsh::OnSetCursor, base::Unretained(app_view_),
 214                    reinterpret_cast<HCURSOR>(cursor)));
 215   }
 216
 217   void OnDisplayFileOpenDialog(const base::string16& title,
 218                                const base::string16& filter,
 219                                const base::FilePath& default_path,
 220                                bool allow_multiple_files) {
 221     ui_task_runner_->PostTask(
 222         FROM_HERE, base::Bind(&ChromeAppViewAsh::OnDisplayFileOpenDialog,
 223                               base::Unretained(app_view_), title, filter,
 224                               default_path, allow_multiple_files));
 225   }
 226
 227   void OnDisplayFileSaveAsDialog(
 228     const MetroViewerHostMsg_SaveAsDialogParams& params) {
 229     ui_task_runner_->PostTask(
 230         FROM_HERE, base::Bind(&ChromeAppViewAsh::OnDisplayFileSaveAsDialog,
 231                               base::Unretained(app_view_), params));
 232   }
 233
 234   void OnDisplayFolderPicker(const base::string16& title) {
 235     ui_task_runner_->PostTask(
 236         FROM_HERE, base::Bind(&ChromeAppViewAsh::OnDisplayFolderPicker,
 237                               base::Unretained(app_view_), title));
 238   }
 239
 240   void OnSetCursorPos(int x, int y) {
 241     VLOG(1) << "In IPC OnSetCursorPos: " << x << ", " << y;
 242     ui_task_runner_->PostTask(FROM_HERE,
 243                               base::Bind(&ChromeAppViewAsh::OnSetCursorPos,
 244                                          base::Unretained(app_view_), x, y));
 245   }
 246
 247   void OnImeCancelComposition() {
 248     ui_task_runner_->PostTask(
 249         FROM_HERE, base::Bind(&ChromeAppViewAsh::OnImeCancelComposition,
 250                               base::Unretained(app_view_)));
 251   }
 252
 253   void OnImeTextInputClientChanged(
 254       const std::vector<int32>& input_scopes,
 255       const std::vector<metro_viewer::CharacterBounds>& character_bounds) {
 256     ui_task_runner_->PostTask(
 257         FROM_HERE, base::Bind(&ChromeAppViewAsh::OnImeUpdateTextInputClient,
 258                               base::Unretained(app_view_), input_scopes,
 259                               character_bounds));
 260   }
 261
 262   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 263   ChromeAppViewAsh* app_view_;
 264 };
 265
 266 void RunMessageLoop(winui::Core::ICoreDispatcher* dispatcher) {
 267   // We're entering a nested message loop, let's allow dispatching
 268   // tasks while we're in there.
 269   base::MessageLoop::current()->SetNestableTasksAllowed(true);
 270
 271   // Enter main core message loop. There are several ways to exit it
 272   // Nicely:
 273   // 1 - User action like ALT-F4.
 274   // 2 - Calling ICoreApplicationExit::Exit().
 275   // 3-  Posting WM_CLOSE to the core window.
 276   dispatcher->ProcessEvents(
 277       winui::Core::CoreProcessEventsOption
 278           ::CoreProcessEventsOption_ProcessUntilQuit);
 279
 280   // Wind down the thread's chrome message loop.
 281   base::MessageLoop::current()->Quit();
 282 }
 283
 284 // Helper to return the state of the shift/control/alt keys.
 285 uint32 GetKeyboardEventFlags() {
 286   uint32 flags = 0;
 287   if (base::win::IsShiftPressed())
 288     flags |= ui::EF_SHIFT_DOWN;
 289   if (base::win::IsCtrlPressed())
 290     flags |= ui::EF_CONTROL_DOWN;
 291   if (base::win::IsAltPressed())
 292     flags |= ui::EF_ALT_DOWN;
 293   return flags;
 294 }
 295
 296 bool LaunchChromeBrowserProcess(const wchar_t* additional_parameters,
 297                                 winapp::Activation::IActivatedEventArgs* args) {
 298   if (args) {
 299     DVLOG(1) << __FUNCTION__ << ":" << ::GetCommandLineW();
 300     winapp::Activation::ActivationKind activation_kind;
 301     CheckHR(args->get_Kind(&activation_kind));
 302
 303     DVLOG(1) << __FUNCTION__ << ", activation_kind=" << activation_kind;
 304
 305     if (activation_kind == winapp::Activation::ActivationKind_Launch) {
 306       mswr::ComPtr<winapp::Activation::ILaunchActivatedEventArgs> launch_args;
 307       if (args->QueryInterface(
 308               winapp::Activation::IID_ILaunchActivatedEventArgs,
 309               &launch_args) == S_OK) {
 310         DVLOG(1) << "Activate: ActivationKind_Launch";
 311         mswrw::HString launch_args_str;
 312         launch_args->get_Arguments(launch_args_str.GetAddressOf());
 313         base::string16 actual_launch_args(
 314             MakeStdWString(launch_args_str.Get()));
 315         if (actual_launch_args == win8::kMetroViewerConnectVerb) {
 316           DVLOG(1) << __FUNCTION__ << "Not launching chrome server";
 317           return true;
 318         }
 319       }
 320     }
 321   }
 322
 323   DVLOG(1) << "Launching chrome server";
 324   base::FilePath chrome_exe_path;
 325
 326   if (!PathService::Get(base::FILE_EXE, &chrome_exe_path))
 327     return false;
 328
 329   base::string16 parameters = L"--silent-launch --connect-to-metro-viewer ";
 330   if (additional_parameters)
 331     parameters += additional_parameters;
 332
 333   SHELLEXECUTEINFO sei = { sizeof(sei) };
 334   sei.nShow = SW_SHOWNORMAL;
 335   sei.lpFile = chrome_exe_path.value().c_str();
 336   sei.lpDirectory = L"";
 337   sei.lpParameters = parameters.c_str();
 338   ::ShellExecuteEx(&sei);
 339   return true;
 340 }
 341
 342 }  // namespace
 343
 344 // This class helps decoding the pointer properties of an event.
 345 class ChromeAppViewAsh::PointerInfoHandler {
 346  public:
 347   PointerInfoHandler(float metro_dpi_scale, float win32_dpi_scale)
 348       : x_(0),
 349         y_(0),
 350         wheel_delta_(0),
 351         pointer_id_(0),
 352         update_kind_(winui::Input::PointerUpdateKind_Other),
 353         timestamp_(0),
 354         mouse_down_flags_(0),
 355         is_horizontal_wheel_(0),
 356         metro_dpi_scale_(metro_dpi_scale),
 357         win32_dpi_scale_(win32_dpi_scale) {}
 358
 359   HRESULT Init(winui::Core::IPointerEventArgs* args) {
 360     HRESULT hr = args->get_CurrentPoint(&pointer_point_);
 361     if (FAILED(hr))
 362       return hr;
 363
 364     winfoundtn::Point point;
 365     hr = pointer_point_->get_Position(&point);
 366     if (FAILED(hr))
 367       return hr;
 368
 369     mswr::ComPtr<winui::Input::IPointerPointProperties> properties;
 370     hr = pointer_point_->get_Properties(&properties);
 371     if (FAILED(hr))
 372       return hr;
 373
 374     hr = properties->get_PointerUpdateKind(&update_kind_);
 375     if (FAILED(hr))
 376       return hr;
 377
 378     hr = properties->get_MouseWheelDelta(&wheel_delta_);
 379     if (FAILED(hr))
 380       return hr;
 381
 382     is_horizontal_wheel_ = 0;
 383     properties->get_IsHorizontalMouseWheel(&is_horizontal_wheel_);
 384
 385     // The input coordinates are in DIP based on the metro scale factor.
 386     // We want to convert it to DIP based on the win32 scale factor.
 387     // We scale the point by the metro scale factor and then scale down
 388     // via the win32 scale factor which achieves the needful.
 389     gfx::Point dip_point_metro(point.X, point.Y);
 390     gfx::Point scaled_point_metro =
 391       gfx::ToCeiledPoint(gfx::ScalePoint(dip_point_metro, metro_dpi_scale_));
 392     gfx::Point dip_point_win32 =
 393         gfx::ToCeiledPoint(gfx::ScalePoint(scaled_point_metro,
 394                                            1.0 / win32_dpi_scale_));
 395     x_ = dip_point_win32.x();
 396     y_ = dip_point_win32.y();
 397
 398     pointer_point_->get_Timestamp(&timestamp_);
 399     pointer_point_->get_PointerId(&pointer_id_);
 400     // Map the OS touch event id to a range allowed by the gesture recognizer.
 401     if (IsTouch())
 402       pointer_id_ %= ui::MotionEvent::MAX_TOUCH_POINT_COUNT;
 403
 404     boolean left_button_state;
 405     hr = properties->get_IsLeftButtonPressed(&left_button_state);
 406     if (FAILED(hr))
 407       return hr;
 408     if (left_button_state)
 409       mouse_down_flags_ |= ui::EF_LEFT_MOUSE_BUTTON;
 410
 411     boolean right_button_state;
 412     hr = properties->get_IsRightButtonPressed(&right_button_state);
 413     if (FAILED(hr))
 414       return hr;
 415     if (right_button_state)
 416       mouse_down_flags_ |= ui::EF_RIGHT_MOUSE_BUTTON;
 417
 418     boolean middle_button_state;
 419     hr = properties->get_IsMiddleButtonPressed(&middle_button_state);
 420     if (FAILED(hr))
 421       return hr;
 422     if (middle_button_state)
 423       mouse_down_flags_ |= ui::EF_MIDDLE_MOUSE_BUTTON;
 424
 425     return S_OK;
 426   }
 427
 428   bool IsType(windevs::Input::PointerDeviceType type) const {
 429     mswr::ComPtr<windevs::Input::IPointerDevice> pointer_device;
 430     CheckHR(pointer_point_->get_PointerDevice(&pointer_device));
 431     windevs::Input::PointerDeviceType device_type;
 432     CheckHR(pointer_device->get_PointerDeviceType(&device_type));
 433     return  (device_type == type);
 434   }
 435
 436   bool IsMouse() const {
 437     return IsType(windevs::Input::PointerDeviceType_Mouse);
 438   }
 439
 440   bool IsTouch() const {
 441     return IsType(windevs::Input::PointerDeviceType_Touch);
 442   }
 443
 444   int32 wheel_delta() const {
 445     return wheel_delta_;
 446   }
 447
 448   // Identifies the button that changed.
 449   ui::EventFlags changed_button() const {
 450     switch (update_kind_) {
 451       case winui::Input::PointerUpdateKind_LeftButtonPressed:
 452         return ui::EF_LEFT_MOUSE_BUTTON;
 453       case winui::Input::PointerUpdateKind_LeftButtonReleased:
 454         return ui::EF_LEFT_MOUSE_BUTTON;
 455       case winui::Input::PointerUpdateKind_RightButtonPressed:
 456         return ui::EF_RIGHT_MOUSE_BUTTON;
 457       case winui::Input::PointerUpdateKind_RightButtonReleased:
 458         return ui::EF_RIGHT_MOUSE_BUTTON;
 459       case winui::Input::PointerUpdateKind_MiddleButtonPressed:
 460         return ui::EF_MIDDLE_MOUSE_BUTTON;
 461       case winui::Input::PointerUpdateKind_MiddleButtonReleased:
 462         return ui::EF_MIDDLE_MOUSE_BUTTON;
 463       default:
 464         return ui::EF_NONE;
 465     }
 466   }
 467
 468   uint32 mouse_down_flags() const { return mouse_down_flags_; }
 469
 470   int x() const { return x_; }
 471   int y() const { return y_; }
 472
 473   uint32 pointer_id() const {
 474     return pointer_id_;
 475   }
 476
 477   uint64 timestamp() const { return timestamp_; }
 478
 479   winui::Input::PointerUpdateKind update_kind() const { return update_kind_; }
 480
 481   bool is_horizontal_wheel() const { return !!is_horizontal_wheel_; }
 482
 483  private:
 484   int x_;
 485   int y_;
 486   int wheel_delta_;
 487   uint32 pointer_id_;
 488   winui::Input::PointerUpdateKind update_kind_;
 489   mswr::ComPtr<winui::Input::IPointerPoint> pointer_point_;
 490   uint64 timestamp_;
 491
 492   // Bitmask of ui::EventFlags corresponding to the buttons that are currently
 493   // down.
 494   uint32 mouse_down_flags_;
 495
 496   // Set to true for a horizontal wheel message.
 497   boolean is_horizontal_wheel_;
 498
 499   // The metro device scale factor as reported by the winrt interfaces.
 500   float metro_dpi_scale_;
 501   // The win32 dpi scale which is queried via GetDeviceCaps. Please refer to
 502   // ui/gfx/win/dpi.cc for more information.
 503   float win32_dpi_scale_;
 504
 505   DISALLOW_COPY_AND_ASSIGN(PointerInfoHandler);
 506 };
 507
 508 ChromeAppViewAsh::ChromeAppViewAsh()
 509     : mouse_down_flags_(ui::EF_NONE),
 510       ui_channel_(nullptr),
 511       core_window_hwnd_(NULL),
 512       metro_dpi_scale_(0),
 513       win32_dpi_scale_(0),
 514       last_cursor_(NULL),
 515       channel_listener_(NULL) {
 516   DVLOG(1) << __FUNCTION__;
 517   globals.previous_state =
 518       winapp::Activation::ApplicationExecutionState_NotRunning;
 519 }
 520
 521 ChromeAppViewAsh::~ChromeAppViewAsh() {
 522   DVLOG(1) << __FUNCTION__;
 523 }
 524
 525 IFACEMETHODIMP
 526 ChromeAppViewAsh::Initialize(winapp::Core::ICoreApplicationView* view) {
 527   view_ = view;
 528   DVLOG(1) << __FUNCTION__;
 529   HRESULT hr = view_->add_Activated(mswr::Callback<ActivatedHandler>(
 530       this, &ChromeAppViewAsh::OnActivate).Get(),
 531       &activated_token_);
 532   CheckHR(hr);
 533   return hr;
 534 }
 535
 536 IFACEMETHODIMP
 537 ChromeAppViewAsh::SetWindow(winui::Core::ICoreWindow* window) {
 538   window_ = window;
 539   DVLOG(1) << __FUNCTION__;
 540
 541   // Retrieve the native window handle via the interop layer.
 542   mswr::ComPtr<ICoreWindowInterop> interop;
 543   HRESULT hr = window->QueryInterface(interop.GetAddressOf());
 544   CheckHR(hr);
 545   hr = interop->get_WindowHandle(&core_window_hwnd_);
 546   CheckHR(hr);
 547
 548   text_service_ = metro_driver::CreateTextService(this, core_window_hwnd_);
 549
 550   hr = window_->add_SizeChanged(mswr::Callback<SizeChangedHandler>(
 551       this, &ChromeAppViewAsh::OnSizeChanged).Get(),
 552       &sizechange_token_);
 553   CheckHR(hr);
 554
 555   // Register for pointer and keyboard notifications. We forward
 556   // them to the browser process via IPC.
 557   hr = window_->add_PointerMoved(mswr::Callback<PointerEventHandler>(
 558       this, &ChromeAppViewAsh::OnPointerMoved).Get(),
 559       &pointermoved_token_);
 560   CheckHR(hr);
 561
 562   hr = window_->add_PointerPressed(mswr::Callback<PointerEventHandler>(
 563       this, &ChromeAppViewAsh::OnPointerPressed).Get(),
 564       &pointerpressed_token_);
 565   CheckHR(hr);
 566
 567   hr = window_->add_PointerReleased(mswr::Callback<PointerEventHandler>(
 568       this, &ChromeAppViewAsh::OnPointerReleased).Get(),
 569       &pointerreleased_token_);
 570   CheckHR(hr);
 571
 572   hr = window_->add_KeyDown(mswr::Callback<KeyEventHandler>(
 573       this, &ChromeAppViewAsh::OnKeyDown).Get(),
 574       &keydown_token_);
 575   CheckHR(hr);
 576
 577   hr = window_->add_KeyUp(mswr::Callback<KeyEventHandler>(
 578       this, &ChromeAppViewAsh::OnKeyUp).Get(),
 579       &keyup_token_);
 580   CheckHR(hr);
 581
 582   mswr::ComPtr<winui::Core::ICoreDispatcher> dispatcher;
 583   hr = window_->get_Dispatcher(dispatcher.GetAddressOf());
 584   CheckHR(hr, "Get Dispatcher failed.");
 585
 586   mswr::ComPtr<winui::Core::ICoreAcceleratorKeys> accelerator_keys;
 587   hr = dispatcher.CopyTo(__uuidof(winui::Core::ICoreAcceleratorKeys),
 588                          reinterpret_cast<void**>(
 589                             accelerator_keys.GetAddressOf()));
 590   CheckHR(hr, "QI for ICoreAcceleratorKeys failed.");
 591   hr = accelerator_keys->add_AcceleratorKeyActivated(
 592       mswr::Callback<AcceleratorKeyEventHandler>(
 593           this, &ChromeAppViewAsh::OnAcceleratorKeyDown).Get(),
 594       &accel_keydown_token_);
 595   CheckHR(hr);
 596
 597   hr = window_->add_PointerWheelChanged(mswr::Callback<PointerEventHandler>(
 598       this, &ChromeAppViewAsh::OnWheel).Get(),
 599       &wheel_token_);
 600   CheckHR(hr);
 601
 602   hr = window_->add_CharacterReceived(mswr::Callback<CharEventHandler>(
 603       this, &ChromeAppViewAsh::OnCharacterReceived).Get(),
 604       &character_received_token_);
 605   CheckHR(hr);
 606
 607   hr = window_->add_Activated(mswr::Callback<WindowActivatedHandler>(
 608       this, &ChromeAppViewAsh::OnWindowActivated).Get(),
 609       &window_activated_token_);
 610   CheckHR(hr);
 611
 612   if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
 613     // Register for edge gesture notifications only for Windows 8 and above.
 614     mswr::ComPtr<winui::Input::IEdgeGestureStatics> edge_gesture_statics;
 615     hr = winrt_utils::CreateActivationFactory(
 616         RuntimeClass_Windows_UI_Input_EdgeGesture,
 617         edge_gesture_statics.GetAddressOf());
 618     CheckHR(hr);
 619
 620     mswr::ComPtr<winui::Input::IEdgeGesture> edge_gesture;
 621     hr = edge_gesture_statics->GetForCurrentView(&edge_gesture);
 622     CheckHR(hr);
 623
 624     hr = edge_gesture->add_Completed(mswr::Callback<EdgeEventHandler>(
 625         this, &ChromeAppViewAsh::OnEdgeGestureCompleted).Get(),
 626         &edgeevent_token_);
 627     CheckHR(hr);
 628   }
 629
 630   // By initializing the direct 3D swap chain with the corewindow
 631   // we can now directly blit to it from the browser process.
 632   direct3d_helper_.Initialize(window);
 633   DVLOG(1) << "Initialized Direct3D.";
 634
 635   // On Windows 8+ the WinRT interface IDisplayProperties which we use to get
 636   // device scale factor does not return the correct values in metro mode.
 637   // To workaround this we retrieve the device scale factor via the win32 way
 638   // and scale input coordinates accordingly to pass them in DIP to chrome.
 639   // TODO(ananta). Investigate and fix.
 640   metro_dpi_scale_ = GetModernUIScale();
 641   win32_dpi_scale_ = gfx::GetDPIScale();
 642   DVLOG(1) << "Metro Scale is " << metro_dpi_scale_;
 643   DVLOG(1) << "Win32 Scale is " << win32_dpi_scale_;
 644   return S_OK;
 645 }
 646
 647 IFACEMETHODIMP
 648 ChromeAppViewAsh::Load(HSTRING entryPoint) {
 649   // On Win7 |entryPoint| is NULL.
 650   DVLOG(1) << __FUNCTION__;
 651   return S_OK;
 652 }
 653
 654 IFACEMETHODIMP
 655 ChromeAppViewAsh::Run() {
 656   DVLOG(1) << __FUNCTION__;
 657   mswr::ComPtr<winui::Core::ICoreDispatcher> dispatcher;
 658   HRESULT hr = window_->get_Dispatcher(dispatcher.GetAddressOf());
 659   CheckHR(hr, "Dispatcher failed.");
 660
 661   // Create the IPC channel IO thread. It needs to out-live the ChannelProxy.
 662   io_thread_.reset(new base::Thread("metro_IO_thread"));
 663   base::Thread::Options options;
 664   options.message_loop_type = base::MessageLoop::TYPE_IO;
 665   io_thread_->StartWithOptions(options);
 666
 667   ChromeChannelListener ui_channel_listener(&ui_loop_, this);
 668   channel_listener_ = &ui_channel_listener;
 669
 670   // We can't do anything until the Chrome browser IPC channel is initialized.
 671   // Lazy initialization in a timer.
 672   ui_loop_.PostDelayedTask(FROM_HERE,
 673       base::Bind(base::IgnoreResult(&ChromeAppViewAsh::StartChromeOSMode),
 674                  base::Unretained(this)),
 675       base::TimeDelta::FromMilliseconds(kChromeChannelPollTimerMs));
 676
 677   // Post the task that'll do the inner Metro message pumping to it.
 678   ui_loop_.PostTask(FROM_HERE, base::Bind(&RunMessageLoop, dispatcher.Get()));
 679   ui_loop_.Run();
 680
 681   io_thread_.reset(NULL);
 682   ui_channel_.reset(NULL);
 683   channel_listener_ = NULL;
 684
 685   DVLOG(0) << "ProcessEvents done, hr=" << hr;
 686   return hr;
 687 }
 688
 689 IFACEMETHODIMP
 690 ChromeAppViewAsh::Uninitialize() {
 691   DVLOG(1) << __FUNCTION__;
 692   metro_driver::RemoveImePopupObserver(this);
 693   input_source_.reset();
 694   text_service_.reset();
 695   window_ = nullptr;
 696   view_ = nullptr;
 697   core_window_hwnd_ = NULL;
 698   return S_OK;
 699 }
 700
 701 // static
 702 HRESULT ChromeAppViewAsh::Unsnap() {
 703   mswr::ComPtr<winui::ViewManagement::IApplicationViewStatics> view_statics;
 704   HRESULT hr = winrt_utils::CreateActivationFactory(
 705       RuntimeClass_Windows_UI_ViewManagement_ApplicationView,
 706       view_statics.GetAddressOf());
 707   CheckHR(hr);
 708
 709   winui::ViewManagement::ApplicationViewState state =
 710       winui::ViewManagement::ApplicationViewState_FullScreenLandscape;
 711   hr = view_statics->get_Value(&state);
 712   CheckHR(hr);
 713
 714   if (state == winui::ViewManagement::ApplicationViewState_Snapped) {
 715     boolean success = FALSE;
 716     hr = view_statics->TryUnsnap(&success);
 717
 718     if (FAILED(hr) || !success) {
 719       LOG(ERROR) << "Failed to unsnap. Error 0x" << hr;
 720       if (SUCCEEDED(hr))
 721         hr = E_UNEXPECTED;
 722     }
 723   }
 724   return hr;
 725 }
 726
 727 void ChromeAppViewAsh::OnActivateDesktop(const base::FilePath& file_path,
 728                                          bool ash_exit) {
 729   DVLOG(1) << "ChannelAppViewAsh::OnActivateDesktop\n";
 730
 731   if (ash_exit) {
 732     // As we are the top level window, the exiting is done async so we manage
 733     // to execute  the entire function including the final Send().
 734     OnMetroExit(TERMINATE_USING_KEY_SEQUENCE);
 735   }
 736
 737   // We are just executing delegate_execute here without parameters. Assumption
 738   // here is that this process will be reused by shell when asking for
 739   // IExecuteCommand interface.
 740
 741   // TODO(shrikant): Consolidate ShellExecuteEx with SEE_MASK_FLAG_LOG_USAGE
 742   // and place it metro.h or similar accessible file from all code code paths
 743   // using this function.
 744   SHELLEXECUTEINFO sei = { sizeof(sei) };
 745   sei.fMask = SEE_MASK_FLAG_LOG_USAGE;
 746   sei.nShow = SW_SHOWNORMAL;
 747   sei.lpFile = file_path.value().c_str();
 748   sei.lpParameters = NULL;
 749   if (!ash_exit)
 750     sei.fMask |= SEE_MASK_NOCLOSEPROCESS;
 751   ::ShellExecuteExW(&sei);
 752   if (!ash_exit) {
 753     ::TerminateProcess(sei.hProcess, 0);
 754     ::CloseHandle(sei.hProcess);
 755   }
 756 }
 757
 758 void ChromeAppViewAsh::OnOpenURLOnDesktop(const base::FilePath& shortcut,
 759                                           const base::string16& url) {
 760   base::FilePath::StringType file = shortcut.value();
 761   SHELLEXECUTEINFO sei = { sizeof(sei) };
 762   sei.fMask = SEE_MASK_FLAG_LOG_USAGE;
 763   sei.nShow = SW_SHOWNORMAL;
 764   sei.lpFile = file.c_str();
 765   sei.lpDirectory = L"";
 766   sei.lpParameters = url.c_str();
 767   ShellExecuteEx(&sei);
 768 }
 769
 770 void ChromeAppViewAsh::OnSetCursor(HCURSOR cursor) {
 771   ::SetCursor(cursor);
 772   last_cursor_ = cursor;
 773 }
 774
 775 void ChromeAppViewAsh::OnDisplayFileOpenDialog(
 776     const base::string16& title,
 777     const base::string16& filter,
 778     const base::FilePath& default_path,
 779     bool allow_multiple_files) {
 780   DVLOG(1) << __FUNCTION__;
 781
 782   // The OpenFilePickerSession instance is deleted when we receive a
 783   // callback from the OpenFilePickerSession class about the completion of the
 784   // operation.
 785   FilePickerSessionBase* file_picker_ =
 786       new OpenFilePickerSession(this,
 787                                 title,
 788                                 filter,
 789                                 default_path,
 790                                 allow_multiple_files);
 791   file_picker_->Run();
 792 }
 793
 794 void ChromeAppViewAsh::OnDisplayFileSaveAsDialog(
 795     const MetroViewerHostMsg_SaveAsDialogParams& params) {
 796   DVLOG(1) << __FUNCTION__;
 797
 798   // The SaveFilePickerSession instance is deleted when we receive a
 799   // callback from the SaveFilePickerSession class about the completion of the
 800   // operation.
 801   FilePickerSessionBase* file_picker_ =
 802       new SaveFilePickerSession(this, params);
 803   file_picker_->Run();
 804 }
 805
 806 void ChromeAppViewAsh::OnDisplayFolderPicker(const base::string16& title) {
 807   DVLOG(1) << __FUNCTION__;
 808   // The FolderPickerSession instance is deleted when we receive a
 809   // callback from the FolderPickerSession class about the completion of the
 810   // operation.
 811   FilePickerSessionBase* file_picker_ = new FolderPickerSession(this, title);
 812   file_picker_->Run();
 813 }
 814
 815 void ChromeAppViewAsh::OnSetCursorPos(int x, int y) {
 816   if (ui_channel_) {
 817     ::SetCursorPos(x, y);
 818     DVLOG(1) << "In UI OnSetCursorPos: " << x << ", " << y;
 819     ui_channel_->Send(new MetroViewerHostMsg_SetCursorPosAck());
 820     // Generate a fake mouse move which matches the SetCursor coordinates as
 821     // the browser expects to receive a mouse move for these coordinates.
 822     // It is not clear why we don't receive a real mouse move in response to
 823     // the SetCursorPos calll above.
 824     ui_channel_->Send(new MetroViewerHostMsg_MouseMoved(x, y, 0));
 825   }
 826 }
 827
 828 void ChromeAppViewAsh::OnOpenFileCompleted(
 829     OpenFilePickerSession* open_file_picker,
 830     bool success) {
 831   DVLOG(1) << __FUNCTION__;
 832   DVLOG(1) << "Success: " << success;
 833   if (ui_channel_) {
 834     if (open_file_picker->allow_multi_select()) {
 835       ui_channel_->Send(new MetroViewerHostMsg_MultiFileOpenDone(
 836           success, open_file_picker->filenames()));
 837     } else {
 838       ui_channel_->Send(new MetroViewerHostMsg_FileOpenDone(
 839           success, base::FilePath(open_file_picker->result())));
 840     }
 841   }
 842   delete open_file_picker;
 843 }
 844
 845 void ChromeAppViewAsh::OnSaveFileCompleted(
 846     SaveFilePickerSession* save_file_picker,
 847     bool success) {
 848   DVLOG(1) << __FUNCTION__;
 849   DVLOG(1) << "Success: " << success;
 850   if (ui_channel_) {
 851     ui_channel_->Send(new MetroViewerHostMsg_FileSaveAsDone(
 852         success,
 853         base::FilePath(save_file_picker->result()),
 854         save_file_picker->filter_index()));
 855   }
 856   delete save_file_picker;
 857 }
 858
 859 void ChromeAppViewAsh::OnFolderPickerCompleted(
 860     FolderPickerSession* folder_picker,
 861     bool success) {
 862   DVLOG(1) << __FUNCTION__;
 863   DVLOG(1) << "Success: " << success;
 864   if (ui_channel_) {
 865     ui_channel_->Send(new MetroViewerHostMsg_SelectFolderDone(
 866         success,
 867         base::FilePath(folder_picker->result())));
 868   }
 869   delete folder_picker;
 870 }
 871
 872 void ChromeAppViewAsh::OnImeCancelComposition() {
 873   if (!text_service_)
 874     return;
 875   text_service_->CancelComposition();
 876 }
 877
 878 void ChromeAppViewAsh::OnImeUpdateTextInputClient(
 879     const std::vector<int32>& input_scopes,
 880     const std::vector<metro_viewer::CharacterBounds>& character_bounds) {
 881   if (!text_service_)
 882     return;
 883   text_service_->OnDocumentChanged(input_scopes, character_bounds);
 884 }
 885
 886 void ChromeAppViewAsh::OnImePopupChanged(ImePopupObserver::EventType event) {
 887   if (!ui_channel_)
 888     return;
 889   switch (event) {
 890     case ImePopupObserver::kPopupShown:
 891       ui_channel_->Send(new MetroViewerHostMsg_ImeCandidatePopupChanged(true));
 892       return;
 893     case ImePopupObserver::kPopupHidden:
 894       ui_channel_->Send(new MetroViewerHostMsg_ImeCandidatePopupChanged(false));
 895       return;
 896     case ImePopupObserver::kPopupUpdated:
 897       // TODO(kochi): Support this event for W3C IME API proposal.
 898       // See crbug.com/238585.
 899       return;
 900     default:
 901       NOTREACHED() << "unknown event type: " << event;
 902       return;
 903   }
 904 }
 905
 906 // Function to Exit metro chrome cleanly. If we are in the foreground
 907 // then we try and exit by sending an Alt+F4 key combination to the core
 908 // window which ensures that the chrome application tile does not show up in
 909 // the running metro apps list on the top left corner.
 910 void ChromeAppViewAsh::OnMetroExit(MetroTerminateMethod method) {
 911   if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
 912     HWND core_window = core_window_hwnd();
 913     if (method == TERMINATE_USING_KEY_SEQUENCE && core_window != NULL &&
 914         core_window == ::GetForegroundWindow()) {
 915       DVLOG(1) << "We are in the foreground. Exiting via Alt F4";
 916       SendKeySequence(VK_F4, ALT);
 917       if (ui_channel_)
 918         ui_channel_->Close();
 919     } else {
 920       globals.app_exit->Exit();
 921     }
 922   } else {
 923     if (ui_channel_)
 924       ui_channel_->Close();
 925
 926     HWND core_window = core_window_hwnd();
 927     ::PostMessage(core_window, WM_CLOSE, 0, 0);
 928
 929     globals.app_exit->Exit();
 930   }
 931 }
 932
 933 void ChromeAppViewAsh::OnInputSourceChanged() {
 934   if (!input_source_)
 935     return;
 936
 937   DCHECK(ui_channel_);
 938
 939   LANGID langid = 0;
 940   bool is_ime = false;
 941   if (!input_source_->GetActiveSource(&langid, &is_ime)) {
 942     LOG(ERROR) << "GetActiveSource failed";
 943     return;
 944   }
 945   ui_channel_->Send(new MetroViewerHostMsg_ImeInputSourceChanged(langid,
 946                                                                  is_ime));
 947 }
 948
 949 void ChromeAppViewAsh::OnCompositionChanged(
 950     const base::string16& text,
 951     int32 selection_start,
 952     int32 selection_end,
 953     const std::vector<metro_viewer::UnderlineInfo>& underlines) {
 954   ui_channel_->Send(new MetroViewerHostMsg_ImeCompositionChanged(
 955       text, selection_start, selection_end, underlines));
 956 }
 957
 958 void ChromeAppViewAsh::OnTextCommitted(const base::string16& text) {
 959   ui_channel_->Send(new MetroViewerHostMsg_ImeTextCommitted(text));
 960 }
 961
 962 void ChromeAppViewAsh::SendMouseButton(int x,
 963                                        int y,
 964                                        int extra,
 965                                        ui::EventType event_type,
 966                                        uint32 flags,
 967                                        ui::EventFlags changed_button,
 968                                        bool is_horizontal_wheel) {
 969   if (!ui_channel_)
 970     return;
 971   MetroViewerHostMsg_MouseButtonParams params;
 972   params.x = static_cast<int32>(x);
 973   params.y = static_cast<int32>(y);
 974   params.extra = static_cast<int32>(extra);
 975   params.event_type = event_type;
 976   params.flags = static_cast<int32>(flags);
 977   params.changed_button = changed_button;
 978   params.is_horizontal_wheel = is_horizontal_wheel;
 979   ui_channel_->Send(new MetroViewerHostMsg_MouseButton(params));
 980 }
 981
 982 void ChromeAppViewAsh::GenerateMouseEventFromMoveIfNecessary(
 983     const PointerInfoHandler& pointer) {
 984   ui::EventType event_type;
 985   // For aura we want the flags to include the button that was released, thus
 986   // we or the old and new.
 987   uint32 mouse_down_flags = pointer.mouse_down_flags() | mouse_down_flags_;
 988   mouse_down_flags_ = pointer.mouse_down_flags();
 989   switch (pointer.update_kind()) {
 990     case winui::Input::PointerUpdateKind_LeftButtonPressed:
 991     case winui::Input::PointerUpdateKind_RightButtonPressed:
 992     case winui::Input::PointerUpdateKind_MiddleButtonPressed:
 993       event_type = ui::ET_MOUSE_PRESSED;
 994       break;
 995     case winui::Input::PointerUpdateKind_LeftButtonReleased:
 996     case winui::Input::PointerUpdateKind_RightButtonReleased:
 997     case winui::Input::PointerUpdateKind_MiddleButtonReleased:
 998       event_type = ui::ET_MOUSE_RELEASED;
 999       break;
1000     default:
1001       return;
1002   }
1003   SendMouseButton(pointer.x(), pointer.y(), 0, event_type,
1004                   mouse_down_flags | GetKeyboardEventFlags(),
1005                   pointer.changed_button(), pointer.is_horizontal_wheel());
1006 }
1007
1008 HRESULT ChromeAppViewAsh::OnActivate(
1009     winapp::Core::ICoreApplicationView*,
1010     winapp::Activation::IActivatedEventArgs* args) {
1011   DVLOG(1) << __FUNCTION__;
1012   // Note: If doing more work in this function, you migth need to call
1013   // get_PreviousExecutionState() and skip the work if  the result is
1014   // ApplicationExecutionState_Running and globals.previous_state is too.
1015   args->get_PreviousExecutionState(&globals.previous_state);
1016   DVLOG(1) << "Previous Execution State: " << globals.previous_state;
1017
1018   winapp::Activation::ActivationKind activation_kind;
1019   CheckHR(args->get_Kind(&activation_kind));
1020   DVLOG(1) << "Activation kind: " << activation_kind;
1021
1022   if (activation_kind == winapp::Activation::ActivationKind_Search)
1023     HandleSearchRequest(args);
1024   else if (activation_kind == winapp::Activation::ActivationKind_Protocol)
1025     HandleProtocolRequest(args);
1026   else
1027     LaunchChromeBrowserProcess(NULL, args);
1028   // We call ICoreWindow::Activate after the handling for the search/protocol
1029   // requests because Chrome can be launched to handle a search request which
1030   // in turn launches the chrome browser process in desktop mode via
1031   // ShellExecute. If we call ICoreWindow::Activate before this, then
1032   // Windows kills the metro chrome process when it calls ShellExecute. Seems
1033   // to be a bug.
1034   window_->Activate();
1035   return S_OK;
1036 }
1037
1038 HRESULT ChromeAppViewAsh::OnPointerMoved(winui::Core::ICoreWindow* sender,
1039                                          winui::Core::IPointerEventArgs* args) {
1040   if (!ui_channel_)
1041     return S_OK;
1042
1043   PointerInfoHandler pointer(metro_dpi_scale_, win32_dpi_scale_);
1044   HRESULT hr = pointer.Init(args);
1045   if (FAILED(hr))
1046     return hr;
1047
1048   if (pointer.IsMouse()) {
1049     // If the mouse was moved towards the charms or the OS specific section,
1050     // the cursor may change from what the browser last set. Restore it here.
1051     if (::GetCursor() != last_cursor_)
1052       SetCursor(last_cursor_);
1053
1054     GenerateMouseEventFromMoveIfNecessary(pointer);
1055     ui_channel_->Send(new MetroViewerHostMsg_MouseMoved(
1056         pointer.x(),
1057         pointer.y(),
1058         mouse_down_flags_ | GetKeyboardEventFlags()));
1059   } else {
1060     DCHECK(pointer.IsTouch());
1061     ui_channel_->Send(new MetroViewerHostMsg_TouchMoved(pointer.x(),
1062                                                         pointer.y(),
1063                                                         pointer.timestamp(),
1064                                                         pointer.pointer_id()));
1065   }
1066   return S_OK;
1067 }
1068
1069 // NOTE: From experimentation, it seems like Metro only sends a PointerPressed
1070 // event for the first button pressed and the last button released in a sequence
1071 // of mouse events.
1072 // For example, a sequence of LEFT_DOWN, RIGHT_DOWN, LEFT_UP, RIGHT_UP results
1073 // only in PointerPressed(LEFT)/PointerReleased(RIGHT) events. Intermediary
1074 // presses and releases are tracked in OnPointMoved().
1075 HRESULT ChromeAppViewAsh::OnPointerPressed(
1076     winui::Core::ICoreWindow* sender,
1077     winui::Core::IPointerEventArgs* args) {
1078   if (!ui_channel_)
1079     return S_OK;
1080
1081   PointerInfoHandler pointer(metro_dpi_scale_, win32_dpi_scale_);
1082   HRESULT hr = pointer.Init(args);
1083   if (FAILED(hr))
1084     return hr;
1085
1086   if (pointer.IsMouse()) {
1087     mouse_down_flags_ = pointer.mouse_down_flags();
1088     SendMouseButton(pointer.x(), pointer.y(), 0, ui::ET_MOUSE_PRESSED,
1089                     mouse_down_flags_ | GetKeyboardEventFlags(),
1090                     pointer.changed_button(), pointer.is_horizontal_wheel());
1091   } else {
1092     DCHECK(pointer.IsTouch());
1093     ui_channel_->Send(new MetroViewerHostMsg_TouchDown(pointer.x(),
1094                                                        pointer.y(),
1095                                                        pointer.timestamp(),
1096                                                        pointer.pointer_id()));
1097   }
1098   return S_OK;
1099 }
1100
1101 HRESULT ChromeAppViewAsh::OnPointerReleased(
1102     winui::Core::ICoreWindow* sender,
1103     winui::Core::IPointerEventArgs* args) {
1104   if (!ui_channel_)
1105     return S_OK;
1106
1107   PointerInfoHandler pointer(metro_dpi_scale_, win32_dpi_scale_);
1108   HRESULT hr = pointer.Init(args);
1109   if (FAILED(hr))
1110     return hr;
1111
1112   if (pointer.IsMouse()) {
1113     mouse_down_flags_ = ui::EF_NONE;
1114     SendMouseButton(pointer.x(), pointer.y(), 0, ui::ET_MOUSE_RELEASED,
1115                     static_cast<uint32>(pointer.changed_button()) |
1116                     GetKeyboardEventFlags(),
1117                     pointer.changed_button(),
1118                     pointer.is_horizontal_wheel());
1119   } else {
1120     DCHECK(pointer.IsTouch());
1121     ui_channel_->Send(new MetroViewerHostMsg_TouchUp(pointer.x(),
1122                                                      pointer.y(),
1123                                                      pointer.timestamp(),
1124                                                      pointer.pointer_id()));
1125   }
1126   return S_OK;
1127 }
1128
1129 HRESULT ChromeAppViewAsh::OnWheel(
1130     winui::Core::ICoreWindow* sender,
1131     winui::Core::IPointerEventArgs* args) {
1132   if (!ui_channel_)
1133     return S_OK;
1134
1135   PointerInfoHandler pointer(metro_dpi_scale_, win32_dpi_scale_);
1136   HRESULT hr = pointer.Init(args);
1137   if (FAILED(hr))
1138     return hr;
1139   DCHECK(pointer.IsMouse());
1140   SendMouseButton(pointer.x(), pointer.y(), pointer.wheel_delta(),
1141                   ui::ET_MOUSEWHEEL, GetKeyboardEventFlags(), ui::EF_NONE,
1142                   pointer.is_horizontal_wheel());
1143   return S_OK;
1144 }
1145
1146 HRESULT ChromeAppViewAsh::OnKeyDown(
1147     winui::Core::ICoreWindow* sender,
1148     winui::Core::IKeyEventArgs* args) {
1149   if (!ui_channel_)
1150     return S_OK;
1151
1152   winsys::VirtualKey virtual_key;
1153   HRESULT hr = args->get_VirtualKey(&virtual_key);
1154   if (FAILED(hr))
1155     return hr;
1156   winui::Core::CorePhysicalKeyStatus status;
1157   hr = args->get_KeyStatus(&status);
1158   if (FAILED(hr))
1159     return hr;
1160
1161   ui_channel_->Send(new MetroViewerHostMsg_KeyDown(virtual_key,
1162                                                    status.RepeatCount,
1163                                                    status.ScanCode,
1164                                                    GetKeyboardEventFlags()));
1165   return S_OK;
1166 }
1167
1168 HRESULT ChromeAppViewAsh::OnKeyUp(
1169     winui::Core::ICoreWindow* sender,
1170     winui::Core::IKeyEventArgs* args) {
1171   if (!ui_channel_)
1172     return S_OK;
1173
1174   winsys::VirtualKey virtual_key;
1175   HRESULT hr = args->get_VirtualKey(&virtual_key);
1176   if (FAILED(hr))
1177     return hr;
1178   winui::Core::CorePhysicalKeyStatus status;
1179   hr = args->get_KeyStatus(&status);
1180   if (FAILED(hr))
1181     return hr;
1182
1183   ui_channel_->Send(new MetroViewerHostMsg_KeyUp(virtual_key,
1184                                                  status.RepeatCount,
1185                                                  status.ScanCode,
1186                                                  GetKeyboardEventFlags()));
1187   return S_OK;
1188 }
1189
1190 HRESULT ChromeAppViewAsh::OnAcceleratorKeyDown(
1191     winui::Core::ICoreDispatcher* sender,
1192     winui::Core::IAcceleratorKeyEventArgs* args) {
1193   if (!ui_channel_)
1194     return S_OK;
1195
1196   winsys::VirtualKey virtual_key;
1197   HRESULT hr = args->get_VirtualKey(&virtual_key);
1198   if (FAILED(hr))
1199     return hr;
1200   winui::Core::CorePhysicalKeyStatus status;
1201   hr = args->get_KeyStatus(&status);
1202   if (FAILED(hr))
1203     return hr;
1204
1205   winui::Core::CoreAcceleratorKeyEventType event_type;
1206   hr = args->get_EventType(&event_type);
1207   if (FAILED(hr))
1208     return hr;
1209
1210   uint32 keyboard_flags = GetKeyboardEventFlags();
1211
1212   switch (event_type) {
1213     case winui::Core::CoreAcceleratorKeyEventType_SystemCharacter:
1214       ui_channel_->Send(new MetroViewerHostMsg_Character(virtual_key,
1215                                                          status.RepeatCount,
1216                                                          status.ScanCode,
1217                                                          keyboard_flags));
1218       break;
1219
1220     case winui::Core::CoreAcceleratorKeyEventType_SystemKeyDown:
1221       // Don't send the Alt + F4 combination to Chrome as this is intended to
1222       // shut the metro environment down. Reason we check for Control here is
1223       // Windows does not shutdown metro if Ctrl is pressed along with Alt F4.
1224       // Other key combinations with Alt F4 shutdown metro.
1225       if ((virtual_key == VK_F4) && ((keyboard_flags & ui::EF_ALT_DOWN) &&
1226           !(keyboard_flags & ui::EF_CONTROL_DOWN)))
1227         return S_OK;
1228       // Don't send the EF_ALT_DOWN modifier along with the IPC message for
1229       // the Alt or F10 key. The accelerator for VKEY_MENU is registered
1230       // without modifiers in Chrome for historical reasons. Not sending the
1231       // EF_ALT_DOWN modifier ensures that the accelerator is processed
1232       // correctly.
1233       if (virtual_key == winsys::VirtualKey_Menu)
1234         keyboard_flags &= ~ui::EF_ALT_DOWN;
1235       ui_channel_->Send(new MetroViewerHostMsg_KeyDown(virtual_key,
1236                                                        status.RepeatCount,
1237                                                        status.ScanCode,
1238                                                        keyboard_flags));
1239       break;
1240
1241     case winui::Core::CoreAcceleratorKeyEventType_SystemKeyUp:
1242       ui_channel_->Send(new MetroViewerHostMsg_KeyUp(virtual_key,
1243                                                      status.RepeatCount,
1244                                                      status.ScanCode,
1245                                                      keyboard_flags));
1246       break;
1247
1248     default:
1249       break;
1250   }
1251   return S_OK;
1252 }
1253
1254 HRESULT ChromeAppViewAsh::OnCharacterReceived(
1255   winui::Core::ICoreWindow* sender,
1256   winui::Core::ICharacterReceivedEventArgs* args) {
1257   if (!ui_channel_)
1258     return S_OK;
1259
1260   unsigned int char_code = 0;
1261   HRESULT hr = args->get_KeyCode(&char_code);
1262   if (FAILED(hr))
1263     return hr;
1264
1265   winui::Core::CorePhysicalKeyStatus status;
1266   hr = args->get_KeyStatus(&status);
1267   if (FAILED(hr))
1268     return hr;
1269
1270   ui_channel_->Send(new MetroViewerHostMsg_Character(char_code,
1271                                                      status.RepeatCount,
1272                                                      status.ScanCode,
1273                                                      GetKeyboardEventFlags()));
1274   return S_OK;
1275 }
1276
1277 HRESULT ChromeAppViewAsh::OnWindowActivated(
1278     winui::Core::ICoreWindow* sender,
1279     winui::Core::IWindowActivatedEventArgs* args) {
1280   if (!ui_channel_)
1281     return S_OK;
1282
1283   if (args) {
1284     winui::Core::CoreWindowActivationState state;
1285     HRESULT hr = args->get_WindowActivationState(&state);
1286     if (FAILED(hr))
1287       return hr;
1288
1289     // Treat both full activation (Ash was reopened from the Start Screen or
1290     // from any other Metro entry point in Windows) and pointer activation
1291     // (user clicked back in Ash after using another app on another monitor)
1292     // the same.
1293     if (state == winui::Core::CoreWindowActivationState_CodeActivated ||
1294         state == winui::Core::CoreWindowActivationState_PointerActivated) {
1295       ui_channel_->Send(new MetroViewerHostMsg_WindowActivated(false));
1296     }
1297   } else {
1298     // On Windows 7, we force a repaint when the window is activated.
1299     ui_channel_->Send(new MetroViewerHostMsg_WindowActivated(true));
1300   }
1301   if (text_service_)
1302     text_service_->OnWindowActivated();
1303   return S_OK;
1304 }
1305
1306 HRESULT ChromeAppViewAsh::HandleSearchRequest(
1307     winapp::Activation::IActivatedEventArgs* args) {
1308   mswr::ComPtr<winapp::Activation::ISearchActivatedEventArgs> search_args;
1309   CheckHR(args->QueryInterface(
1310           winapp::Activation::IID_ISearchActivatedEventArgs, &search_args));
1311
1312   if (!ui_channel_) {
1313     DVLOG(1) << "Launched to handle search request";
1314     LaunchChromeBrowserProcess(L"--windows8-search", args);
1315   }
1316
1317   mswrw::HString search_string;
1318   CheckHR(search_args->get_QueryText(search_string.GetAddressOf()));
1319   base::string16 search_text(MakeStdWString(search_string.Get()));
1320
1321   ui_loop_.PostTask(FROM_HERE,
1322                     base::Bind(&ChromeAppViewAsh::OnSearchRequest,
1323                     base::Unretained(this),
1324                     search_text));
1325   return S_OK;
1326 }
1327
1328 HRESULT ChromeAppViewAsh::HandleProtocolRequest(
1329     winapp::Activation::IActivatedEventArgs* args) {
1330   DVLOG(1) << __FUNCTION__;
1331   if (!ui_channel_)
1332     DVLOG(1) << "Launched to handle url request";
1333
1334   mswr::ComPtr<winapp::Activation::IProtocolActivatedEventArgs>
1335       protocol_args;
1336   CheckHR(args->QueryInterface(
1337           winapp::Activation::IID_IProtocolActivatedEventArgs,
1338           &protocol_args));
1339
1340   mswr::ComPtr<winfoundtn::IUriRuntimeClass> uri;
1341   protocol_args->get_Uri(&uri);
1342   mswrw::HString url;
1343   uri->get_AbsoluteUri(url.GetAddressOf());
1344   base::string16 actual_url(MakeStdWString(url.Get()));
1345   DVLOG(1) << "Received url request: " << actual_url;
1346
1347   ui_loop_.PostTask(FROM_HERE,
1348                     base::Bind(&ChromeAppViewAsh::OnNavigateToUrl,
1349                                base::Unretained(this),
1350                                actual_url));
1351   return S_OK;
1352 }
1353
1354 HRESULT ChromeAppViewAsh::OnEdgeGestureCompleted(
1355     winui::Input::IEdgeGesture* gesture,
1356     winui::Input::IEdgeGestureEventArgs* args) {
1357   if (ui_channel_)
1358     ui_channel_->Send(new MetroViewerHostMsg_EdgeGesture());
1359   return S_OK;
1360 }
1361
1362 void ChromeAppViewAsh::OnSearchRequest(const base::string16& search_string) {
1363   if (ui_channel_)
1364     ui_channel_->Send(new MetroViewerHostMsg_SearchRequest(search_string));
1365 }
1366
1367 void ChromeAppViewAsh::OnNavigateToUrl(const base::string16& url) {
1368   if (ui_channel_)
1369     ui_channel_->Send(new MetroViewerHostMsg_OpenURL(url));
1370 }
1371
1372 HRESULT ChromeAppViewAsh::OnSizeChanged(winui::Core::ICoreWindow* sender,
1373     winui::Core::IWindowSizeChangedEventArgs* args) {
1374   if (!window_ || !ui_channel_) {
1375     return S_OK;
1376   }
1377
1378   // winui::Core::IWindowSizeChangedEventArgs args->Size appears to return
1379   // scaled values under HiDPI. We will instead use GetWindowRect() which
1380   // should always return values in Pixels.
1381   RECT rect = {0};
1382   ::GetWindowRect(core_window_hwnd_, &rect);
1383
1384   uint32 cx = static_cast<uint32>(rect.right - rect.left);
1385   uint32 cy = static_cast<uint32>(rect.bottom - rect.top);
1386
1387   DVLOG(1) << "Window size changed: width=" << cx << ", height=" << cy;
1388   ui_channel_->Send(new MetroViewerHostMsg_WindowSizeChanged(cx, cy));
1389   return S_OK;
1390 }
1391
1392 void ChromeAppViewAsh::StartChromeOSMode() {
1393   static int ms_elapsed = 0;
1394
1395   if (!IPC::Channel::IsNamedServerInitialized(
1396           win8::kMetroViewerIPCChannelName) && ms_elapsed < 10000) {
1397     ms_elapsed += 100;
1398     ui_loop_.PostDelayedTask(FROM_HERE,
1399         base::Bind(base::IgnoreResult(&ChromeAppViewAsh::StartChromeOSMode),
1400                    base::Unretained(this)),
1401         base::TimeDelta::FromMilliseconds(kChromeChannelPollTimerMs));
1402     return;
1403   }
1404
1405   if (!IPC::Channel::IsNamedServerInitialized(
1406           win8::kMetroViewerIPCChannelName)) {
1407     DVLOG(1) << "Failed to connect to chrome channel : "
1408              << win8::kMetroViewerIPCChannelName;
1409     DVLOG(1) << "Exiting. Elapsed time :" << ms_elapsed;
1410     PostMessage(core_window_hwnd_, WM_CLOSE, 0, 0);
1411     return;
1412   }
1413
1414   DVLOG(1) << "Found channel : " << win8::kMetroViewerIPCChannelName;
1415
1416   DCHECK(channel_listener_);
1417
1418   // In Aura mode we create an IPC channel to the browser, then ask it to
1419   // connect to us.
1420   ui_channel_ =
1421       IPC::ChannelProxy::Create(win8::kMetroViewerIPCChannelName,
1422                                 IPC::Channel::MODE_NAMED_CLIENT,
1423                                 channel_listener_,
1424                                 io_thread_->task_runner());
1425   DVLOG(1) << "Created channel proxy";
1426
1427   // Upon receipt of the MetroViewerHostMsg_SetTargetSurface message the
1428   // browser will use D3D from the browser process to present to our Window.
1429   ui_channel_->Send(new MetroViewerHostMsg_SetTargetSurface(
1430       gfx::NativeViewId(core_window_hwnd_),
1431       win32_dpi_scale_));
1432   DVLOG(1) << "ICoreWindow sent " << core_window_hwnd_;
1433
1434   // Send an initial size message so that the Ash root window host gets sized
1435   // correctly.
1436   RECT rect = {0};
1437   ::GetWindowRect(core_window_hwnd_, &rect);
1438   ui_channel_->Send(
1439       new MetroViewerHostMsg_WindowSizeChanged(rect.right - rect.left,
1440                                                rect.bottom - rect.top));
1441
1442   input_source_ = metro_driver::InputSource::Create();
1443   if (input_source_) {
1444     input_source_->AddObserver(this);
1445     // Send an initial input source.
1446     OnInputSourceChanged();
1447   }
1448
1449   // Start receiving IME popup window notifications.
1450   metro_driver::AddImePopupObserver(this);
1451
1452   DVLOG(1) << "Channel setup complete";
1453 }
1454
1455 ///////////////////////////////////////////////////////////////////////////////
1456
1457 ChromeAppViewFactory::ChromeAppViewFactory(
1458     winapp::Core::ICoreApplication* icore_app) {
1459   mswr::ComPtr<winapp::Core::ICoreApplication> core_app(icore_app);
1460   mswr::ComPtr<winapp::Core::ICoreApplicationExit> app_exit;
1461   CheckHR(core_app.As(&app_exit));
1462   globals.app_exit = app_exit.Detach();
1463 }
1464
1465 IFACEMETHODIMP
1466 ChromeAppViewFactory::CreateView(winapp::Core::IFrameworkView** view) {
1467   *view = mswr::Make<ChromeAppViewAsh>().Detach();
1468   return (*view) ? S_OK :  E_OUTOFMEMORY;
1469 }