Prefix CommandLine usage with base namespace (Part 8: components)

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 187 matching lines @@
 }
 #endif
 
 size_t LengthWithoutTrailingSpaces(const char* str, size_t len) {
   while (len > 0 && str[len - 1] == ' ') {
     len--;
   }
   return len;
 }
 
-void SetClientIdFromCommandLine(const CommandLine& command_line) {
+void SetClientIdFromCommandLine(const base::CommandLine& command_line) {
   // Get the guid from the command line switch.
   std::string switch_value =
       command_line.GetSwitchValueASCII(switches::kEnableCrashReporter);
   GetCrashReporterClient()->SetCrashReporterClientIdFromGUID(switch_value);
 }
 
 // MIME substrings.
 #if defined(OS_CHROMEOS)
 const char g_sep[] = ":";
 #endif
@@ skipping 543 matching lines @@
   info.crash_keys = g_crash_keys;
   HandleCrashDump(info);
   return FinalizeCrashDoneAndroid(false /* is_browser_process */);
 }
 
 void EnableNonBrowserCrashDumping(const std::string& process_type,
                                   int minidump_fd) {
   // This will guarantee that the BuildInfo has been initialized and subsequent
   // calls will not require memory allocation.
   base::android::BuildInfo::GetInstance();
-  SetClientIdFromCommandLine(*CommandLine::ForCurrentProcess());
+  SetClientIdFromCommandLine(*base::CommandLine::ForCurrentProcess());
 
   // On Android, the current sandboxing uses process isolation, in which the
   // child process runs with a different UID. That breaks the normal crash
   // reporting where the browser process generates the minidump by inspecting
   // the child process. This is because the browser process now does not have
   // the permission to access the states of the child process (as it has a
   // different UID).
   // TODO(jcivelli): http://b/issue?id=6776356 we should use a watchdog
   // process forked from the renderer process that generates the minidump.
   if (minidump_fd == -1) {
@@ skipping 845 matching lines @@
   // This will guarantee that the BuildInfo has been initialized and subsequent
   // calls will not require memory allocation.
   base::android::BuildInfo::GetInstance();
 
   // Handler registration is LIFO. Install the microdump handler first, such
   // that if conventional minidump crash reporting is enabled below, it takes
   // precedence (i.e. its handler is run first) over the microdump handler.
   InitMicrodumpCrashHandlerIfNecessary(process_type);
 #endif
   // Determine the process type and take appropriate action.
-  const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
+  const base::CommandLine& parsed_command_line =
+      *base::CommandLine::ForCurrentProcess();
   if (parsed_command_line.HasSwitch(switches::kDisableBreakpad))
     return;
 
   if (process_type.empty()) {
     bool enable_breakpad = GetCrashReporterClient()->GetCollectStatsConsent() ||
                            GetCrashReporterClient()->IsRunningUnattended();
     enable_breakpad &=
         !parsed_command_line.HasSwitch(switches::kDisableBreakpad);
     if (!enable_breakpad) {
       enable_breakpad = parsed_command_line.HasSwitch(
@@ skipping 24 matching lines @@
     EnableNonBrowserCrashDumping();
     VLOG(1) << "Non Browser crash dumping enabled for: " << process_type;
 #endif  // #if defined(OS_ANDROID)
   }
 
   PostEnableBreakpadInitialization();
 }
 
 #if defined(OS_ANDROID)
 void InitNonBrowserCrashReporterForAndroid(const std::string& process_type) {
-  const CommandLine* command_line = CommandLine::ForCurrentProcess();
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
 
   // Handler registration is LIFO. Install the microdump handler first, such
   // that if conventional minidump crash reporting is enabled below, it takes
   // precedence (i.e. its handler is run first) over the microdump handler.
   InitMicrodumpCrashHandlerIfNecessary(process_type);
 
   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(
         GetCrashReporterClient()->GetAndroidMinidumpDescriptor());
     if (minidump_fd < 0) {
       NOTREACHED() << "Could not find minidump FD, crash reporting disabled.";
     } else {
       InitCrashKeys();
       EnableNonBrowserCrashDumping(process_type, minidump_fd);
     }
   }
 }
 #endif  // OS_ANDROID
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }
 
 }  // namespace breakpad