Add FilePath to base namespace.

remoting/host/setup/daemon_controller_linux.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 "remoting/host/setup/daemon_controller.h"
 
 #include <unistd.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 50 matching lines @@
       const CompletionCallback& done) OVERRIDE;
   virtual void UpdateConfig(scoped_ptr<base::DictionaryValue> config,
                             const CompletionCallback& done_callback) OVERRIDE;
   virtual void Stop(const CompletionCallback& done_callback) OVERRIDE;
   virtual void SetWindow(void* window_handle) OVERRIDE;
   virtual void GetVersion(const GetVersionCallback& done_callback) OVERRIDE;
   virtual void GetUsageStatsConsent(
       const GetUsageStatsConsentCallback& done) OVERRIDE;
 
  private:
-  FilePath GetConfigPath();
+  base::FilePath GetConfigPath();
 
   void DoGetConfig(const GetConfigCallback& callback);
   void DoSetConfigAndStart(scoped_ptr<base::DictionaryValue> config,
                            const CompletionCallback& done);
   void DoUpdateConfig(scoped_ptr<base::DictionaryValue> config,
                       const CompletionCallback& done_callback);
   void DoStop(const CompletionCallback& done_callback);
   void DoGetVersion(const GetVersionCallback& done_callback);
 
   base::Thread file_io_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(DaemonControllerLinux);
 };
 
 DaemonControllerLinux::DaemonControllerLinux()
     : file_io_thread_("DaemonControllerFileIO") {
   file_io_thread_.Start();
 }
 
-static bool GetScriptPath(FilePath* result) {
-  FilePath candidate_exe(kDaemonScript);
+static bool GetScriptPath(base::FilePath* result) {
+  base::FilePath candidate_exe(kDaemonScript);
   if (access(candidate_exe.value().c_str(), X_OK) == 0) {
     *result = candidate_exe;
     return true;
   }
   return false;
 }
 
 static bool RunHostScriptWithTimeout(
     const std::vector<std::string>& args,
     base::TimeDelta timeout,
     int* exit_code) {
   // As long as we're relying on running an external binary from the
   // PATH, don't do it as root.
   if (getuid() == 0) {
     return false;
   }
-  FilePath script_path;
+  base::FilePath script_path;
   if (!GetScriptPath(&script_path)) {
     return false;
   }
   CommandLine command_line(script_path);
   for (unsigned int i = 0; i < args.size(); ++i) {
     command_line.AppendArg(args[i]);
   }
   base::ProcessHandle process_handle;
   bool result = base::LaunchProcess(command_line,
                                     base::LaunchOptions(),
@@ skipping 73 matching lines @@
   // noop
 }
 
 void DaemonControllerLinux::GetVersion(
     const GetVersionCallback& done_callback) {
   file_io_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &DaemonControllerLinux::DoGetVersion, base::Unretained(this),
       done_callback));
 }
 
-FilePath DaemonControllerLinux::GetConfigPath() {
+base::FilePath DaemonControllerLinux::GetConfigPath() {
   std::string filename = "host#" + GetMd5(net::GetHostName()) + ".json";
   return file_util::GetHomeDir().
       Append(".config/chrome-remote-desktop").Append(filename);
 }
 
 void DaemonControllerLinux::DoGetConfig(const GetConfigCallback& callback) {
   scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
 
   if (GetState() != remoting::DaemonController::STATE_NOT_IMPLEMENTED) {
     JsonHostConfig config(GetConfigPath());
@@ skipping 24 matching lines @@
   if (!RunHostScriptWithTimeout(
           args, base::TimeDelta::FromMilliseconds(kSudoTimeoutMs),
           &exit_code) ||
       exit_code != 0) {
     LOG(ERROR) << "Failed to add user to chrome-remote-desktop group.";
     done_callback.Run(RESULT_FAILED);
     return;
   }
 
   // Ensure the configuration directory exists.
-  FilePath config_dir = GetConfigPath().DirName();
+  base::FilePath config_dir = GetConfigPath().DirName();
   if (!file_util::DirectoryExists(config_dir) &&
       !file_util::CreateDirectory(config_dir)) {
     LOG(ERROR) << "Failed to create config directory " << config_dir.value();
     done_callback.Run(RESULT_FAILED);
     return;
   }
 
   // Write config.
   JsonHostConfig config_file(GetConfigPath());
   if (!config_file.CopyFrom(config.get()) ||
@@ skipping 48 matching lines @@
   if (RunHostScript(args, &exit_code)) {
     result = (exit_code == 0) ? RESULT_OK : RESULT_FAILED;
   } else {
     result = RESULT_FAILED;
   }
   done_callback.Run(result);
 }
 
 void DaemonControllerLinux::DoGetVersion(
     const GetVersionCallback& done_callback) {
-  FilePath script_path;
+  base::FilePath script_path;
   if (!GetScriptPath(&script_path)) {
     done_callback.Run("");
     return;
   }
   CommandLine command_line(script_path);
   command_line.AppendArg("--host-version");
 
   std::string version;
   int exit_code = 0;
   int result =
@@ skipping 15 matching lines @@
   done_callback.Run(version);
 }
 
 }  // namespace
 
 scoped_ptr<DaemonController> remoting::DaemonController::Create() {
   return scoped_ptr<DaemonController>(new DaemonControllerLinux());
 }
 
 }  // namespace remoting