Manually merging remaining Win8 changes.

win8/metro_driver/chrome_app_view.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.h"
 
 #include <algorithm>
 #include <windows.applicationModel.datatransfer.h>
 #include <windows.foundation.h>
@@ skipping 38 matching lines @@
 static const int kFlipWindowsHotKeyId = 0x0000baba;
 
 static const int kAnimateWindowTimeoutMs = 200;
 
 static const int kCheckOSKDelayMs = 300;
 
 const wchar_t kOSKClassName[] = L"IPTip_Main_Window";
 
 static const int kOSKAdjustmentOffset = 20;
 
+const wchar_t kChromeSubclassWindowProp[] = L"MetroChromeWindowProc";
+
 namespace {
 
+enum Modifier {
+  NONE,
+  SHIFT = 1,
+  CONTROL = 2,
+  ALT = 4
+};
+
+// Helper function to send keystrokes via the SendInput function.
+// Params:
+// mnemonic_char: The keystroke to be sent.
+// modifiers: Combination with Alt, Ctrl, Shift, etc.
+// extended: whether this is an extended key.
+// unicode: whether this is a unicode key.
+void SendMnemonic(WORD mnemonic_char, Modifier modifiers, bool extended,
+                  bool unicode) {
+  INPUT keys[4] = {0};  // Keyboard events
+  int key_count = 0;  // Number of generated events
+
+  if (modifiers & SHIFT) {
+    keys[key_count].type = INPUT_KEYBOARD;
+    keys[key_count].ki.wVk = VK_SHIFT;
+    keys[key_count].ki.wScan = MapVirtualKey(VK_SHIFT, 0);
+    key_count++;
+  }
+
+  if (modifiers & CONTROL) {
+    keys[key_count].type = INPUT_KEYBOARD;
+    keys[key_count].ki.wVk = VK_CONTROL;
+    keys[key_count].ki.wScan = MapVirtualKey(VK_CONTROL, 0);
+    key_count++;
+  }
+
+  if (modifiers & ALT) {
+    keys[key_count].type = INPUT_KEYBOARD;
+    keys[key_count].ki.wVk = VK_MENU;
+    keys[key_count].ki.wScan = MapVirtualKey(VK_MENU, 0);
+    key_count++;
+  }
+
+  keys[key_count].type = INPUT_KEYBOARD;
+  keys[key_count].ki.wVk = mnemonic_char;
+  keys[key_count].ki.wScan = MapVirtualKey(mnemonic_char, 0);
+
+  if (extended)
+    keys[key_count].ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
+  if (unicode)
+    keys[key_count].ki.dwFlags |= KEYEVENTF_UNICODE;
+  key_count++;
+
+  bool should_sleep = key_count > 1;
+
+  // Send key downs
+  for (int i = 0; i < key_count; i++) {
+    SendInput(1, &keys[ i ], sizeof(keys[0]));
+    keys[i].ki.dwFlags |= KEYEVENTF_KEYUP;
+    if (should_sleep) {
+      Sleep(10);
+    }
+  }
+
+  // Now send key ups in reverse order
+  for (int i = key_count; i; i--) {
+    SendInput(1, &keys[ i - 1 ], sizeof(keys[0]));
+    if (should_sleep) {
+      Sleep(10);
+    }
+  }
+}
+
+void MetroExit() {
+  if (globals.core_window == ::GetForegroundWindow()) {
+    DVLOG(1) << "We are in the foreground. Exiting via Alt F4";
+    SendMnemonic(VK_F4, ALT, false, false);
+    DWORD core_window_process_id = 0;
+    DWORD core_window_thread_id = GetWindowThreadProcessId(
+        globals.core_window, &core_window_process_id);
+    if (core_window_thread_id != ::GetCurrentThreadId()) {
+      // Sleep to give time to the core window thread to get this message.
+      Sleep(100);
+    }
+  } else {
+    DVLOG(1) << "We are not in the foreground. Exiting normally";
+    globals.app_exit->Exit();
+    globals.core_window = NULL;
+  }
+}
+
 void AdjustToFitWindow(HWND hwnd, int flags) {
   RECT rect = {0};
   ::GetWindowRect(globals.core_window, &rect);
   int cx = rect.right - rect.left;
   int cy = rect.bottom - rect.top;
 
   ::SetWindowPos(hwnd, HWND_TOP,
                  rect.left, rect.top, cx, cy,
                  SWP_NOZORDER | flags);
 }
 
+LRESULT CALLBACK ChromeWindowProc(HWND window,
+                                  UINT message,
+                                  WPARAM wp,
+                                  LPARAM lp) {
+  if (message == WM_SETCURSOR) {
+    // Override the WM_SETCURSOR message to avoid showing the resize cursor
+    // as the mouse moves to the edge of the screen.
+    switch (LOWORD(lp)) {
+      case HTBOTTOM:
+      case HTBOTTOMLEFT:
+      case HTBOTTOMRIGHT:
+      case HTLEFT:
+      case HTRIGHT:
+      case HTTOP:
+      case HTTOPLEFT:
+      case HTTOPRIGHT:
+        lp = MAKELPARAM(HTCLIENT, HIWORD(lp));
+        break;
+      default:
+        break;
+    }
+  }
+
+  WNDPROC old_proc = reinterpret_cast<WNDPROC>(
+      ::GetProp(window, kChromeSubclassWindowProp));
+  DCHECK(old_proc);
+  return CallWindowProc(old_proc, window, message, wp, lp);
+}
+
 void AdjustFrameWindowStyleForMetro(HWND hwnd) {
   DVLOG(1) << __FUNCTION__;
   // Ajust the frame so the live preview works and the frame buttons dissapear.
   ::SetWindowLong(hwnd, GWL_STYLE,
                   WS_POPUP | (::GetWindowLong(hwnd, GWL_STYLE) &
                   ~(WS_MAXIMIZE | WS_CAPTION | WS_THICKFRAME | WS_SYSMENU)));
   ::SetWindowLong(hwnd, GWL_EXSTYLE,
                   ::GetWindowLong(hwnd, GWL_EXSTYLE) & ~(WS_EX_DLGMODALFRAME |
                   WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE));
+
+  // Subclass the wndproc of the frame window, if it's not already there.
+  if (::GetProp(hwnd, kChromeSubclassWindowProp) == NULL) {
+    WNDPROC old_chrome_proc = reinterpret_cast<WNDPROC>(
+        ::SetWindowLong(hwnd, GWL_WNDPROC,
+                        reinterpret_cast<long>(ChromeWindowProc)));
+    ::SetProp(hwnd, kChromeSubclassWindowProp, old_chrome_proc);
+  }
   AdjustToFitWindow(hwnd, SWP_FRAMECHANGED | SWP_NOACTIVATE);
 }
 
 void SetFrameWindowInternal(HWND hwnd) {
   DVLOG(1) << __FUNCTION__ << ", hwnd=" << LONG_PTR(hwnd);
 
   HWND current_top_frame =
       !globals.host_windows.empty() ? globals.host_windows.front().first : NULL;
   if (hwnd != current_top_frame && IsWindow(current_top_frame)) {
     DVLOG(1) << "Hiding current top window, hwnd="
@@ skipping 19 matching lines @@
     return (item.first == hwnd);
   });
 
   if (globals.host_windows.size() > 0) {
     DVLOG(1) << "Making new top frame window visible:"
             << reinterpret_cast<int>(globals.host_windows.front().first);
     AdjustToFitWindow(globals.host_windows.front().first, SWP_SHOWWINDOW);
   } else {
     // time to quit
     DVLOG(1) << "Last host window closed. Calling Exit().";
-    globals.app_exit->Exit();
+    MetroExit();
   }
 }
 
 void FlipFrameWindowsInternal() {
   DVLOG(1) << __FUNCTION__;
   // Get the first window in the frame windows queue and push it to the end.
   // Metroize the next window in the queue.
   if (globals.host_windows.size() > 1) {
     std::pair<HWND, bool> current_top_window = globals.host_windows.front();
     globals.host_windows.pop_front();
@@ skipping 348 matching lines @@
   // by Metro, so we instead read them directly from the pinned taskbar
   // shortcut. This may call Coinitialize and there is tell of badness
   // occurring if CoInitialize is called on a metro thread.
   globals.metro_command_line_switches =
       winrt_utils::ReadArgumentsFromPinnedTaskbarShortcut();
 
   globals.g_core_proc = reinterpret_cast<WNDPROC>(
       ::SetWindowLong(globals.core_window, GWL_WNDPROC,
                       reinterpret_cast<long>(ChromeAppView::CoreWindowProc)));
   DWORD exit_code = globals.host_main(globals.host_context);
+
   DVLOG(1) << "host thread done, exit_code=" << exit_code;
-  globals.app_exit->Exit();
+  MetroExit();
   return exit_code;
 }
 
 ChromeAppView::ChromeAppView()
     : osk_visible_notification_received_(false),
       osk_offset_adjustment_(0) {
   globals.previous_state =
       winapp::Activation::ApplicationExecutionState_NotRunning;
 }
 
@@ skipping 188 matching lines @@
   // windows active it is possible we end up stuck on the wait below therefore
   // we tell chrome to close its windows.
   if (!globals.host_windows.empty()) {
     DVLOG(1) << "Chrome still has windows open!";
     EndChromeSession();
   }
   DWORD wr = ::WaitForSingleObject(globals.host_thread, INFINITE);
   if (wr != WAIT_OBJECT_0) {
     DVLOG(1) << "Waiting for host thread failed : " << wr;
   }
+
+  DVLOG(1) << "Host thread exited";
+
   ::CloseHandle(globals.host_thread);
   globals.host_thread = NULL;
-
   return hr;
 }
 
 IFACEMETHODIMP
 ChromeAppView::Uninitialize() {
   DVLOG(1) << __FUNCTION__;
   window_ = nullptr;
   view_ = nullptr;
   base::AutoLock lock(notification_lock_);
   notification_map_.clear();
@@ skipping 338 matching lines @@
   CheckHR(core_app.As(&app_exit));
   globals.app_exit = app_exit.Detach();
 }
 
 IFACEMETHODIMP
 ChromeAppViewFactory::CreateView(winapp::Core::IFrameworkView** view) {
   globals.view = mswr::Make<ChromeAppView>().Detach();
   *view = globals.view;
   return (*view) ? S_OK :  E_OUTOFMEMORY;
 }