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;
+
 // 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 166 matching lines @@
         base::Bind(&ChromeAppViewAsh::OnImeUpdateTextInputClient,
                    base::Unretained(app_view_),
                    input_scopes,
                    character_bounds));
   }
 
   scoped_refptr<base::MessageLoopProxy> ui_proxy_;
   ChromeAppViewAsh* app_view_;
 };
 
-bool WaitForChromeIPCConnection(const std::string& channel_name) {
-  int ms_elapsed = 0;
-  while (!IPC::Channel::IsNamedServerInitialized(channel_name) &&
-         ms_elapsed < 10000) {
-    ms_elapsed += 100;
-    Sleep(100);
-  }
-  return IPC::Channel::IsNamedServerInitialized(channel_name);
-}
-
 void RunMessageLoop(winui::Core::ICoreDispatcher* dispatcher) {
   // We're entering a nested message loop, let's allow dispatching
   // tasks while we're in there.
   base::MessageLoop::current()->SetNestableTasksAllowed(true);
 
   // Enter main core message loop. There are several ways to exit it
   // Nicely:
   // 1 - User action like ALT-F4.
   // 2 - Calling ICoreApplicationExit::Exit().
   // 3-  Posting WM_CLOSE to the core window.
@@ skipping 222 matching lines @@
 
   // 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_;
 
   DISALLOW_COPY_AND_ASSIGN(PointerInfoHandler);
 };
 
+ChromeAppViewAsh* ChromeAppViewAsh::g_instance_ = NULL;
+
 ChromeAppViewAsh::ChromeAppViewAsh()
     : mouse_down_flags_(ui::EF_NONE),
       ui_channel_(nullptr),
       core_window_hwnd_(NULL),
       metro_dpi_scale_(0),
       win32_dpi_scale_(0),
-      last_cursor_(NULL) {
+      last_cursor_(NULL),
+      channel_listener_(NULL) {
   DVLOG(1) << __FUNCTION__;
   globals.previous_state =
       winapp::Activation::ApplicationExecutionState_NotRunning;
+  DCHECK(!g_instance_);
+
+  g_instance_ = this;
 }
 
 ChromeAppViewAsh::~ChromeAppViewAsh() {
   DVLOG(1) << __FUNCTION__;
 }
 
 IFACEMETHODIMP
 ChromeAppViewAsh::Initialize(winapp::Core::ICoreApplicationView* view) {
   view_ = view;
   DVLOG(1) << __FUNCTION__;
@@ skipping 123 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);
+  channel_listener_ = &ui_channel_listener;
 
-  // 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.
 
-  // 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 =

[cpu_(ooo_6.6-7.5), 2014/09/25 23:00:08]

change to base::timer, since in line 698 we run our message loop, it should
work. Then you can use base::bind so you should not need globals or touch the
core_window_hwnd_

[ananta, 2014/09/26 02:29:01]

Good point. Done.

+      ::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);
+  channel_listener_ = 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 232 matching lines @@
     ::PostMessage(core_window, WM_CLOSE, 0, 0);
 
     globals.app_exit->Exit();
   }
 }
 
 void ChromeAppViewAsh::OnInputSourceChanged() {
   if (!input_source_)
     return;
 
+  DCHECK(ui_channel_);
+
   LANGID langid = 0;
   bool is_ime = false;
   if (!input_source_->GetActiveSource(&langid, &is_ime)) {
     LOG(ERROR) << "GetActiveSource failed";
     return;
   }
   ui_channel_->Send(new MetroViewerHostMsg_ImeInputSourceChanged(langid,
                                                                  is_ime));
 }
 
