The metro_driver should not block the UI thread while waiting for the Chrome browser IPC channel to…

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>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
-#include "base/threading/thread.h"
 #include "base/win/metro.h"
 #include "base/win/win_util.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"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/win/dpi.h"
@@ skipping 52 matching lines @@
 
 namespace {
 
 enum KeyModifier {
   NONE,
   SHIFT = 1,
   CONTROL = 2,
   ALT = 4
 };
 
+const int kChromeChannelPollTimerMs = 100;
+const UINT_PTR kChromeChannelPollTimerId = 0xdeadbabe;
+static const wchar_t kChromeAppViewAshInstanceProp[] =
+    L"ChromeAppViewAshInstance";
+static const wchar_t kChromeChannelListenerProp[] =
+    L"ChromeChannelListenerProp";
+
 // Helper function to send keystrokes via the SendInput function.
 // mnemonic_char: The keystroke to be sent.
 // modifiers: Combination with Alt, Ctrl, Shift, etc.
 void SendKeySequence(
     WORD mnemonic_char, KeyModifier modifiers) {
   INPUT keys[4] = {0};  // Keyboard events
   int key_count = 0;  // Number of generated events
 
   if (modifiers & SHIFT) {
     keys[key_count].type = INPUT_KEYBOARD;
@@ skipping 571 matching lines @@
 }
 
 IFACEMETHODIMP
 ChromeAppViewAsh::Run() {
   DVLOG(1) << __FUNCTION__;
   mswr::ComPtr<winui::Core::ICoreDispatcher> dispatcher;
   HRESULT hr = window_->get_Dispatcher(dispatcher.GetAddressOf());
   CheckHR(hr, "Dispatcher failed.");
 
   // Create the IPC channel IO thread. It needs to out-live the ChannelProxy.
-  base::Thread io_thread("metro_IO_thread");
+  io_thread_.reset(new base::Thread("metro_IO_thread"));
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
-  io_thread.StartWithOptions(options);
+  io_thread_->StartWithOptions(options);
 
-  // Start up Chrome and wait for the desired IPC server connection to exist.
-  WaitForChromeIPCConnection(win8::kMetroViewerIPCChannelName);
+  ChromeChannelListener ui_channel_listener(&ui_loop_, this);
 
-  // In Aura mode we create an IPC channel to the browser, then ask it to
-  // connect to us.
-  ChromeChannelListener ui_channel_listener(&ui_loop_, this);
-  scoped_ptr<IPC::ChannelProxy> channel =
-      IPC::ChannelProxy::Create(win8::kMetroViewerIPCChannelName,
-                                IPC::Channel::MODE_NAMED_CLIENT,
-                                &ui_channel_listener,
-                                io_thread.message_loop_proxy());
-  ui_channel_ = channel.get();
+  // We can't do anything until the Chrome browser IPC channel is initialized.
+  // Lazy initialization in a timer.
+  ::SetProp(core_window_hwnd_, kChromeAppViewAshInstanceProp, this);
+  ::SetProp(core_window_hwnd_, kChromeChannelListenerProp,
+            &ui_channel_listener);
 
-  // Upon receipt of the MetroViewerHostMsg_SetTargetSurface message the
-  // browser will use D3D from the browser process to present to our Window.
-  ui_channel_->Send(new MetroViewerHostMsg_SetTargetSurface(
-                    gfx::NativeViewId(core_window_hwnd_), win32_dpi_scale_));
-  DVLOG(1) << "ICoreWindow sent " << core_window_hwnd_;
+  UINT_PTR channel_setup_timer_id =
+      ::SetTimer(core_window_hwnd_,
+                 kChromeChannelPollTimerId,
+                 kChromeChannelPollTimerMs,
+                 &ChromeAppViewAsh::StartChromeOSMode);
 
-  // Send an initial size message so that the Ash root window host gets sized
-  // correctly.
-  RECT rect = {0};
-  ::GetWindowRect(core_window_hwnd_, &rect);
-  ui_channel_->Send(
-      new MetroViewerHostMsg_WindowSizeChanged(rect.right - rect.left,
-                                               rect.bottom - rect.top));
-
-  input_source_ = metro_driver::InputSource::Create();
-  if (input_source_) {
-    input_source_->AddObserver(this);
-    // Send an initial input source.
-    OnInputSourceChanged();
-  }
-
-  // Start receiving IME popup window notifications.
-  metro_driver::AddImePopupObserver(this);
-
-  // And post the task that'll do the inner Metro message pumping to it.
+  // Post the task that'll do the inner Metro message pumping to it.
   ui_loop_.PostTask(FROM_HERE, base::Bind(&RunMessageLoop, dispatcher.Get()));
   ui_loop_.Run();
 
+  io_thread_.reset(NULL);
+  ui_channel_.reset(NULL);
+
   DVLOG(0) << "ProcessEvents done, hr=" << hr;
   return hr;
 }
 
 IFACEMETHODIMP
 ChromeAppViewAsh::Uninitialize() {
   DVLOG(1) << __FUNCTION__;
   metro_driver::RemoveImePopupObserver(this);
   input_source_.reset();
   text_service_.reset();
@@ skipping 331 matching lines @@
   // in turn launches the chrome browser process in desktop mode via
   // ShellExecute. If we call ICoreWindow::Activate before this, then
   // Windows kills the metro chrome process when it calls ShellExecute. Seems
   // to be a bug.
   window_->Activate();
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnPointerMoved(winui::Core::ICoreWindow* sender,
                                          winui::Core::IPointerEventArgs* args) {
+  if (!ui_channel_)
+    return S_OK;
+
   PointerInfoHandler pointer(metro_dpi_scale_, win32_dpi_scale_);
   HRESULT hr = pointer.Init(args);
   if (FAILED(hr))
     return hr;
 
   if (pointer.IsMouse()) {
     // If the mouse was moved towards the charms or the OS specific section,
     // the cursor may change from what the browser last set. Restore it here.
     if (::GetCursor() != last_cursor_)
       SetCursor(last_cursor_);
@@ skipping 15 matching lines @@
 
 // NOTE: From experimentation, it seems like Metro only sends a PointerPressed
 // event for the first button pressed and the last button released in a sequence
 // of mouse events.
 // For example, a sequence of LEFT_DOWN, RIGHT_DOWN, LEFT_UP, RIGHT_UP results
 // only in PointerPressed(LEFT)/PointerReleased(RIGHT) events. Intermediary
 // presses and releases are tracked in OnPointMoved().
 HRESULT ChromeAppViewAsh::OnPointerPressed(
     winui::Core::ICoreWindow* sender,
     winui::Core::IPointerEventArgs* args) {
+  if (!ui_channel_)
+    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_ = pointer.mouse_down_flags();
     SendMouseButton(pointer.x(), pointer.y(), 0, ui::ET_MOUSE_PRESSED,
                     mouse_down_flags_ | GetKeyboardEventFlags(),
                     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) {
+  if (!ui_channel_)
+    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());
   } 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) {
+  if (!ui_channel_)
+    return S_OK;
+
   PointerInfoHandler pointer(metro_dpi_scale_, win32_dpi_scale_);
   HRESULT hr = pointer.Init(args);
   if (FAILED(hr))
     return hr;
   DCHECK(pointer.IsMouse());
   SendMouseButton(pointer.x(), pointer.y(), pointer.wheel_delta(),
                   ui::ET_MOUSEWHEEL, GetKeyboardEventFlags(), ui::EF_NONE,
                   pointer.is_horizontal_wheel());
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnKeyDown(
     winui::Core::ICoreWindow* sender,
     winui::Core::IKeyEventArgs* args) {
+  if (!ui_channel_)
+    return S_OK;
+
   winsys::VirtualKey virtual_key;
   HRESULT hr = args->get_VirtualKey(&virtual_key);
   if (FAILED(hr))
     return hr;
   winui::Core::CorePhysicalKeyStatus status;
   hr = args->get_KeyStatus(&status);
   if (FAILED(hr))
     return hr;
 
   ui_channel_->Send(new MetroViewerHostMsg_KeyDown(virtual_key,
                                                    status.RepeatCount,
                                                    status.ScanCode,
                                                    GetKeyboardEventFlags()));
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnKeyUp(
     winui::Core::ICoreWindow* sender,
     winui::Core::IKeyEventArgs* args) {
+  if (!ui_channel_)
+    return S_OK;
+
   winsys::VirtualKey virtual_key;
   HRESULT hr = args->get_VirtualKey(&virtual_key);
   if (FAILED(hr))
     return hr;
   winui::Core::CorePhysicalKeyStatus status;
   hr = args->get_KeyStatus(&status);
   if (FAILED(hr))
     return hr;
 
   ui_channel_->Send(new MetroViewerHostMsg_KeyUp(virtual_key,
                                                  status.RepeatCount,
                                                  status.ScanCode,
                                                  GetKeyboardEventFlags()));
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnAcceleratorKeyDown(
     winui::Core::ICoreDispatcher* sender,
     winui::Core::IAcceleratorKeyEventArgs* args) {
+  if (!ui_channel_)
+    return S_OK;
+
   winsys::VirtualKey virtual_key;
   HRESULT hr = args->get_VirtualKey(&virtual_key);
   if (FAILED(hr))
     return hr;
   winui::Core::CorePhysicalKeyStatus status;
   hr = args->get_KeyStatus(&status);
   if (FAILED(hr))
     return hr;
 
   winui::Core::CoreAcceleratorKeyEventType event_type;
@@ skipping 34 matching lines @@
 
     default:
       break;
   }
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnCharacterReceived(
   winui::Core::ICoreWindow* sender,
   winui::Core::ICharacterReceivedEventArgs* args) {
+  if (!ui_channel_)
+    return S_OK;
+
   unsigned int char_code = 0;
   HRESULT hr = args->get_KeyCode(&char_code);
   if (FAILED(hr))
     return hr;
 
   winui::Core::CorePhysicalKeyStatus status;
   hr = args->get_KeyStatus(&status);
   if (FAILED(hr))
     return hr;
 
   ui_channel_->Send(new MetroViewerHostMsg_Character(char_code,
                                                      status.RepeatCount,
                                                      status.ScanCode,
                                                      GetKeyboardEventFlags()));
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnWindowActivated(
     winui::Core::ICoreWindow* sender,
     winui::Core::IWindowActivatedEventArgs* args) {
+  if (!ui_channel_)
+    return S_OK;
+
   if (args) {
     winui::Core::CoreWindowActivationState state;
     HRESULT hr = args->get_WindowActivationState(&state);
     if (FAILED(hr))
       return hr;
 
     // Treat both full activation (Ash was reopened from the Start Screen or
     // from any other Metro entry point in Windows) and pointer activation
     // (user clicked back in Ash after using another app on another monitor)
     // the same.
@@ skipping 88 matching lines @@
   ::GetWindowRect(core_window_hwnd_, &rect);
 
   uint32 cx = static_cast<uint32>(rect.right - rect.left);
   uint32 cy = static_cast<uint32>(rect.bottom - rect.top);
 
   DVLOG(1) << "Window size changed: width=" << cx << ", height=" << cy;
   ui_channel_->Send(new MetroViewerHostMsg_WindowSizeChanged(cx, cy));
   return S_OK;
 }
 
+// static
+void CALLBACK ChromeAppViewAsh::StartChromeOSMode(HWND core_window,
+                                                  UINT message,
+                                                  UINT_PTR timer_id,
+                                                  DWORD time) {
+  static int ms_elapsed = 0;
+  if (!IPC::Channel::IsNamedServerInitialized(

[scottmg, 2014/09/24 02:40:32]

WaitForChromeIPCConnection isn't used any more, should be deleted

[ananta, 2014/09/24 18:22:33]

Done.

+          win8::kMetroViewerIPCChannelName) && ms_elapsed < 10000) {
+    ms_elapsed += 100;
+    return;
+  }
+
+  if (!IPC::Channel::IsNamedServerInitialized(
+          win8::kMetroViewerIPCChannelName)) {
+    DVLOG(1) << "Failed to connect to chrome channel : "
+             << win8::kMetroViewerIPCChannelName;
+    DVLOG(1) << "Exiting...";
+    PostMessage(core_window, WM_CLOSE, 0, 0);
+    ::RemoveProp(core_window, kChromeAppViewAshInstanceProp);

[scottmg, 2014/09/24 02:40:32]

why do we need window props instead of plain globals, when e.g. ms_elapsed is
just a static?

[ananta, 2014/09/24 18:22:33]

Good point. Done.

+    ::RemoveProp(core_window, kChromeChannelListenerProp);
+    ::KillTimer(core_window, kChromeChannelPollTimerId);

[scottmg, 2014/09/24 02:40:32]

killtimer here and below can move out above the if

[ananta, 2014/09/24 18:22:33]

Done.

+    return;
+  }
+
+  ::KillTimer(core_window, kChromeChannelPollTimerId);
+
+  DVLOG(1) << "Found channel : " << win8::kMetroViewerIPCChannelName;
+
+  ChromeAppViewAsh* instance = reinterpret_cast<ChromeAppViewAsh*>(
+      ::GetProp(core_window, kChromeAppViewAshInstanceProp));
+  DCHECK(instance);
+
+  ChromeChannelListener* listener = reinterpret_cast<ChromeChannelListener*>(
+       ::GetProp(core_window, kChromeChannelListenerProp));
+  DCHECK(listener);
+
+  // In Aura mode we create an IPC channel to the browser, then ask it to
+  // connect to us.
+  instance->ui_channel_ =
+      IPC::ChannelProxy::Create(win8::kMetroViewerIPCChannelName,
+                                IPC::Channel::MODE_NAMED_CLIENT,
+                                listener,
+                                instance->io_thread_->message_loop_proxy());
+  DVLOG(1) << "Created channel proxy";
+
+  // Upon receipt of the MetroViewerHostMsg_SetTargetSurface message the
+  // browser will use D3D from the browser process to present to our Window.
+  instance->ui_channel_->Send(new MetroViewerHostMsg_SetTargetSurface(
+                              gfx::NativeViewId(core_window),
+                              instance->win32_dpi_scale_));
+  DVLOG(1) << "ICoreWindow sent " << core_window;
+
+  // Send an initial size message so that the Ash root window host gets sized
+  // correctly.
+  RECT rect = {0};
+  ::GetWindowRect(core_window, &rect);
+  instance->ui_channel_->Send(
+      new MetroViewerHostMsg_WindowSizeChanged(rect.right - rect.left,
+                                               rect.bottom - rect.top));
+
+  instance->input_source_ = metro_driver::InputSource::Create();
+  if (instance->input_source_) {
+    instance->input_source_->AddObserver(instance);
+    // Send an initial input source.
+    instance->OnInputSourceChanged();
+  }
+
+  // Start receiving IME popup window notifications.
+  metro_driver::AddImePopupObserver(instance);
+
+  ::RemoveProp(core_window, kChromeAppViewAshInstanceProp);
+  ::RemoveProp(core_window, kChromeChannelListenerProp);
+
+  DVLOG(1) << "Channel setup complete";
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 ChromeAppViewFactory::ChromeAppViewFactory(
     winapp::Core::ICoreApplication* icore_app) {
   mswr::ComPtr<winapp::Core::ICoreApplication> core_app(icore_app);
   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;
 }