Make chrome.exe rendezvous with existing chrome process earlier.

This change causes chrome to attempt to locate and defer to an already running
chrome process earlier in startup (before chrome.dll is loaded).

Some benchmarks* (all times are in ms):

ASUS S200E (low-end netbook):
Unpatched: 1109, 547, 2656, 381
Patched:   125,  125,   78,  78

z620 (high-end dev machine)
Unpatched: 124, 125, 125, 219
Patched:    47,  63,  63,  46

chrome.exe size:
Unpatched: 748K
Patched:   768K

* The period measured was that between chrome.exe being executed and the existing chrome process receiving WM_COPYDATA.

BUG=171588
TBR=cpu@chromium.org, gab@chromium.org, grt@chromium.org, pastarmovj@chromium.org, shrikant@chromium.org, sky@chromium.org

Review URL: https://codereview.chromium.org/14617003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@204099 0039d316-1c4b-4281-b951-d872f2087c98

chrome/app/chrome_exe_main_win.cc

@@ -5,15 +5,24 @@
 #include <windows.h>
 #include <tchar.h>
 
+#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.
@@ -34,12 +43,61 @@ int RunChrome(HINSTANCE instance) {
   return rc;
 }
 
+// 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.
+// Note this is currently stored as a list of two because it's probably faster
+// to iterate over this small array than building a map for constant time
+// lookups.
+const char* const kFastStartSwitches[] = {
+  switches::kProfileDirectory,
+  switches::kShowAppList,
+};
+
+bool IsFastStartSwitch(const std::string& command_line_switch) {
+  for (size_t i = 0; i < arraysize(kFastStartSwitches); ++i) {
+    if (command_line_switch == kFastStartSwitches[i])
+      return true;
+  }
+  return false;
+}
+
+bool ContainsNonFastStartFlag(const CommandLine& command_line) {
+  const CommandLine::SwitchMap& switches = command_line.GetSwitches();
+  if (switches.size() > arraysize(kFastStartSwitches))
+    return true;
+  for (CommandLine::SwitchMap::const_iterator it = switches.begin();
+       it != switches.end(); ++it) {
+    if (!IsFastStartSwitch(it->first))
+      return true;
+  }
+  return false;
+}
+
+bool AttemptFastNotify(const 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) == chrome::NOTIFY_SUCCESS;
+}
+
+}  // 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);

chrome/browser/chrome_process_finder_win.cc

