Add base:: qualification to some CommandLine references in content.

content/common/sandbox_win.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 "content/common/sandbox_win.h"
 
 #include <string>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
@@ skipping 225 matching lines @@
         sizeof(session_id), &session_id_length));
     CloseHandle(token);
     if (session_id)
       s_session_id = session_id;
   }
 
   return base::StringPrintf(L"\\Sessions\\%d%ls", s_session_id, object);
 }
 
 // Checks if the sandbox should be let to run without a job object assigned.
-bool ShouldSetJobLevel(const CommandLine& cmd_line) {
+bool ShouldSetJobLevel(const base::CommandLine& cmd_line) {
   if (!cmd_line.HasSwitch(switches::kAllowNoSandboxJob))
     return true;
 
   // Windows 8 allows nested jobs so we don't need to check if we are in other
   // job.
   if (base::win::GetVersion() >= base::win::VERSION_WIN8)
     return true;
 
   BOOL in_job = true;
   // Either there is no job yet associated so we must add our job,
@@ skipping 115 matching lines @@
   if (sandbox::SBOX_ALL_OK !=  policy->SetAlternateDesktop(true)) {
     DLOG(WARNING) << "Failed to apply desktop security to the renderer";
   }
 
   return true;
 }
 
 // Updates the command line arguments with debug-related flags. If debug flags
 // have been used with this process, they will be filtered and added to
 // command_line as needed.
-void ProcessDebugFlags(CommandLine* command_line) {
-  const CommandLine& current_cmd_line = *CommandLine::ForCurrentProcess();
+void ProcessDebugFlags(base::CommandLine* command_line) {
+  const base::CommandLine& current_cmd_line =
+      *base::CommandLine::ForCurrentProcess();
   std::string type = command_line->GetSwitchValueASCII(switches::kProcessType);
   if (current_cmd_line.HasSwitch(switches::kWaitForDebuggerChildren)) {
     // Look to pass-on the kWaitForDebugger flag.
     std::string value = current_cmd_line.GetSwitchValueASCII(
         switches::kWaitForDebuggerChildren);
     if (value.empty() || value == type) {
       command_line->AppendSwitch(switches::kWaitForDebugger);
     }
     command_line->AppendSwitchASCII(switches::kWaitForDebuggerChildren, value);
   }
@@ skipping 99 matching lines @@
     // Callers use CHECK macro to make sure we get the right stack.
     CheckDuplicateHandle(handle);
   }
 
   return TRUE;
 }
 #endif
 
 }  // namespace
 
-void SetJobLevel(const CommandLine& cmd_line,
+void SetJobLevel(const base::CommandLine& cmd_line,
                  sandbox::JobLevel job_level,
                  uint32 ui_exceptions,
                  sandbox::TargetPolicy* policy) {
   if (ShouldSetJobLevel(cmd_line)) {
 #ifdef _WIN64
     policy->SetJobMemoryLimit(4ULL * 1024 * 1024 * 1024);
 #endif
     policy->SetJobLevel(job_level, ui_exceptions);
   } else {
     policy->SetJobLevel(sandbox::JOB_NONE, 0);
@@ skipping 65 matching lines @@
 
   base::win::OSInfo::VersionNumber os_version =
       base::win::OSInfo::GetInstance()->version_number();
   if ((os_version.major == 6) && (os_version.minor == 1)) {
     // We can't use DirectWrite for pre-release versions of Windows 7.
     if (os_version.build < 7600)
       return false;
   }
 
   // If forced off, don't use it.
-  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  const base::CommandLine& command_line =
+      *base::CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kDisableDirectWrite))
     return false;
 
 #if !defined(NACL_WIN64)
   // Can't use GDI on HiDPI.
   if (gfx::GetDPIScale() > 1.0f)
     return true;
 #endif
 
   // Otherwise, check the field trial.
   const std::string group_name =
       base::FieldTrialList::FindFullName("DirectWrite");
   return group_name != "Disabled";
 }
 
 base::ProcessHandle StartSandboxedProcess(
     SandboxedProcessLauncherDelegate* delegate,
-    CommandLine* cmd_line) {
-  const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
+    base::CommandLine* cmd_line) {
+  const base::CommandLine& browser_command_line =
+      *base::CommandLine::ForCurrentProcess();
   std::string type_str = cmd_line->GetSwitchValueASCII(switches::kProcessType);
 
   TRACE_EVENT_BEGIN_ETW("StartProcessWithAccess", 0, type_str);
 
   // Propagate the --allow-no-job flag if present.
   if (browser_command_line.HasSwitch(switches::kAllowNoSandboxJob) &&
       !cmd_line->HasSwitch(switches::kAllowNoSandboxJob)) {
     cmd_line->AppendSwitch(switches::kAllowNoSandboxJob);
   }
 
@@ skipping 162 matching lines @@
   }
 
   return false;
 }
 
 bool BrokerAddTargetPeer(HANDLE peer_process) {
   return g_broker_services->AddTargetPeer(peer_process) == sandbox::SBOX_ALL_OK;
 }
 
 }  // namespace content