Make Crashpad use the user data dir, rather than always default location

chrome/app/chrome_main_delegate.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/app/chrome_main_delegate.h"
 
 #include <stddef.h>
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/cpu.h"
 #include "base/files/file_path.h"
 #include "base/i18n/rtl.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/path_service.h"
 #include "base/process/memory.h"
 #include "base/process/process_handle.h"
 #include "base/process/process_info.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event_impl.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/defaults.h"
+#include "chrome/browser/ui/startup/bad_flags_prompt.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_content_client.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_result_codes.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/crash_keys.h"
 #include "chrome/common/features.h"
 #include "chrome/common/logging_chrome.h"
@@ skipping 312 matching lines @@
 }
 #endif  // !defined(OS_MACOSX) && !defined(OS_ANDROID)
 
 #endif  // OS_POSIX
 
 struct MainFunction {
   const char* name;
   int (*function)(const content::MainFunctionParams&);
 };
 
+#if !defined(OS_ANDROID)
+void InitLogging(const std::string& process_type) {
+  logging::OldFileDeletionState file_state =
+      logging::APPEND_TO_OLD_LOG_FILE;
+  if (process_type.empty()) {
+    file_state = logging::DELETE_OLD_LOG_FILE;
+  }
+  const base::CommandLine& command_line =
+      *base::CommandLine::ForCurrentProcess();
+  logging::InitChromeLogging(command_line, file_state);
+}
+#endif
+
+#if !defined(CHROME_MULTIPLE_DLL_CHILD)
+void RecordMainStartupMetrics(base::TimeTicks exe_entry_point_ticks) {
+  if (!exe_entry_point_ticks.is_null())
+    startup_metric_utils::RecordExeMainEntryPointTicks(exe_entry_point_ticks);
+#if defined(OS_MACOSX) || defined(OS_WIN) || defined(OS_LINUX)
+  // Record the startup process creation time on supported platforms.
+  startup_metric_utils::RecordStartupProcessCreationTime(
+      base::CurrentProcessInfo::CreationTime());
+#endif
+
+// On Android the main entry point time is the time when the Java code starts.
+// This happens before the shared library containing this code is even loaded.
+// The Java startup code has recorded that time, but the C++ code can't fetch it
+// from the Java side until it has initialized the JNI. See
+// ChromeMainDelegateAndroid.
+#if !defined(OS_ANDROID)
+  startup_metric_utils::RecordMainEntryPointTime(base::Time::Now());
+#endif
+}
+#endif  // !defined(CHROME_MULTIPLE_DLL_CHILD)
+
+}  // namespace
+
 // Initializes the user data dir. Must be called before InitializeLocalState().