+// Copyright 2013 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/chrome_process_finder_win.h"
+
+#include <shellapi.h>
+#include <string>
+
+#include "base/command_line.h"
+#include "base/file_util.h"
+#include "base/files/file_path.h"
+#include "base/logging.h"
+#include "base/process_info.h"
+#include "base/process_util.h"
+#include "base/string_number_conversions.h"
+#include "base/stringprintf.h"
+#include "base/utf_string_conversions.h"
+#include "base/win/metro.h"
+#include "base/win/scoped_handle.h"
+#include "base/win/win_util.h"
+#include "base/win/windows_version.h"
+#include "chrome/browser/metro_utils/metro_chrome_win.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_switches.h"
+
+
+namespace {
+
+const int kTimeoutInSeconds = 20;
+
+// The following is copied from net/base/escape.cc. We don't want to depend on
+// net here because this gets compiled into chrome.exe to facilitate
+// fast-rendezvous (see https://codereview.chromium.org/14617003/).
+
+// TODO(koz): Move these functions out of net/base/escape.cc into base/escape.cc
+// so we can depend on it directly.
+
+// BEGIN COPY from net/base/escape.cc
+
+// A fast bit-vector map for ascii characters.
+//
+// Internally stores 256 bits in an array of 8 ints.
+// Does quick bit-flicking to lookup needed characters.
+struct Charmap {
+  bool Contains(unsigned char c) const {
+    return ((map[c >> 5] & (1 << (c & 31))) != 0);
+  }
+
+  uint32 map[8];
+};
+
+const char kHexString[] = "0123456789ABCDEF";
+inline char IntToHex(int i) {
+  DCHECK_GE(i, 0) << i << " not a hex value";
+  DCHECK_LE(i, 15) << i << " not a hex value";
+  return kHexString[i];
+}
+
+// Given text to escape and a Charmap defining which values to escape,
+// return an escaped string.  If use_plus is true, spaces are converted
+// to +, otherwise, if spaces are in the charmap, they are converted to
+// %20.
+std::string Escape(const std::string& text, const Charmap& charmap,
+                   bool use_plus) {
+  std::string escaped;
+  escaped.reserve(text.length() * 3);
+  for (unsigned int i = 0; i < text.length(); ++i) {
+    unsigned char c = static_cast<unsigned char>(text[i]);
+    if (use_plus && ' ' == c) {
+      escaped.push_back('+');
+    } else if (charmap.Contains(c)) {
+      escaped.push_back('%');
+      escaped.push_back(IntToHex(c >> 4));
+      escaped.push_back(IntToHex(c & 0xf));
+    } else {
+      escaped.push_back(c);
+    }
+  }
+  return escaped;
+}
+
+// Everything except alphanumerics and !'()*-._~
+// See RFC 2396 for the list of reserved characters.
+static const Charmap kQueryCharmap = {{
+  0xffffffffL, 0xfc00987dL, 0x78000001L, 0xb8000001L,
+  0xffffffffL, 0xffffffffL, 0xffffffffL, 0xffffffffL
+}};
+
+std::string EscapeQueryParamValue(const std::string& text, bool use_plus) {
+  return Escape(text, kQueryCharmap, use_plus);
+}
+
+// END COPY from net/base/escape.cc
+
+}
+
+namespace chrome {
+
+HWND FindRunningChromeWindow(const base::FilePath& user_data_dir) {
+  return FindWindowEx(HWND_MESSAGE, NULL, chrome::kMessageWindowClass,
+                      user_data_dir.value().c_str());
+}
+
+NotifyChromeResult AttemptToNotifyRunningChrome(HWND remote_window) {
+  DCHECK(remote_window);
+  static const char kSearchUrl[] =
+      "http://www.google.com/search?q=%s&sourceid=chrome&ie=UTF-8";
+  DWORD process_id = 0;
+  DWORD thread_id = GetWindowThreadProcessId(remote_window, &process_id);
+  if (!thread_id || !process_id)
+    return NOTIFY_FAILED;
+
+  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 = 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);
+    }
+    return NOTIFY_SUCCESS;
+  }
+
+  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();
+  }
+
+  CommandLine command_line(*CommandLine::ForCurrentProcess());
+  command_line.AppendSwitchASCII(
+      switches::kOriginalProcessStartTime,
+      base::Int64ToString(
+          base::CurrentProcessInfo::CreationTime()->ToInternalValue()));
+
+  // Send the command line to the remote chrome 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 (!file_util::GetCurrentDirectory(&cur_dir))
+    return NOTIFY_FAILED;
+  to_send.append(cur_dir.value());
+  to_send.append(L"\0", 1);  // Null separator.
+  to_send.append(command_line.GetCommandLineString());
+  to_send.append(L"\0", 1);  // Null separator.
+
+  // Allow the current running browser window to make 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)) {
+    return result ? NOTIFY_SUCCESS : NOTIFY_FAILED;
+  }
+
+  // It is possible that the process owning this window may have died by now.
+  if (!::IsWindow(remote_window))
+    return NOTIFY_FAILED;
+
+  // If the window couldn't be notified but still exists, assume it is hung.
+  return NOTIFY_WINDOW_HUNG;
+}
+
+}  // namespace chrome

chrome/browser/chrome_process_finder_win.h

+// Copyright 2013 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.
+
+#ifndef CHROME_BROWSER_CHROME_PROCESS_FINDER_WIN_H_
+#define CHROME_BROWSER_CHROME_PROCESS_FINDER_WIN_H_
+
+#include <windows.h>
+
+namespace base {
+class FilePath;
+}
+
+namespace chrome {
+
+enum NotifyChromeResult {
+  NOTIFY_SUCCESS,
+  NOTIFY_FAILED,
+  NOTIFY_WINDOW_HUNG,
+};
+
+// Finds an already running Chrome window if it exists.
+HWND FindRunningChromeWindow(const base::FilePath& user_data_dir);
+
+// Attempts to send the current command line to an already running instance of
+// Chrome via a WM_COPYDATA message.
+// Returns true if a running Chrome is found and successfully notified.
+NotifyChromeResult AttemptToNotifyRunningChrome(HWND remote_window);
+
+}  // namespace chrome
+
+#endif  // CHROME_BROWSER_CHROME_PROCESS_FINDER_WIN_H_

chrome/browser/metro_utils/DEPS

+include_rules = [
+  "+base",
+  "+chrome/installer/util",
+]

chrome/browser/ui/metro_chrome_win.cc → chrome/browser/metro_utils/metro_chrome_win.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/ui/metro_chrome_win.h"
+#include "chrome/browser/metro_utils/metro_chrome_win.h"
 
 #include <windows.h>
 #include <shobjidl.h>

