Rename BreakpadClient to CrashReporterClient.

components/crash/app/breakpad_linux.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.
 
 // For linux_syscall_support.h. This makes it safe to call embedded system
 // calls when in seccomp mode.
 
 #include "components/crash/app/breakpad_linux.h"
 
 #include <fcntl.h>
@@ skipping 20 matching lines @@
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/global_descriptors.h"
 #include "base/process/memory.h"
 #include "base/strings/string_util.h"
 #include "breakpad/src/client/linux/crash_generation/crash_generation_client.h"
 #include "breakpad/src/client/linux/handler/exception_handler.h"
 #include "breakpad/src/client/linux/minidump_writer/directory_reader.h"
 #include "breakpad/src/common/linux/linux_libc_support.h"
 #include "breakpad/src/common/memory.h"
-#include "components/crash/app/breakpad_client.h"
 #include "components/crash/app/breakpad_linux_impl.h"
+#include "components/crash/app/crash_reporter_client.h"
 #include "content/public/common/content_descriptors.h"
 
 #if defined(OS_ANDROID)
 #include <android/log.h>
 #include <sys/stat.h>
 
 #include "base/android/build_info.h"
 #include "base/android/path_utils.h"
 #endif
 #include "third_party/lss/linux_syscall_support.h"
 
 #if defined(ADDRESS_SANITIZER)
 #include <ucontext.h>  // for getcontext().
 #endif
 
 #if defined(OS_ANDROID)
 #define STAT_STRUCT struct stat
 #define FSTAT_FUNC fstat
 #else
 #define STAT_STRUCT struct kernel_stat
 #define FSTAT_FUNC sys_fstat
 #endif
 
 // Some versions of gcc are prone to warn about unused return values. In cases
 // where we either a) know the call cannot fail, or b) there is nothing we
 // can do when a call fails, we mark the return code as ignored. This avoids
 // spurious compiler warnings.
 #define IGNORE_RET(x) do { if (x); } while (0)
 
