Add FilePath to base namespace.

remoting/host/win/wts_session_process_delegate.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.
 //
 // This file implements the Windows service controlling Me2Me host processes
 // running within user sessions.
 
 #include "remoting/host/win/wts_session_process_delegate.h"
 
 #include "base/base_switches.h"
@@ skipping 38 matching lines @@
 // asynchronous fire-and-forget shutdown.
 class WtsSessionProcessDelegate::Core
     : public base::RefCountedThreadSafe<WtsSessionProcessDelegate::Core>,
       public base::MessagePumpForIO::IOHandler,
       public WorkerProcessLauncher::Delegate {
  public:
   // The caller must ensure that |delegate| remains valid at least until
   // Stop() method has been called.
   Core(scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
        scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-       const FilePath& binary_path,
+       const base::FilePath& binary_path,
        bool launch_elevated,
        const std::string& channel_security);
 
   // base::MessagePumpForIO::IOHandler implementation.
   virtual void OnIOCompleted(base::MessagePumpForIO::IOContext* context,
                              DWORD bytes_transferred,
                              DWORD error) OVERRIDE;
 
   // IPC::Sender implementation.
   virtual bool Send(IPC::Message* message) OVERRIDE;
@@ skipping 33 matching lines @@
   // Called to process incoming job object notifications.
   void OnJobNotification(DWORD message, DWORD pid);
 
   // The task runner all public methods of this class should be called on.
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 
   // The task runner serving job object notifications.
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // Path to the worker process binary.
-  FilePath binary_path_;
+  base::FilePath binary_path_;
 
   // The server end of the IPC channel used to communicate to the worker
   // process.
   scoped_ptr<IPC::ChannelProxy> channel_;
 
   // Security descriptor (as SDDL) to be applied to |channel_|.
   std::string channel_security_;
 
   // Pointer to GetNamedPipeClientProcessId() API if it is available.
   typedef BOOL (WINAPI * GetNamedPipeClientProcessIdFn)(HANDLE, DWORD*);
@@ skipping 20 matching lines @@
 
   // The handle of the worker process, if launched.
   base::win::ScopedHandle worker_process_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 WtsSessionProcessDelegate::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-    const FilePath& binary_path,
+    const base::FilePath& binary_path,
     bool launch_elevated,
     const std::string& channel_security)
     : main_task_runner_(main_task_runner),
       io_task_runner_(io_task_runner),
       binary_path_(binary_path),
       channel_security_(channel_security),
       get_named_pipe_client_pid_(NULL),
       launch_elevated_(launch_elevated),
       stopping_(false) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
@@ skipping 77 matching lines @@
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   CommandLine command_line(CommandLine::NO_PROGRAM);
   if (launch_elevated_) {
     // The job object is not ready. Retry starting the host process later.
     if (!job_.IsValid()) {
       return false;
     }
 
     // Construct the helper binary name.
-    FilePath daemon_binary;
+    base::FilePath daemon_binary;
     if (!GetInstalledBinaryPath(kDaemonBinaryName, &daemon_binary))
       return false;
 
     // Create the command line passing the name of the IPC channel to use and
     // copying known switches from the caller's command line.
     command_line.SetProgram(daemon_binary);
     command_line.AppendSwitchPath(kElevateSwitchName, binary_path_);
 
     CHECK(ResetEvent(process_exit_event_));
   } else {
@@ skipping 215 matching lines @@
       // if we cannot get the actual exit code. So here we can safely ignore
       // the error returned by OpenProcess().
       worker_process_.Set(OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid));
       break;
   }
 }
 
 WtsSessionProcessDelegate::WtsSessionProcessDelegate(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-    const FilePath& binary_path,
+    const base::FilePath& binary_path,
     uint32 session_id,
     bool launch_elevated,
     const std::string& channel_security) {
   core_ = new Core(main_task_runner, io_task_runner, binary_path,
                    launch_elevated, channel_security);
   if (!core_->Initialize(session_id)) {
     core_->Stop();
     core_ = NULL;
   }
 }
@@ skipping 31 matching lines @@
 bool WtsSessionProcessDelegate::LaunchProcess(
     IPC::Listener* delegate,
     base::win::ScopedHandle* process_exit_event_out) {
   if (!core_)
     return false;
 
   return core_->LaunchProcess(delegate, process_exit_event_out);
 }
 
 } // namespace remoting