Make chrome.exe rendezvous with existing chrome process earlier.

chrome/browser/process_singleton_win.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 "chrome/browser/process_singleton.h"
 
 #include <shellapi.h>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/process_info.h"
 #include "base/process_util.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/metro.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "base/win/wrapped_window_proc.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chrome_process_finder_win.h"
+#include "chrome/browser/metro_utils/metro_chrome_win.h"
 #include "chrome/browser/shell_integration.h"
-#include "chrome/browser/ui/metro_chrome_win.h"
 #include "chrome/browser/ui/simple_message_box.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/util/wmi.h"
 #include "content/public/common/result_codes.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/win/hwnd_util.h"
 
 namespace {
 
 const char kLockfile[] = "lockfile";
 
-const char kSearchUrl[] =
-  "http://www.google.com/search?q=%s&sourceid=chrome&ie=UTF-8";
-
 const int kMetroChromeActivationTimeoutMs = 3000;
 
 // A helper class that acquires the given |mutex| while the AutoLockMutex is in
 // scope.
 class AutoLockMutex {
  public:
   explicit AutoLockMutex(HANDLE mutex) : mutex_(mutex) {
     DWORD result = ::WaitForSingleObject(mutex_, INFINITE);
     DPCHECK(result == WAIT_OBJECT_0) << "Result = " << result;
   }
@@ skipping 181 matching lines @@
     if (!installer::WMIProcess::Launch(::GetCommandLineW(), &process_id))
       return false;
     is_virtualized_ = true;
     // The new window was spawned from WMI, and won't be in the foreground.
     // So, first we sleep while the new chrome.exe instance starts (because
     // WaitForInputIdle doesn't work here). Then we poll for up to two more
     // seconds and make the window foreground if we find it (or we give up).
     HWND hwnd = 0;
     ::Sleep(90);
     for (int tries = 200; tries; --tries) {
-      hwnd = ::FindWindowEx(HWND_MESSAGE, NULL, chrome::kMessageWindowClass,
-                            user_data_dir.value().c_str());
+      hwnd = chrome::FindRunningChromeWindow(user_data_dir);
       if (hwnd) {
         ::SetForegroundWindow(hwnd);
         break;
       }
       ::Sleep(10);
     }
     return true;
   }
   return false;
 }
@@ skipping 22 matching lines @@
 // Code roughly based on Mozilla.
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
   if (is_virtualized_)
     return PROCESS_NOTIFIED;  // We already spawned the process in this case.
   if (lock_file_ == INVALID_HANDLE_VALUE && !remote_window_) {
     return LOCK_ERROR;
   } else if (!remote_window_) {
     return PROCESS_NONE;
   }
 
   DWORD process_id = 0;

[gab, 2013/05/15 13:28:03]

This code is already in AttemptToNotifyRunningChrome().

[koz (OOO until 15th September), 2013/05/17 00:12:42]

These variables are used further down.

   DWORD thread_id = ::GetWindowThreadProcessId(remote_window_, &process_id);
   // It is possible that the process owning this window may have died by now.
   if (!thread_id || !process_id) {
     remote_window_ = NULL;
     return PROCESS_NONE;
   }
 
