Rename BreakpadClient to CrashReporterClient.

components/crash/app/breakpad_mac.mm

 // 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.
 
 #import "components/crash/app/breakpad_mac.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 #import <Foundation/Foundation.h>
 
 #include "base/auto_reset.h"
 #include "base/base_switches.h"
 #import "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #import "base/logging.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #import "base/mac/scoped_nsautorelease_pool.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_restrictions.h"
 #import "breakpad/src/client/mac/Framework/Breakpad.h"
-#include "components/crash/app/breakpad_client.h"
+#include "components/crash/app/crash_reporter_client.h"
+
+using crash_reporter::GetCrashReporterClient;
 
 namespace breakpad {
 
 namespace {
 
 BreakpadRef gBreakpadRef = NULL;
 
 void SetCrashKeyValue(NSString* key, NSString* value) {
   // Comment repeated from header to prevent confusion:
   // IMPORTANT: On OS X, the key/value pairs are sent to the crash server
@@ skipping 121 matching lines @@
   // the browser process, so the browser passes the decision to them on the
   // command line.
   NSBundle* main_bundle = base::mac::FrameworkBundle();
   bool is_browser = !base::mac::IsBackgroundOnlyProcess();
   bool enable_breakpad = false;
   CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   if (is_browser) {
     // Since the configuration management infrastructure is possibly not
     // initialized when this code runs, read the policy preference directly.
-    if (!GetBreakpadClient()->ReportingIsEnforcedByPolicy(&enable_breakpad)) {
+    if (!GetCrashReporterClient()->ReportingIsEnforcedByPolicy(
+            &enable_breakpad)) {
       // Controlled by the user. The crash reporter may be enabled by
       // preference or through an environment variable, but the kDisableBreakpad
       // switch overrides both.
-      enable_breakpad = GetBreakpadClient()->GetCollectStatsConsent() ||
-                        GetBreakpadClient()->IsRunningUnattended();
+      enable_breakpad = GetCrashReporterClient()->GetCollectStatsConsent() ||
+                        GetCrashReporterClient()->IsRunningUnattended();
       enable_breakpad &= !command_line->HasSwitch(switches::kDisableBreakpad);
     }
   } else {
     // This is a helper process, check the command line switch.
     enable_breakpad = command_line->HasSwitch(switches::kEnableCrashReporter);
   }
 
   if (!enable_breakpad) {
     VLOG_IF(1, is_browser) << "Breakpad disabled";
     return;
@@ skipping 22 matching lines @@
                       forKey:@BREAKPAD_REPORTER_EXE_LOCATION];
 
   // In the main application (the browser process), crashes can be passed to
   // the system's Crash Reporter.  This allows the system to notify the user
   // when the application crashes, and provide the user with the option to
   // restart it.
   if (is_browser)
     [breakpad_config setObject:@"NO" forKey:@BREAKPAD_SEND_AND_EXIT];
 
   base::FilePath dir_crash_dumps;
-  GetBreakpadClient()->GetCrashDumpLocation(&dir_crash_dumps);
+  GetCrashReporterClient()->GetCrashDumpLocation(&dir_crash_dumps);
   [breakpad_config setObject:base::SysUTF8ToNSString(dir_crash_dumps.value())
                       forKey:@BREAKPAD_DUMP_DIRECTORY];
 
   // Temporarily run Breakpad in-process on 10.10 and later because APIs that
   // it depends on got broken (http://crbug.com/386208).
   // This can catch crashes in the browser process only.
   if (is_browser && base::mac::IsOSYosemiteOrLater()) {
     [breakpad_config setObject:[NSNumber numberWithBool:YES]
                         forKey:@BREAKPAD_IN_PROCESS];
   }
 
   // Initialize Breakpad.
   gBreakpadRef = BreakpadCreate(breakpad_config);
   if (!gBreakpadRef) {
     LOG_IF(ERROR, base::mac::AmIBundled()) << "Breakpad initializaiton failed";
     return;
   }
 
   // Initialize the scoped crash key system.
   base::debug::SetCrashKeyReportingFunctions(&SetCrashKeyValueImpl,
                                              &ClearCrashKeyValueImpl);
-  GetBreakpadClient()->RegisterCrashKeys();
+  GetCrashReporterClient()->RegisterCrashKeys();
 
   // Set Breakpad metadata values.  These values are added to Info.plist during
   // the branded Google Chrome.app build.
   SetCrashKeyValue(@"ver", [info_dictionary objectForKey:@BREAKPAD_VERSION]);
   SetCrashKeyValue(@"prod", [info_dictionary objectForKey:@BREAKPAD_PRODUCT]);
   SetCrashKeyValue(@"plat", @"OS X");
 
   if (!is_browser) {
     // Get the guid from the command line switch.
     std::string client_guid =
         command_line->GetSwitchValueASCII(switches::kEnableCrashReporter);
-    GetBreakpadClient()->SetBreakpadClientIdFromGUID(client_guid);
+    GetCrashReporterClient()->SetCrashReporterClientIdFromGUID(client_guid);
   }
 
   logging::SetLogMessageHandler(&FatalMessageHandler);
   base::debug::SetDumpWithoutCrashingFunction(&DumpHelper::DumpWithoutCrashing);
 
   // abort() sends SIGABRT, which breakpad does not intercept.
   // Register a signal handler to crash in a way breakpad will
   // intercept.
   struct sigaction sigact;
   memset(&sigact, 0, sizeof(sigact));
   sigact.sa_handler = SIGABRTHandler;
   CHECK(0 == sigaction(SIGABRT, &sigact, NULL));
 }
 
 void InitCrashProcessInfo(const std::string& process_type_switch) {
   if (gBreakpadRef == NULL) {
     return;
   }
 
   // Determine the process type.
   NSString* process_type = @"browser";
   if (!process_type_switch.empty()) {
     process_type = base::SysUTF8ToNSString(process_type_switch);
   }
 
-  GetBreakpadClient()->InstallAdditionalFilters(gBreakpadRef);
+  GetCrashReporterClient()->InstallAdditionalFilters(gBreakpadRef);
 
   // Store process type in crash dump.
   SetCrashKeyValue(@"ptype", process_type);
 
   NSString* pid_value =
       [NSString stringWithFormat:@"%d", static_cast<unsigned int>(getpid())];
   SetCrashKeyValue(@"pid", pid_value);
 }
 
 }  // namespace breakpad