-void InitializeUserDataDir() {
-  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+// WARNING! It is important that this code match behavior with
+// GetUserDataDirectory() in chrome_elf. The two functions must be updated in
+// sync.
+void InitializeUserDataDir(base::CommandLine* command_line) {
   base::FilePath user_data_dir =
       command_line->GetSwitchValuePath(switches::kUserDataDir);
   std::string process_type =
       command_line->GetSwitchValueASCII(switches::kProcessType);
-
 #if defined(OS_LINUX)
   // On Linux, Chrome does not support running multiple copies under different
   // DISPLAYs, so the profile directory can be specified in the environment to
   // support the virtual desktop use-case.
   if (user_data_dir.empty()) {
     std::string user_data_dir_string;
     std::unique_ptr<base::Environment> environment(base::Environment::Create());
     if (environment->GetVar("CHROME_USER_DATA_DIR", &user_data_dir_string) &&
         base::IsStringUTF8(user_data_dir_string)) {
       user_data_dir = base::FilePath::FromUTF8Unsafe(user_data_dir_string);
@@ skipping 11 matching lines @@
 
   const bool specified_directory_was_invalid = !user_data_dir.empty() &&
       !PathService::OverrideAndCreateIfNeeded(chrome::DIR_USER_DATA,
           user_data_dir, false, true);
   // Save inaccessible or invalid paths so the user may be prompted later.
   if (specified_directory_was_invalid)
     chrome::SetInvalidSpecifiedUserDataDir(user_data_dir);
 
   // Warn and fail early if the process fails to get a user data directory.
   if (!PathService::Get(chrome::DIR_USER_DATA, &user_data_dir)) {
-    // If an invalid command-line or policy override was specified, the user
-    // will be given an error with that value. Otherwise, use the directory
-    // returned by PathService (or the fallback default directory) in the error.
-    if (!specified_directory_was_invalid) {
-      // PathService::Get() returns false and yields an empty path if it fails
-      // to create DIR_USER_DATA. Retrieve the default value manually to display
-      // a more meaningful error to the user in that case.
-      if (user_data_dir.empty())
-        chrome::GetDefaultUserDataDirectory(&user_data_dir);
-      chrome::SetInvalidSpecifiedUserDataDir(user_data_dir);
-    }
-
-    // The browser process (which is identified by an empty |process_type|) will
-    // handle the error later; other processes that need the dir crash here.
-    CHECK(process_type.empty()) << "Unable to get the user data directory "
-                                << "for process type: " << process_type;
+    chrome::MaybeShowInvalidUserDataDirWarningDialog();
+    LOG(FATAL) << "Unable to get the user data directory "
+               << "for process type: " << process_type;
   }
 
   // Append the fallback user data directory to the commandline. Otherwise,
   // child or service processes will attempt to use the invalid directory.
   if (specified_directory_was_invalid)
     command_line->AppendSwitchPath(switches::kUserDataDir, user_data_dir);
 }
 
-#if !defined(OS_ANDROID)
-void InitLogging(const std::string& process_type) {
-  logging::OldFileDeletionState file_state =
-      logging::APPEND_TO_OLD_LOG_FILE;
-  if (process_type.empty()) {
-    file_state = logging::DELETE_OLD_LOG_FILE;
-  }
-  const base::CommandLine& command_line =
-      *base::CommandLine::ForCurrentProcess();
-  logging::InitChromeLogging(command_line, file_state);
-}
-#endif
-
-#if !defined(CHROME_MULTIPLE_DLL_CHILD)
-void RecordMainStartupMetrics(base::TimeTicks exe_entry_point_ticks) {
-  if (!exe_entry_point_ticks.is_null())
-    startup_metric_utils::RecordExeMainEntryPointTicks(exe_entry_point_ticks);
-#if defined(OS_MACOSX) || defined(OS_WIN) || defined(OS_LINUX)
-  // Record the startup process creation time on supported platforms.
-  startup_metric_utils::RecordStartupProcessCreationTime(
-      base::CurrentProcessInfo::CreationTime());
-#endif
-
-// On Android the main entry point time is the time when the Java code starts.
-// This happens before the shared library containing this code is even loaded.
-// The Java startup code has recorded that time, but the C++ code can't fetch it
-// from the Java side until it has initialized the JNI. See
-// ChromeMainDelegateAndroid.
-#if !defined(OS_ANDROID)
-  startup_metric_utils::RecordMainEntryPointTime(base::Time::Now());
-#endif
-}
-#endif  // !defined(CHROME_MULTIPLE_DLL_CHILD)
-
-}  // namespace
 
 ChromeMainDelegate::ChromeMainDelegate()
     : ChromeMainDelegate(base::TimeTicks()) {}
 
 ChromeMainDelegate::ChromeMainDelegate(base::TimeTicks exe_entry_point_ticks) {
 #if !defined(CHROME_MULTIPLE_DLL_CHILD)
   // Record startup metrics in the browser process. For component builds, there
   // is no way to know the type of process (process command line is not yet
   // initialized), so the function below will also be called in renderers.
   // This doesn't matter as it simply sets global variables.
@@ skipping 272 matching lines @@
   child_process_logging::Init();
 #endif
 #if defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) || defined(OS_LINUX))
   // Create an instance of the CPU class to parse /proc/cpuinfo and cache
   // cpu_brand info.
   base::CPU cpu_info;
 #endif
 
   // Initialize the user data dir for any process type that needs it.
   if (chrome::ProcessNeedsProfileDir(process_type)) {
-    InitializeUserDataDir();
+    InitializeUserDataDir(base::CommandLine::ForCurrentProcess());
 #if defined(OS_WIN) && !defined(CHROME_MULTIPLE_DLL_CHILD)
     if (downgrade::IsMSIInstall()) {
       downgrade::MoveUserDataForFirstRunAfterDowngrade();
       base::FilePath user_data_dir;
       if (PathService::Get(chrome::DIR_USER_DATA, &user_data_dir))
         downgrade::UpdateLastVersion(user_data_dir);
     }
 #endif
   }
 
@@ skipping 292 matching lines @@
     case version_info::Channel::CANARY:
       return true;
     case version_info::Channel::DEV:
     case version_info::Channel::BETA:
     case version_info::Channel::STABLE:
     default:
       // Don't enable instrumentation.
       return false;
   }
 }