Moved a bunch of win-specific files to the new win folder in chrome/browser

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 <windows.h>
 #include <shellapi.h>
 #include <stddef.h>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/process/process.h"
 #include "base/process/process_info.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.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/shell_integration.h"
 #include "chrome/browser/ui/simple_message_box.h"
+#include "chrome/browser/win/chrome_process_finder.h"
 #include "chrome/common/channel_info.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/grit/chromium_strings.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/wmi.h"
 #include "components/version_info/version_info.h"
@@ skipping 225 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 = chrome::FindRunningChromeWindow(user_data_dir);
+      hwnd = chrome::win::FindRunningChromeWindow(user_data_dir);
       if (hwnd) {
         ::SetForegroundWindow(hwnd);
         break;
       }
       ::Sleep(10);
     }
     return true;
   }
   return false;
 }
@@ skipping 17 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;
   }
 
-  switch (chrome::AttemptToNotifyRunningChrome(remote_window_, false)) {
-    case chrome::NOTIFY_SUCCESS:
+  switch (chrome::win::AttemptToNotifyRunningChrome(remote_window_, false)) {
+    case chrome::win::NOTIFY_SUCCESS:
       return PROCESS_NOTIFIED;
-    case chrome::NOTIFY_FAILED:
+    case chrome::win::NOTIFY_FAILED:
       remote_window_ = NULL;
       return PROCESS_NONE;
-    case chrome::NOTIFY_WINDOW_HUNG:
+    case chrome::win::NOTIFY_WINDOW_HUNG:
       // Fall through and potentially terminate the hung browser.
       break;
   }
 
   // The window is hung.
   DWORD process_id = 0;
   DWORD thread_id = ::GetWindowThreadProcessId(remote_window_, &process_id);
   if (!thread_id || !process_id) {
     remote_window_ = NULL;
     return PROCESS_NONE;
@@ skipping 42 matching lines @@
   }
   return result;
 }
 
 // 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!";
 
-  remote_window_ = chrome::FindRunningChromeWindow(user_data_dir_);
+  remote_window_ = chrome::win::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));
     if (!only_me.IsValid()) {
       DPLOG(FATAL) << "CreateMutex failed";
       return false;
     }
 
     AutoLockMutex auto_lock_only_me(only_me.Get());
 
     // 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_ = chrome::FindRunningChromeWindow(user_data_dir_);
+    remote_window_ = chrome::win::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,
                                 NULL,
                                 CREATE_ALWAYS,
@@ skipping 20 matching lines @@
   return window_.hwnd() != NULL;
 }
 
 void ProcessSingleton::Cleanup() {
 }
 
 void ProcessSingleton::OverrideShouldKillRemoteProcessCallbackForTesting(
     const ShouldKillRemoteProcessCallback& display_dialog_callback) {
   should_kill_remote_process_callback_ = display_dialog_callback;
 }