+using crash_reporter::GetCrashReporterClient;
 using google_breakpad::ExceptionHandler;
 using google_breakpad::MinidumpDescriptor;
 
 namespace breakpad {
 
 namespace {
 
 #if !defined(OS_CHROMEOS)
 const char kUploadURL[] = "https://clients2.google.com/cr/report";
 #endif
@@ skipping 117 matching lines @@
   while (len > 0 && str[len - 1] == ' ') {
     len--;
   }
   return len;
 }
 
 void SetClientIdFromCommandLine(const CommandLine& command_line) {
   // Get the guid from the command line switch.
   std::string switch_value =
       command_line.GetSwitchValueASCII(switches::kEnableCrashReporter);
-  GetBreakpadClient()->SetBreakpadClientIdFromGUID(switch_value);
+  GetCrashReporterClient()->SetCrashReporterClientIdFromGUID(switch_value);
 }
 
 // MIME substrings.
 #if defined(OS_CHROMEOS)
 const char g_sep[] = ":";
 #endif
 const char g_rn[] = "\r\n";
 const char g_form_data_msg[] = "Content-Disposition: form-data; name=\"";
 const char g_quote_msg[] = "\"";
 const char g_dashdash_msg[] = "--";
@@ skipping 403 matching lines @@
 }
 #endif
 
 void EnableCrashDumping(bool unattended) {
   g_is_crash_reporter_enabled = true;
 
   base::FilePath tmp_path("/tmp");
   PathService::Get(base::DIR_TEMP, &tmp_path);
 
   base::FilePath dumps_path(tmp_path);
-  if (GetBreakpadClient()->GetCrashDumpLocation(&dumps_path)) {
+  if (GetCrashReporterClient()->GetCrashDumpLocation(&dumps_path)) {
     base::FilePath logfile =
-        dumps_path.Append(GetBreakpadClient()->GetReporterLogFilename());
+        dumps_path.Append(GetCrashReporterClient()->GetReporterLogFilename());
     std::string logfile_str = logfile.value();
     const size_t crash_log_path_len = logfile_str.size() + 1;
     g_crash_log_path = new char[crash_log_path_len];
     strncpy(g_crash_log_path, logfile_str.c_str(), crash_log_path_len);
   }
   DCHECK(!g_breakpad);
   MinidumpDescriptor minidump_descriptor(dumps_path.value());
   minidump_descriptor.set_size_limit(kMaxMinidumpFileSize);
 #if defined(OS_ANDROID)
   unattended = true;  // Android never uploads directly.
@@ skipping 214 matching lines @@
 
 void SetCrashKeyValue(const base::StringPiece& key,
                       const base::StringPiece& value) {
   g_crash_keys->SetKeyValue(key.data(), value.data());
 }
 
 void ClearCrashKey(const base::StringPiece& key) {
   g_crash_keys->RemoveKey(key.data());
 }
 
-// GetBreakpadClient() cannot call any Set methods until after InitCrashKeys().
+// GetCrashReporterClient() cannot call any Set methods until after
+// InitCrashKeys().
 void InitCrashKeys() {
   g_crash_keys = new CrashKeyStorage;
-  GetBreakpadClient()->RegisterCrashKeys();
+  GetCrashReporterClient()->RegisterCrashKeys();
   base::debug::SetCrashKeyReportingFunctions(&SetCrashKeyValue, &ClearCrashKey);
 }
 
 // Miscellaneous initialization functions to call after Breakpad has been
 // enabled.
 void PostEnableBreakpadInitialization() {
   SetProcessStartTime();
   g_pid = getpid();
 
   base::debug::SetDumpWithoutCrashingFunction(&DumpProcess);
@@ skipping 418 matching lines @@
 #if defined(OS_CHROMEOS)
   CrashReporterWriter writer(temp_file_fd);
 #else
   MimeWriter writer(temp_file_fd, mime_boundary);
 #endif
   {
     // TODO(thestig) Do not use this inside a compromised context.
     std::string product_name;
     std::string version;
 
-    GetBreakpadClient()->GetProductNameAndVersion(&product_name, &version);
+    GetCrashReporterClient()->GetProductNameAndVersion(&product_name, &version);
 
     writer.AddBoundary();
     writer.AddPairString("prod", product_name.c_str());
     writer.AddBoundary();
     writer.AddPairString("ver", version.c_str());
     writer.AddBoundary();
     if (info.pid > 0) {
       char pid_value_buf[kUint64StringSize];
       uint64_t pid_value_len = my_uint64_len(info.pid);
       my_uint64tos(pid_value_buf, info.pid, pid_value_len);
@@ skipping 222 matching lines @@
   // This will guarantee that the BuildInfo has been initialized and subsequent
   // calls will not require memory allocation.
   base::android::BuildInfo::GetInstance();
 #endif
   // Determine the process type and take appropriate action.
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   if (parsed_command_line.HasSwitch(switches::kDisableBreakpad))
     return;
 
   if (process_type.empty()) {
-    bool enable_breakpad = GetBreakpadClient()->GetCollectStatsConsent() ||
-                           GetBreakpadClient()->IsRunningUnattended();
+    bool enable_breakpad = GetCrashReporterClient()->GetCollectStatsConsent() ||
+                           GetCrashReporterClient()->IsRunningUnattended();
     enable_breakpad &=
         !parsed_command_line.HasSwitch(switches::kDisableBreakpad);
     if (!enable_breakpad) {
       enable_breakpad = parsed_command_line.HasSwitch(
           switches::kEnableCrashReporterForTesting);
     }
     if (!enable_breakpad) {
       VLOG(1) << "Breakpad disabled";
       return;
     }
 
     InitCrashKeys();
-    EnableCrashDumping(GetBreakpadClient()->IsRunningUnattended());
-  } else if (GetBreakpadClient()->EnableBreakpadForProcess(process_type)) {
+    EnableCrashDumping(GetCrashReporterClient()->IsRunningUnattended());
+  } else if (GetCrashReporterClient()->EnableBreakpadForProcess(process_type)) {
 #if defined(OS_ANDROID)
     NOTREACHED() << "Breakpad initialized with InitCrashReporter() instead of "
       "InitNonBrowserCrashReporter in " << process_type << " process.";
     return;
 #else
     // We might be chrooted in a zygote or renderer process so we cannot call
     // GetCollectStatsConsent because that needs access the the user's home
     // dir. Instead, we set a command line flag for these processes.
     // Even though plugins are not chrooted, we share the same code path for
     // simplicity.
@@ skipping 10 matching lines @@
 }
 
 #if defined(OS_ANDROID)
 void InitNonBrowserCrashReporterForAndroid(const std::string& process_type) {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kEnableCrashReporter)) {
     // On Android we need to provide a FD to the file where the minidump is
     // generated as the renderer and browser run with different UIDs
     // (preventing the browser from inspecting the renderer process).
     int minidump_fd = base::GlobalDescriptors::GetInstance()->MaybeGet(
-        GetBreakpadClient()->GetAndroidMinidumpDescriptor());
+        GetCrashReporterClient()->GetAndroidMinidumpDescriptor());
     if (minidump_fd < 0) {
       NOTREACHED() << "Could not find minidump FD, crash reporting disabled.";
     } else {
       EnableNonBrowserCrashDumping(process_type, minidump_fd);
     }
   }
 }
 #endif  // OS_ANDROID
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }
 
 }  // namespace breakpad