@@ skipping 10 matching lines @@
   ui_channel_->Send(new MetroViewerHostMsg_ImeTextCommitted(text));
 }
 
 void ChromeAppViewAsh::SendMouseButton(int x,
                                        int y,
                                        int extra,
                                        ui::EventType event_type,
                                        uint32 flags,
                                        ui::EventFlags changed_button,
                                        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.event_type = event_type;
   params.flags = static_cast<int32>(flags);
   params.changed_button = changed_button;
   params.is_horizontal_wheel = is_horizontal_wheel;
   ui_channel_->Send(new MetroViewerHostMsg_MouseButton(params));
 }
@@ skipping 49 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 54 matching lines @@
   ui_loop_.PostTask(FROM_HERE,
                     base::Bind(&ChromeAppViewAsh::OnNavigateToUrl,
                                base::Unretained(this),
                                actual_url));
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::OnEdgeGestureCompleted(
     winui::Input::IEdgeGesture* gesture,
     winui::Input::IEdgeGestureEventArgs* args) {
-  ui_channel_->Send(new MetroViewerHostMsg_EdgeGesture());
+  if (ui_channel_)
+    ui_channel_->Send(new MetroViewerHostMsg_EdgeGesture());
   return S_OK;
 }
 
 void ChromeAppViewAsh::OnSearchRequest(const base::string16& search_string) {
-  DCHECK(ui_channel_);
-  ui_channel_->Send(new MetroViewerHostMsg_SearchRequest(search_string));
+  if (ui_channel_)
+    ui_channel_->Send(new MetroViewerHostMsg_SearchRequest(search_string));
 }
 
 void ChromeAppViewAsh::OnNavigateToUrl(const base::string16& url) {
-  DCHECK(ui_channel_);
- ui_channel_->Send(new MetroViewerHostMsg_OpenURL(url));
+  if (ui_channel_)
+    ui_channel_->Send(new MetroViewerHostMsg_OpenURL(url));
 }
 
 HRESULT ChromeAppViewAsh::OnSizeChanged(winui::Core::ICoreWindow* sender,
     winui::Core::IWindowSizeChangedEventArgs* args) {
   if (!window_) {
     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);
 
   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(
+          win8::kMetroViewerIPCChannelName) && ms_elapsed < 10000) {
+    ms_elapsed += 100;
+    return;
+  }
+
+  ::KillTimer(core_window, kChromeChannelPollTimerId);
+
+  if (!IPC::Channel::IsNamedServerInitialized(
+          win8::kMetroViewerIPCChannelName)) {
+    DVLOG(1) << "Failed to connect to chrome channel : "
+             << win8::kMetroViewerIPCChannelName;
+    DVLOG(1) << "Exiting. Elapsed time :" << ms_elapsed;
+    PostMessage(core_window, WM_CLOSE, 0, 0);
+    return;
+  }
+
+  DVLOG(1) << "Found channel : " << win8::kMetroViewerIPCChannelName;
+
+  DCHECK(g_instance_);
+  DCHECK(g_instance_->channel_listener_);
+
+  // In Aura mode we create an IPC channel to the browser, then ask it to
+  // connect to us.
+  g_instance_->ui_channel_ =
+      IPC::ChannelProxy::Create(win8::kMetroViewerIPCChannelName,
+                                IPC::Channel::MODE_NAMED_CLIENT,
+                                g_instance_->channel_listener_,
+                                g_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.
+  g_instance_->ui_channel_->Send(new MetroViewerHostMsg_SetTargetSurface(
+                                 gfx::NativeViewId(core_window),
+                                 g_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);
+  g_instance_->ui_channel_->Send(
+      new MetroViewerHostMsg_WindowSizeChanged(rect.right - rect.left,
+                                               rect.bottom - rect.top));
+
+  g_instance_->input_source_ = metro_driver::InputSource::Create();
+  if (g_instance_->input_source_) {
+    g_instance_->input_source_->AddObserver(g_instance_);
+    // Send an initial input source.
+    g_instance_->OnInputSourceChanged();
+  }
+
+  // Start receiving IME popup window notifications.
+  metro_driver::AddImePopupObserver(g_instance_);
+
+  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;
 }