Make chrome.exe rendezvous with existing chrome process earlier.

chrome/app/chrome_exe_main_win.cc

 // Copyright (c) 2011 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 <windows.h>
 #include <tchar.h>
 
+#include <algorithm>
+#include <string>
+
 #include "base/at_exit.h"
 #include "base/command_line.h"
+#include "base/files/file_path.h"
 #include "chrome/app/breakpad_win.h"
 #include "chrome/app/client_util.h"
 #include "chrome/app/metro_driver_win.h"
+#include "chrome/browser/chrome_process_finder_win.h"
+#include "chrome/browser/policy/policy_path_parser.h"
+#include "chrome/common/chrome_paths_internal.h"
+#include "chrome/common/chrome_switches.h"
 #include "content/public/app/startup_helper_win.h"
 #include "content/public/common/result_codes.h"
 #include "sandbox/win/src/sandbox_factory.h"
 
+namespace {
+
 int RunChrome(HINSTANCE instance) {
   bool exit_now = true;
   // We restarted because of a previous crash. Ask user if we should relaunch.
   if (ShowRestartDialogIfCrashed(&exit_now)) {
     if (exit_now)
       return content::RESULT_CODE_NORMAL_EXIT;
   }
 
   // Initialize the sandbox services.
   sandbox::SandboxInterfaceInfo sandbox_info = {0};
   content::InitializeSandboxInfo(&sandbox_info);
 
   // Load and launch the chrome dll. *Everything* happens inside.
   MainDllLoader* loader = MakeMainDllLoader();
   int rc = loader->Launch(instance, &sandbox_info);
   loader->RelaunchChromeBrowserWithNewCommandLineIfNeeded();
   delete loader;
   return rc;
 }
 
+
+bool IsFastStartSwitch(const std::string& command_line_switch) {
+  // List of switches that it's safe to rendezvous early with. Fast start should
+  // not be done if a command line contains a switch not in this set.
+  static const char* kFastStartSwitches[] = {

[grt (UTC plus 2), 2013/05/13 13:32:07]

Use the extra const to keep the whole structure in the RO data segment:
  static const char* const kFastStartSwitches

[koz (OOO until 15th September), 2013/05/14 08:39:54]

Done.

+    switches::kProfileDirectory,
+    switches::kShowAppList,
+  };
+  for (size_t i = 0; i < arraysize(kFastStartSwitches); ++i)

[gab, 2013/05/13 13:27:43]

nit: wrap for loop in {} since content is multiple lines

[grt (UTC plus 2), 2013/05/13 13:32:07]

braces on the "for" loop

[koz (OOO until 15th September), 2013/05/14 08:39:54]

Done.

[koz (OOO until 15th September), 2013/05/14 08:39:54]

Done.

+    if (command_line_switch == kFastStartSwitches[i])
+      return true;
+  return false;
+}
+
+bool ContainsNonFastStartFlag(CommandLine* command_line) {

[gab, 2013/05/13 13:27:43]

This algorithm is O(m*n), where:
m is the number of fast-start-switches.
n is the number of switches on the command-line.

This could easily be made O(n) by putting the fast-start-switches in a hash
table; I agree however that since m is 2 in this case it's probably faster to
avoid building a hash table just for this...

Perhaps this should be emphasized by a comment (or even by removing the for loop
in IsFastStartSwitch() and just explicitly adding if{}else if{} blocks to check
for both switches explicitly..?

You could also add a quick check at the beginning of ContainsNonFastStartFlag()
to check if the command-line has more switches than there are
fast-start-switches to quickly return instead of starting lookups in the
SwitchMap (although I guess you could prove that you are guaranteed to return in
m+1 lookups (not n) so that the algo is really O(m^2)).

[koz (OOO until 15th September), 2013/05/14 08:39:54]

I added the comment and the size check.

+  const CommandLine::SwitchMap& switches = command_line->GetSwitches();

[gab, 2013/05/13 13:27:43]

Hmmm... GetSwitches is confusing, it says "// Get a copy of all switches, along
with their values."... yet it doesn't return a copy, but a reference to the
internal structure... either way, it returns a const& so GetSwitches() can
probably be made a const-method, allowing this method to use a const&
command_line?

[koz (OOO until 15th September), 2013/05/14 08:39:54]

Done.

+  for (CommandLine::SwitchMap::const_iterator it = switches.begin();
+       it != switches.end(); it++) {

[gab, 2013/05/13 13:27:43]

nit: ++it

[koz (OOO until 15th September), 2013/05/14 08:39:54]

Done.

+    if (!IsFastStartSwitch(it->first))
+      return true;
+  }
+  return false;
+}
+
+bool AttemptFastNotify(CommandLine* command_line) {
+  if (ContainsNonFastStartFlag(command_line))
+    return false;
+
+  base::FilePath user_data_dir;
+  if (!chrome::GetDefaultUserDataDirectory(&user_data_dir))
+    return false;
+  policy::path_parser::CheckUserDataDirPolicy(&user_data_dir);
+
+  HWND chrome = chrome::FindRunningChromeWindow(user_data_dir);
+  return chrome && chrome::AttemptToNotifyRunningChrome(chrome);
+}
+
+}  // namespace
+
 int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE prev, wchar_t*, int) {
   // Initialize the commandline singleton from the environment.
   CommandLine::Init(0, NULL);
   // The exit manager is in charge of calling the dtors of singletons.
   base::AtExitManager exit_manager;
 
+  if (AttemptFastNotify(CommandLine::ForCurrentProcess()))
+    return 0;
+
   MetroDriver metro_driver;
   if (metro_driver.in_metro_mode())
     return metro_driver.RunInMetro(instance, &RunChrome);
   // Not in metro mode, proceed as normal.
   return RunChrome(instance);
 }