Move CommandLine to base namespace.

chrome/browser/service_process/service_process_control.h

 // 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.
 
 #ifndef CHROME_BROWSER_SERVICE_PROCESS_SERVICE_PROCESS_CONTROL_H_
 #define CHROME_BROWSER_SERVICE_PROCESS_SERVICE_PROCESS_CONTROL_H_
 
 #include <queue>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/cancelable_callback.h"
 #include "base/id_map.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/process/process.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
 
+namespace base {
 class CommandLine;
+}
 
 namespace cloud_print {
 struct CloudPrintProxyInfo;
 }  // namespace cloud_print
 
 // A ServiceProcessControl works as a portal between the service process and
 // the browser process.
 //
 // It is used to start and terminate the service process. It is also used
 // to send and receive IPC messages from the service process.
@@ skipping 88 matching lines @@
   // be called in this case.
   bool GetHistograms(const base::Closure& cloud_print_status_callback,
                      const base::TimeDelta& timeout);
 
  private:
   // This class is responsible for launching the service process on the
   // PROCESS_LAUNCHER thread.
   class Launcher
       : public base::RefCountedThreadSafe<ServiceProcessControl::Launcher> {
    public:
-    Launcher(ServiceProcessControl* process, CommandLine* cmd_line);
+    Launcher(ServiceProcessControl* process, base::CommandLine* cmd_line);
     // Execute the command line to start the process asynchronously. After the
     // command is executed |task| is called with the process handle on the UI
     // thread.
     void Run(const base::Closure& task);
 
     bool launched() const { return launched_; }
 
    private:
     friend class base::RefCountedThreadSafe<ServiceProcessControl::Launcher>;
     virtual ~Launcher();
 
 #if !defined(OS_MACOSX)
     void DoDetectLaunched();
 #endif  // !OS_MACOSX
 
     void DoRun();
     void Notify();
     void CloseProcessHandle();
     ServiceProcessControl* process_;
-    scoped_ptr<CommandLine> cmd_line_;
+    scoped_ptr<base::CommandLine> cmd_line_;
     base::Closure notify_task_;
     bool launched_;
     uint32 retry_count_;
     base::ProcessHandle process_handle_;
   };
 
   friend class MockServiceProcessControl;
   friend class CloudPrintProxyPolicyStartupTest;
 
   ServiceProcessControl();
@@ skipping 44 matching lines @@
   // the service process.
   base::Closure histograms_callback_;
 
   content::NotificationRegistrar registrar_;
 
   // Callback that gets invoked if service didn't reply in time.
   base::CancelableClosure histograms_timeout_callback_;
 };
 
 #endif  // CHROME_BROWSER_SERVICE_PROCESS_SERVICE_PROCESS_CONTROL_H_