Stability instrumentation Crashpad integration

chrome/install_static/install_util.cc

 // Copyright 2014 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/install_static/install_util.h"
 
 #include <windows.h>
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 11 matching lines @@
 #include "chrome_elf/nt_registry/nt_registry.h"
 #include "components/version_info/channel.h"
 
 namespace install_static {
 
 enum class ProcessType {
   UNINITIALIZED,
   OTHER_PROCESS,
   BROWSER_PROCESS,
   CLOUD_PRINT_SERVICE_PROCESS,
+  CRASHPAD_HANDLER_PROCESS,
 #if !defined(DISABLE_NACL)
   NACL_BROKER_PROCESS,
   NACL_LOADER_PROCESS,
 #endif
 };
 
 // Caches the |ProcessType| of the current process.
 ProcessType g_process_type = ProcessType::UNINITIALIZED;
 
 const wchar_t kRegValueChromeStatsSample[] = L"UsageStatsInSample";
@@ skipping 28 matching lines @@
 // TODO(ananta)
 // http://crbug.com/604923
 // These constants are defined in the chrome/installer directory as well. We
 // need to unify them.
 constexpr wchar_t kRegValueAp[] = L"ap";
 constexpr wchar_t kRegValueName[] = L"name";
 constexpr wchar_t kRegValueUsageStats[] = L"usagestats";
 constexpr wchar_t kMetricsReportingEnabled[] = L"MetricsReportingEnabled";
 
 constexpr wchar_t kCloudPrintServiceProcess[] = L"cloud-print-service";
+constexpr wchar_t kCrashpadHandlerProcess[] = L"crashpad-handler";
 #if !defined(DISABLE_NACL)
 constexpr wchar_t kNaClBrokerProcess[] = L"nacl-broker";
 constexpr wchar_t kNaClLoaderProcess[] = L"nacl-loader";
 #endif
 
 void Trace(const wchar_t* format_string, ...) {
   static const int kMaxLogBufferSize = 1024;
   static wchar_t buffer[kMaxLogBufferSize] = {};
 
   va_list args = {};
@@ skipping 209 matching lines @@
   }
   if (MatchPattern(value, kChromeChannelBetaPattern) ||
       MatchPattern(value, kChromeChannelBetaX64Pattern)) {
     return kChromeChannelBeta;
   }
   // Else report values with garbage as stable since they will match the stable
   // rules in the update configs.
   return std::wstring();
 }
 
+void EnsureProcessTypeIsInitialized() {
+  if (g_process_type == ProcessType::UNINITIALIZED) {
+    InitializeProcessType();
+    assert(g_process_type != ProcessType::UNINITIALIZED);
+  }
+}
+
 // Converts a process type specified as a string to the ProcessType enum.
 ProcessType GetProcessType(const std::wstring& process_type) {
   if (process_type.empty())
     return ProcessType::BROWSER_PROCESS;
   if (process_type == kCloudPrintServiceProcess)
     return ProcessType::CLOUD_PRINT_SERVICE_PROCESS;
+  if (process_type == kCrashpadHandlerProcess)
+    return ProcessType::CRASHPAD_HANDLER_PROCESS;
 #if !defined(DISABLE_NACL)
   if (process_type == kNaClBrokerProcess)
     return ProcessType::NACL_BROKER_PROCESS;
   if (process_type == kNaClLoaderProcess)
     return ProcessType::NACL_LOADER_PROCESS;
 #endif
   return ProcessType::OTHER_PROCESS;
 }
 
 // Returns whether |process_type| needs the profile directory.
 bool ProcessNeedsProfileDir(ProcessType process_type) {
   // On Windows we don't want subprocesses other than the browser process and
   // service processes to be able to use the profile directory because if it
   // lies on a network share the sandbox will prevent us from accessing it.
   switch (process_type) {
     case ProcessType::BROWSER_PROCESS:
     case ProcessType::CLOUD_PRINT_SERVICE_PROCESS:
+    case ProcessType::CRASHPAD_HANDLER_PROCESS:
 #if !defined(DISABLE_NACL)
     case ProcessType::NACL_BROKER_PROCESS:
     case ProcessType::NACL_LOADER_PROCESS:
 #endif
       return true;
     case ProcessType::OTHER_PROCESS:
       return false;
     case ProcessType::UNINITIALIZED:
       assert(false);
       return false;
@@ skipping 166 matching lines @@
   return false;
 }
 
 void InitializeProcessType() {
   assert(g_process_type == ProcessType::UNINITIALIZED);
   std::wstring process_type =
       GetSwitchValueFromCommandLine(::GetCommandLine(), kProcessType);
   g_process_type = GetProcessType(process_type);
 }
 
-bool IsProcessTypeInitialized() {
-  return g_process_type != ProcessType::UNINITIALIZED;
-}
-
 bool IsNonBrowserProcess() {
-  assert(g_process_type != ProcessType::UNINITIALIZED);
+  EnsureProcessTypeIsInitialized();
   return g_process_type != ProcessType::BROWSER_PROCESS;
 }
 
 bool ProcessNeedsProfileDir(const std::string& process_type) {
   return ProcessNeedsProfileDir(GetProcessType(UTF8ToUTF16(process_type)));
 }
 
+bool CurrentProcessNeedsProfileDir() {
+  EnsureProcessTypeIsInitialized();
+  return ProcessNeedsProfileDir(g_process_type);
+}
+
+std::wstring GetUserDataDirectory() {
+  return install_static::InstallDetails::Get().user_data_dir();
+}
+
+std::wstring GetInvalidUserDataDirectory() {
+  return install_static::InstallDetails::Get().invalid_user_data_dir();
+}
+
 std::wstring GetCrashDumpLocation() {
   // In order to be able to start crash handling very early and in chrome_elf,
   // we cannot rely on chrome's PathService entries (for DIR_CRASH_DUMPS) being
   // available on Windows. See https://crbug.com/564398.
-  std::wstring user_data_dir;
-  bool ret = GetUserDataDirectory(&user_data_dir, nullptr);
-  assert(ret);
-  IgnoreUnused(ret);
+  std::wstring user_data_dir = GetUserDataDirectory();
+  if (user_data_dir.empty())
+    return user_data_dir;
   return user_data_dir.append(L"\\Crashpad");
 }
 
 std::string GetEnvironmentString(const std::string& variable_name) {
   return UTF16ToUTF8(
       GetEnvironmentString16(UTF8ToUTF16(variable_name).c_str()));
 }
 
 std::wstring GetEnvironmentString16(const wchar_t* variable_name) {
   DWORD value_length = ::GetEnvironmentVariableW(variable_name, nullptr, 0);
@@ skipping 338 matching lines @@
     case ChannelStrategy::ADDITIONAL_PARAMETERS:
       return ChannelFromAdditionalParameters(mode, ap_value);
     case ChannelStrategy::FIXED:
       return mode.default_channel_name;
   }
 
   return std::wstring();
 }
 
 }  // namespace install_static