-  if (base::win::IsMetroProcess()) {
-    // Interesting corner case. We are launched as a metro process but we
-    // found another chrome running. Since metro enforces single instance then
-    // the other chrome must be desktop chrome and this must be a search charm
-    // activation. This scenario is unique; other cases should be properly
-    // handled by the delegate_execute which will not activate a second chrome.
-    string16 terms;
-    base::win::MetroLaunchType launch = base::win::GetMetroLaunchParams(&terms);
-    if (launch != base::win::METRO_SEARCH) {
-      LOG(WARNING) << "In metro mode, but and launch is " << launch;
-    } else {
-      std::string query = net::EscapeQueryParamValue(UTF16ToUTF8(terms), true);
-      std::string url = base::StringPrintf(kSearchUrl, query.c_str());
-      SHELLEXECUTEINFOA sei = { sizeof(sei) };
-      sei.fMask = SEE_MASK_FLAG_LOG_USAGE;
-      sei.nShow = SW_SHOWNORMAL;
-      sei.lpFile = url.c_str();
-      ::OutputDebugStringA(sei.lpFile);
-      sei.lpDirectory = "";
-      ::ShellExecuteExA(&sei);
-    }
+  if (chrome::AttemptToNotifyRunningChrome(remote_window_))
     return PROCESS_NOTIFIED;
-  }
-
-  // Non-metro mode, send our command line to the other chrome message window.
-  // format is "START\0<<<current directory>>>\0<<<commandline>>>".
-  std::wstring to_send(L"START\0", 6);  // want the NULL in the string.
-  base::FilePath cur_dir;
-  if (!PathService::Get(base::DIR_CURRENT, &cur_dir))
-    return PROCESS_NONE;
-  to_send.append(cur_dir.value());
-  to_send.append(L"\0", 1);  // Null separator.
-  to_send.append(::GetCommandLineW());
-  // Add the process start time as a flag.
-  to_send.append(L" --");
-  to_send.append(ASCIIToWide(switches::kOriginalProcessStartTime));
-  to_send.append(L"=");
-  to_send.append(base::Int64ToString16(
-      base::CurrentProcessInfo::CreationTime()->ToInternalValue()));
-  to_send.append(L"\0", 1);  // Null separator.
-
-  base::win::ScopedHandle process_handle;
-  if (base::win::GetVersion() >= base::win::VERSION_WIN8 &&
-      base::OpenProcessHandleWithAccess(
-          process_id, PROCESS_QUERY_INFORMATION,
-          process_handle.Receive()) &&
-      base::win::IsProcessImmersive(process_handle.Get())) {
-    chrome::ActivateMetroChrome();
-  }
-
-  // Allow the current running browser window making itself the foreground
-  // window (otherwise it will just flash in the taskbar).
-  ::AllowSetForegroundWindow(process_id);
-
-  COPYDATASTRUCT cds;
-  cds.dwData = 0;
-  cds.cbData = static_cast<DWORD>((to_send.length() + 1) * sizeof(wchar_t));
-  cds.lpData = const_cast<wchar_t*>(to_send.c_str());
-  DWORD_PTR result = 0;
-  if (::SendMessageTimeout(remote_window_,
-                           WM_COPYDATA,
-                           NULL,
-                           reinterpret_cast<LPARAM>(&cds),
-                           SMTO_ABORTIFHUNG,
-                           kTimeoutInSeconds * 1000,
-                           &result)) {
-    // It is possible that the process owning this window may have died by now.
-    if (!result) {
-      remote_window_ = NULL;
-      return PROCESS_NONE;
-    }
-    return PROCESS_NOTIFIED;
-  }
+  else
+    remote_window_ = NULL;

[gab, 2013/05/15 13:28:03]

Some of these cases should return PROCESS_NONE here to keep the same behavior.

