Make callers of CommandLine use it via the base:: namespace.

chrome/browser/process_singleton_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 "chrome/browser/process_singleton.h"
 
 #include <shellapi.h>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
@@ skipping 73 matching lines @@
 // Checks the visibility of the enumerated window and signals once a visible
 // window has been found.
 BOOL CALLBACK BrowserWindowEnumeration(HWND window, LPARAM param) {
   bool* result = reinterpret_cast<bool*>(param);
   *result = ::IsWindowVisible(window) != 0;
   // Stops enumeration if a visible window has been found.
   return !*result;
 }
 
 bool ParseCommandLine(const COPYDATASTRUCT* cds,
-                      CommandLine* parsed_command_line,
+                      base::CommandLine* parsed_command_line,
                       base::FilePath* current_directory) {
   // We should have enough room for the shortest command (min_message_size)
   // and also be a multiple of wchar_t bytes. The shortest command
   // possible is L"START\0\0" (empty current directory and command line).
   static const int min_message_size = 7;
   if (cds->cbData < min_message_size * sizeof(wchar_t) ||
       cds->cbData % sizeof(wchar_t) != 0) {
     LOG(WARNING) << "Invalid WM_COPYDATA, length = " << cds->cbData;
     return false;
   }
@@ skipping 32 matching lines @@
         msg.find_first_of(L'\0', second_null + 1);
     if (third_null == std::wstring::npos ||
         third_null == msg.length()) {
       LOG(WARNING) << "Invalid format for start command, we need a string in 4 "
         "parts separated by NULLs";
     }
 
     // Get command line.
     const std::wstring cmd_line =
         msg.substr(second_null + 1, third_null - second_null);
-    *parsed_command_line = CommandLine::FromString(cmd_line);
+    *parsed_command_line = base::CommandLine::FromString(cmd_line);
     return true;
   }
   return false;
 }
 
 bool ProcessLaunchNotification(
     const ProcessSingleton::NotificationCallback& notification_callback,
     UINT message,
     WPARAM wparam,
     LPARAM lparam,
     LRESULT* result) {
   if (message != WM_COPYDATA)
     return false;
 
   // Handle the WM_COPYDATA message from another process.
   const COPYDATASTRUCT* cds = reinterpret_cast<COPYDATASTRUCT*>(lparam);
 
-  CommandLine parsed_command_line(CommandLine::NO_PROGRAM);
+  base::CommandLine parsed_command_line(base::CommandLine::NO_PROGRAM);
   base::FilePath current_directory;
   if (!ParseCommandLine(cds, &parsed_command_line, &current_directory)) {
     *result = TRUE;
     return true;
   }
 
   *result = notification_callback.Run(parsed_command_line, current_directory) ?
       TRUE : FALSE;
   return true;
 }
@@ skipping 150 matching lines @@
 
 ProcessSingleton::NotifyResult
 ProcessSingleton::NotifyOtherProcessOrCreate() {
   ProcessSingleton::NotifyResult result = PROCESS_NONE;
   if (!Create()) {
     result = NotifyOtherProcess();
     if (result == PROCESS_NONE)
       result = PROFILE_IN_USE;
   } else {
     g_browser_process->platform_part()->PlatformSpecificCommandLineProcessing(
-        *CommandLine::ForCurrentProcess());
+        *base::CommandLine::ForCurrentProcess());
   }
   return result;
 }
 
 // Look for a Chrome instance that uses the same profile directory. If there
 // isn't one, create a message window with its title set to the profile
 // directory path.
 bool ProcessSingleton::Create() {
   static const wchar_t kMutexName[] = L"Local\\ChromeProcessSingletonStartup!";
   static const wchar_t kMetroActivationEventName[] =
@@ skipping 107 matching lines @@
           ::SetEvent(metro_activation_event.Get());
       }
     }
   }
 
   return window_.hwnd() != NULL;
 }
 
 void ProcessSingleton::Cleanup() {
 }