chrome/browser/ui/metro_chrome_win.h → chrome/browser/metro_utils/metro_chrome_win.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_UI_METRO_CHROME_WIN_H_
-#define CHROME_BROWSER_UI_METRO_CHROME_WIN_H_
+#ifndef CHROME_BROWSER_METRO_UTILS_METRO_CHROME_WIN_H_
+#define CHROME_BROWSER_METRO_UTILS_METRO_CHROME_WIN_H_
 
 namespace chrome {
 
@@ -16,4 +16,4 @@ bool ActivateMetroChrome();
 
 }  // namespace chrome
 
-#endif  // CHROME_BROWSER_UI_METRO_CHROME_WIN_H_
+#endif  // CHROME_BROWSER_METRO_UTILS_METRO_CHROME_WIN_H_

chrome/browser/process_singleton_win.cc

@@ -24,8 +24,9 @@
 #include "base/win/wrapped_window_proc.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.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"
@@ -43,9 +44,6 @@ 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
@@ -247,8 +245,7 @@ bool ProcessSingleton::EscapeVirtualization(
     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;
@@ -291,90 +288,20 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
     return PROCESS_NONE;
   }
 
-  DWORD process_id = 0;
-  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);
-    }
-    return PROCESS_NOTIFIED;
-  }
-
-  CommandLine command_line(*CommandLine::ForCurrentProcess());
-  command_line.AppendSwitchASCII(
-      switches::kOriginalProcessStartTime,
-      base::Int64ToString(
-          base::CurrentProcessInfo::CreationTime()->ToInternalValue()));
-
-  // 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(command_line.GetCommandLineString());
-  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) {
+  switch (chrome::AttemptToNotifyRunningChrome(remote_window_)) {
+    case chrome::NOTIFY_SUCCESS:
+      return PROCESS_NOTIFIED;
+    case chrome::NOTIFY_FAILED:
       remote_window_ = NULL;
       return PROCESS_NONE;
-    }
-    return PROCESS_NOTIFIED;
+    case chrome::NOTIFY_WINDOW_HUNG:
+      remote_window_ = NULL;
+      break;
   }
 
-  // It is possible that the process owning this window may have died by now.
-  if (!::IsWindow(remote_window_)) {
+  DWORD process_id = 0;
+  DWORD thread_id = ::GetWindowThreadProcessId(remote_window_, &process_id);
+  if (!thread_id || !process_id) {
     remote_window_ = NULL;
     return PROCESS_NONE;
   }
@@ -386,10 +313,12 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
                       reinterpret_cast<LPARAM>(&visible_window));
 
   // If there is a visible browser window, ask the user before killing it.
-  if (visible_window && chrome::ShowMessageBox(NULL,
-      l10n_util::GetStringUTF16(IDS_PRODUCT_NAME),
-      l10n_util::GetStringUTF16(IDS_BROWSER_HUNGBROWSER_MESSAGE),
-      chrome::MESSAGE_BOX_TYPE_QUESTION) == chrome::MESSAGE_BOX_RESULT_NO) {
+  if (visible_window &&
+      chrome::ShowMessageBox(
+          NULL,
+          l10n_util::GetStringUTF16(IDS_PRODUCT_NAME),
+          l10n_util::GetStringUTF16(IDS_BROWSER_HUNGBROWSER_MESSAGE),
+          chrome::MESSAGE_BOX_TYPE_QUESTION) == chrome::MESSAGE_BOX_RESULT_NO) {
     // The user denied. Quit silently.
     return PROCESS_NOTIFIED;
   }
@@ -400,7 +329,8 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
   return PROCESS_NONE;
 }
 
-ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessOrCreate() {
+ProcessSingleton::NotifyResult
+ProcessSingleton::NotifyOtherProcessOrCreate() {
   ProcessSingleton::NotifyResult result = PROCESS_NONE;
   if (!Create()) {
     result = NotifyOtherProcess();
@@ -421,9 +351,7 @@ bool ProcessSingleton::Create() {
   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
@@ -439,9 +367,7 @@ bool ProcessSingleton::Create() {
     // 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
@@ -490,9 +416,7 @@ bool ProcessSingleton::Create() {
         // 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_);
       }
     }
 

chrome/browser/ui/extensions/app_metro_infobar_delegate_win.cc

@@ -9,13 +9,13 @@
 #include "base/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/metro_utils/metro_chrome_win.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/app_list_service_win.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/host_desktop.h"
-#include "chrome/browser/ui/metro_chrome_win.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"

chrome/chrome.gyp

@@ -169,6 +169,7 @@
         'chrome_renderer.gypi',
         'chrome_tests.gypi',
         'nacl.gypi',
+        'policy.gypi',
         '../apps/apps.gypi',
       ],
       'targets': [
@@ -877,7 +878,7 @@
           ],
         },
       ],
-    },],  # OS=="linux"
+    }],  # OS=="linux"
     ['OS=="win"',
       { 'targets': [
         {
@@ -1049,8 +1050,12 @@
             'tools/safe_browsing/sb_sigutil.cc',
           ],
         },
-      ]},  # 'targets'
-    ],  # OS=="win"
+      ],  # 'targets'
+      'includes': [
+        'chrome_process_finder.gypi',
+        'metro_utils.gypi',
+      ],
+    }],  # OS=="win"
     ['OS=="win" and target_arch=="ia32"',
       { 'targets': [
         {

chrome/chrome_browser.gypi

@@ -1419,10 +1419,6 @@
         'browser/policy/policy_loader_win.h',
         'browser/policy/policy_map.cc',
         'browser/policy/policy_map.h',
-        'browser/policy/policy_path_parser.h',
-        'browser/policy/policy_path_parser_linux.cc',
-        'browser/policy/policy_path_parser_mac.mm',
-        'browser/policy/policy_path_parser_win.cc',
         'browser/policy/policy_schema.cc',
         'browser/policy/policy_schema.h',
         'browser/policy/policy_service.cc',
@@ -2356,6 +2352,7 @@
             'common/extensions/api/api.gyp:api',
             'debugger',
             'installer_util',
+            'policy_path_parser',
             'sync_file_system_proto',
             '../cc/cc.gyp:cc',
             '../components/components.gyp:autofill_browser',
@@ -2966,6 +2963,7 @@
             '<(DEPTH)/third_party/wtl/include',
           ],
           'dependencies': [
+            'chrome_process_finder',
             'installer_util_strings',
             '../google_update/google_update.gyp:google_update',
             '../third_party/iaccessible2/iaccessible2.gyp:iaccessible2',

chrome/chrome_browser_ui.gypi

@@ -1264,8 +1264,6 @@
         'browser/ui/login/login_model.h',
         'browser/ui/login/login_prompt.cc',
         'browser/ui/login/login_prompt.h',
-        'browser/ui/metro_chrome_win.cc',
-        'browser/ui/metro_chrome_win.h',
         'browser/ui/metro_pin_tab_helper_win.cc',
         'browser/ui/metro_pin_tab_helper_win.h',
         'browser/ui/native_focus_tracker.h',
@@ -2847,6 +2845,7 @@
           'dependencies': [
             'installer_util_strings',
             'launcher_support',
+            'metro_utils',
             '../google_update/google_update.gyp:google_update',
             '../third_party/iaccessible2/iaccessible2.gyp:iaccessible2',
             '../third_party/isimpledom/isimpledom.gyp:isimpledom',

chrome/chrome_exe.gypi

@@ -460,6 +460,7 @@
           'dependencies': [
             'chrome_dll',
             'chrome_nacl_win64',
+            'chrome_process_finder',
             'chrome_version_resources',
             'installer_util',
             'image_pre_reader',

chrome/chrome_process_finder.gypi

+# Copyright (c) 2013 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.
+
+{
+  'targets': [
+    {
+      'target_name': 'chrome_process_finder',
+      'type': 'static_library',
+      'include_dirs': [
+        '..',
+      ],
+      'dependencies': [
+        'policy_path_parser',
+        '../base/base.gyp:base',
+        '../chrome/chrome.gyp:metro_utils',
+        '../chrome/common_constants.gyp:common_constants',
+      ],
+      'sources': [
+        'browser/chrome_process_finder_win.cc',
+        'browser/chrome_process_finder_win.h',
+      ],
+    },
+  ],
+}

chrome/metro_utils.gypi

+# Copyright 2013 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.
+
+{
+  'targets': [
+    {
+      'target_name': 'metro_utils',
+      'type': 'static_library',
+      'dependencies': [
+        'installer_util',
+        '../base/base.gyp:base',
+      ],
+      'include_dirs': [
+        '..',
+      ],
+      'sources': [
+        'browser/metro_utils/metro_chrome_win.cc',
+        'browser/metro_utils/metro_chrome_win.h',
+      ],
+    },
+  ],
+}

chrome/policy.gypi

+# Copyright (c) 2013 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.
+
+{
+  'targets': [
+    {
+      'target_name': 'policy_path_parser',
+      'type': 'static_library',
+      'dependencies': [
+        '../base/base.gyp:base',
+        '../chrome/common_constants.gyp:common_constants',
+        '../chrome/app/policy/cloud_policy_codegen.gyp:policy',
+      ],
+      'include_dirs': [
+        '..',
+      ],
+      'sources': [
+        'browser/policy/policy_path_parser.h',
+        'browser/policy/policy_path_parser_linux.cc',
+        'browser/policy/policy_path_parser_mac.mm',
+        'browser/policy/policy_path_parser_win.cc',
+      ],
+    },
+  ],
+}