It's probably simpler to just move the enum and have
chrome::AttemptToNotifyRunningChrome return an enum (e.g., something like:
PROCESS_NOTIFY_SUCCESS (success cases -- we should return early),
PROCESS_NOTIFY_FAILED (failed cases -- we should launch), and
PROCESS_NOTIFY_WINDOW_HUNG (when we should keep going below -- or, in the
chrome.exe case, abandon the early rendez-vous (since we can't pop a dialog from
chrome.exe; as it is currently though, we will wait for the 20s timeout again
when trying to rdv a second time in process_singleton, although we "know" from
chrome.exe that the window is hung... could we signal that to process_singleton
from chrome.exe somehow?)).

[koz (OOO until 15th September), 2013/05/17 00:12:42]

Done.

I don't know if it's worth trying to signal to chrome.dll that the window has
hung.

 
   // It is possible that the process owning this window may have died by now.
   if (!::IsWindow(remote_window_)) {

[gab, 2013/05/15 13:28:03]

You can also move this block in chrome::AttemptToNotifyRunningChrome().

[koz (OOO until 15th September), 2013/05/17 00:12:42]

Done.

     remote_window_ = NULL;
     return PROCESS_NONE;
   }
 
   // The window is hung. Scan for every window to find a visible one.
   bool visible_window = false;
   ::EnumThreadWindows(thread_id,
                       &BrowserWindowEnumeration,
                       reinterpret_cast<LPARAM>(&visible_window));
 
@@ skipping 26 matching lines @@
 }
 
 // Look for a Chrome instance that uses the same profile directory. If there
 // isn't one, create a message window with its title set to the profile
 // directory path.
 bool ProcessSingleton::Create() {
   static const wchar_t kMutexName[] = L"Local\\ChromeProcessSingletonStartup!";
   static const wchar_t kMetroActivationEventName[] =
       L"Local\\ChromeProcessSingletonStartupMetroActivation!";
 
-  remote_window_ = ::FindWindowEx(HWND_MESSAGE, NULL,
-                                  chrome::kMessageWindowClass,
-                                  user_data_dir_.value().c_str());
+  remote_window_ = chrome::FindRunningChromeWindow(user_data_dir_);
   if (!remote_window_ && !EscapeVirtualization(user_data_dir_)) {
     // Make sure we will be the one and only process creating the window.
     // We use a named Mutex since we are protecting against multi-process
     // access. As documented, it's clearer to NOT request ownership on creation
     // since it isn't guaranteed we will get it. It is better to create it
     // without ownership and explicitly get the ownership afterward.
     base::win::ScopedHandle only_me(::CreateMutex(NULL, FALSE, kMutexName));
     DPCHECK(only_me.IsValid());
 
     AutoLockMutex auto_lock_only_me(only_me);
 
     // We now own the mutex so we are the only process that can create the
     // window at this time, but we must still check if someone created it
     // between the time where we looked for it above and the time the mutex
     // was given to us.
-    remote_window_ = ::FindWindowEx(HWND_MESSAGE, NULL,
-                                    chrome::kMessageWindowClass,
-                                    user_data_dir_.value().c_str());
+    remote_window_ = chrome::FindRunningChromeWindow(user_data_dir_);
 
 
     // In Win8+, a new Chrome process launched in Desktop mode may need to be
     // transmuted into Metro Chrome (see ShouldLaunchInWindows8ImmersiveMode for
     // heuristics). To accomplish this, the current Chrome activates Metro
     // Chrome, releases the startup mutex, and waits for metro Chrome to take
     // the singleton. From that point onward, the command line for this Chrome
     // process will be sent to Metro Chrome by the usual channels.
     if (!remote_window_ && base::win::GetVersion() >= base::win::VERSION_WIN8 &&
         !base::win::IsMetroProcess()) {
@@ skipping 28 matching lines @@
 
           DWORD result = ::WaitForSingleObject(metro_activation_event,
                                                kMetroChromeActivationTimeoutMs);
           DPCHECK(result == WAIT_OBJECT_0 || result == WAIT_TIMEOUT)
               << "Result = " << result;
         }
 
         // Check if this singleton was successfully grabbed by another process
         // (hopefully Metro Chrome). Failing to do so, this process will grab
         // the singleton and launch in Desktop mode.
-        remote_window_ = ::FindWindowEx(HWND_MESSAGE, NULL,
-                                        chrome::kMessageWindowClass,
-                                        user_data_dir_.value().c_str());
+        remote_window_ = chrome::FindRunningChromeWindow(user_data_dir_);
       }
     }
 
     if (!remote_window_) {
       // We have to make sure there is no Chrome instance running on another
       // machine that uses the same profile.
       base::FilePath lock_file_path = user_data_dir_.AppendASCII(kLockfile);
       lock_file_ = ::CreateFile(lock_file_path.value().c_str(),
                                 GENERIC_WRITE,
                                 FILE_SHARE_READ,
@@ skipping 58 matching lines @@
   switch (message) {
     case WM_COPYDATA:
       return OnCopyData(reinterpret_cast<HWND>(wparam),
                         reinterpret_cast<COPYDATASTRUCT*>(lparam));
     default:
       break;
   }
 
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }