Get rid of unnecessary chrome_main_ files now that most of the code has been removed from them. I...

chrome/app/chrome_main.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 "chrome/app/chrome_main.h"
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop.h"
 #include "base/metrics/stats_counters.h"
@@ skipping 28 matching lines @@
 #include "media/base/media.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_switches.h"
 
 #if defined(OS_WIN)
 #include <algorithm>
 #include <atlbase.h>
 #include <malloc.h>
 #include "base/string_util.h"
 #include "base/win/registry.h"
+#include "chrome/browser/policy/policy_path_parser.h"
+#include "policy/policy_constants.h"
 #include "sandbox/src/sandbox.h"
 #include "tools/memory_watcher/memory_watcher.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #include "base/mac/os_crash_dumps.h"
 #include "chrome/app/breakpad_mac.h"
 #include "chrome/browser/mac/relauncher.h"
 #include "chrome/common/chrome_paths_internal.h"
@@ skipping 82 matching lines @@
 // some apps fail to properly escape arguments.
 bool HasDeprecatedArguments(const std::wstring& command_line) {
   const wchar_t kChromeHtml[] = L"chromehtml:";
   std::wstring command_line_lower = command_line;
   // We are only searching for ASCII characters so this is OK.
   StringToLowerASCII(&command_line_lower);
   std::wstring::size_type pos = command_line_lower.find(kChromeHtml);
   return (pos != std::wstring::npos);
 }
 
+// Checks if the registry key exists in the given hive and expands any
+// variables in the string.
+bool LoadUserDataDirPolicyFromRegistry(HKEY hive,
+                                       const std::wstring& key_name,
+                                       FilePath* user_data_dir) {
+  std::wstring value;
+
+  base::win::RegKey hklm_policy_key(hive, policy::kRegistrySubKey, KEY_READ);
+  if (hklm_policy_key.ReadValue(key_name.c_str(), &value) == ERROR_SUCCESS) {
+    *user_data_dir = FilePath(policy::path_parser::ExpandPathVariables(value));
+    return true;
+  }
+  return false;
+}
+
+void CheckUserDataDirPolicy(FilePath* user_data_dir) {
+  DCHECK(user_data_dir);
+  // We are running as Chrome Frame if we were invoked with user-data-dir,
+  // chrome-frame, and automation-channel switches.
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  const bool is_chrome_frame =
+      !user_data_dir->empty() &&
+      command_line->HasSwitch(switches::kChromeFrame) &&
+      command_line->HasSwitch(switches::kAutomationClientChannelID);
+
+  // In the case of Chrome Frame, the last path component of the user-data-dir
+  // provided on the command line must be preserved since it is specific to
+  // CF's host.
+  FilePath cf_host_dir;
+  if (is_chrome_frame)
+    cf_host_dir = user_data_dir->BaseName();
+
+  // Policy from the HKLM hive has precedence over HKCU so if we have one here
+  // we don't have to try to load HKCU.
+  const char* key_name_ascii = (is_chrome_frame ? policy::key::kGCFUserDataDir :
+                                policy::key::kUserDataDir);
+  std::wstring key_name(ASCIIToWide(key_name_ascii));
+  if (LoadUserDataDirPolicyFromRegistry(HKEY_LOCAL_MACHINE, key_name,
+                                        user_data_dir) ||
+      LoadUserDataDirPolicyFromRegistry(HKEY_CURRENT_USER, key_name,
+                                        user_data_dir)) {
+    // A Group Policy value was loaded.  Append the Chrome Frame host directory
+    // if relevant.
+    if (is_chrome_frame)
+      *user_data_dir = user_data_dir->Append(cf_host_dir);
+  }
+}
+
 #endif  // defined(OS_WIN)
 
 #if defined(OS_LINUX)
 static void AdjustLinuxOOMScore(const std::string& process_type) {
   // Browsers and zygotes should still be killable, but killed last.
   const int kZygoteScore = 0;
   // The minimum amount to bump a score by.  This is large enough that
   // even if it's translated into the old values, it will still go up
   // by at least one.
   const int kScoreBump = 100;
@@ skipping 193 matching lines @@
 };
 
 class ChromeMainDelegate : public content::ContentMainDelegate {
  public:
   virtual bool BasicStartupComplete(int* exit_code) OVERRIDE {
 #if defined(OS_CHROMEOS)
     chromeos::BootTimesLoader::Get()->SaveChromeMainStats();
 #endif
 
 #if defined(OS_MACOSX)
-    chrome_main::SetUpBundleOverrides();
+    SetUpBundleOverrides();
     chrome::common::mac::EnableCFBundleBlocker();
 #endif
 
     Profiling::ProcessStarted();
 
     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
     std::string process_type =
         command_line.GetSwitchValueASCII(switches::kProcessType);
 
 #if defined(OS_POSIX)
@@ skipping 130 matching lines @@
     PathService::Override(content::CHILD_PROCESS_EXE,
         chrome::GetVersionedDirectory().
             Append(chrome::kHelperProcessExecutablePath));
 
     InitMacCrashReporter(command_line, process_type);
 #endif
 
     // Notice a user data directory override if any
     FilePath user_data_dir =
         command_line.GetSwitchValuePath(switches::kUserDataDir);
-    chrome_main::CheckUserDataDirPolicy(&user_data_dir);
+#if defined(OS_MACOSX) || defined(OS_WIN)
+    CheckUserDataDirPolicy(&user_data_dir);
+#endif
     if (!user_data_dir.empty())
       CHECK(PathService::Override(chrome::DIR_USER_DATA, user_data_dir));
 
     base::ProcessId browser_pid = base::GetCurrentProcId();
     if (!process_type.empty() &&
 #if defined(OS_MACOSX)
         process_type != switches::kRelauncherProcess &&
 #endif
         process_type != switches::kServiceProcess) {
 #if defined(OS_WIN) || defined(OS_MACOSX)
@@ skipping 223 matching lines @@
 DLLEXPORT int __cdecl ChromeMain(HINSTANCE instance,
                                  sandbox::SandboxInterfaceInfo* sandbox_info) {
   ChromeMainDelegate chrome_main_delegate;
   return content::ContentMain(instance, sandbox_info, &chrome_main_delegate);
 #elif defined(OS_POSIX)
 int ChromeMain(int argc, char** argv) {
   ChromeMainDelegate chrome_main_delegate;
   return content::ContentMain(argc, argv, &chrome_main_delegate);
 #endif
 }