Add FilePath to base namespace.

remoting/host/policy_hack/policy_watcher_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.
 
 // Most of this code is copied from various classes in
 // src/chrome/browser/policy. In particular, look at
 //
 //   file_based_policy_loader.{h,cc}
 //   config_dir_policy_provider.{h,cc}
 //
@@ skipping 14 matching lines @@
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time.h"
 #include "base/values.h"
 
 namespace remoting {
 namespace policy_hack {
 
 namespace {
 
-const FilePath::CharType kPolicyDir[] =
+const base::FilePath::CharType kPolicyDir[] =
   // Always read the Chrome policies (even on Chromium) so that policy
   // enforcement can't be bypassed by running Chromium.
   FILE_PATH_LITERAL("/etc/opt/chrome/policies/managed");
 
 // Amount of time we wait for the files on disk to settle before trying to load
 // them. This alleviates the problem of reading partially written files and
 // makes it possible to batch quasi-simultaneous changes.
 const int kSettleIntervalSeconds = 5;
 
 }  // namespace
 
 class PolicyWatcherLinux : public PolicyWatcher {
  public:
   PolicyWatcherLinux(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-                     const FilePath& config_dir)
+                     const base::FilePath& config_dir)
       : PolicyWatcher(task_runner),
         config_dir_(config_dir),
         ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
     // Detach the factory because we ensure that only the policy thread ever
     // calls methods on this. Also, the API contract of having to call
     // StopWatching() (which signals completion) after StartWatching()
     // before this object can be destructed ensures there are no users of
     // this object before it is destructed.
     weak_factory_.DetachFromThread();
   }
@@ skipping 21 matching lines @@
     ScheduleFallbackReloadTask();
   }
 
   virtual void StopWatchingInternal() OVERRIDE {
     DCHECK(OnPolicyWatcherThread());
     // Cancel any inflight requests.
     watcher_.reset();
   }
 
  private:
-  void OnFilePathChanged(const FilePath& path, bool error) {
+  void OnFilePathChanged(const base::FilePath& path, bool error) {
     DCHECK(OnPolicyWatcherThread());
 
     if (!error)
       Reload();
     else
       LOG(ERROR) << "PolicyWatcherLinux on " << path.value() << " failed.";
   }
 
   base::Time GetLastModification() {
     DCHECK(OnPolicyWatcherThread());
     base::Time last_modification = base::Time();
     base::PlatformFileInfo file_info;
 
     // If the path does not exist or points to a directory, it's safe to load.
     if (!file_util::GetFileInfo(config_dir_, &file_info) ||
         !file_info.is_directory) {
       return last_modification;
     }
 
     // Enumerate the files and find the most recent modification timestamp.
     file_util::FileEnumerator file_enumerator(config_dir_,
                                               false,
                                               file_util::FileEnumerator::FILES);
-    for (FilePath config_file = file_enumerator.Next();
+    for (base::FilePath config_file = file_enumerator.Next();
          !config_file.empty();
          config_file = file_enumerator.Next()) {
       if (file_util::GetFileInfo(config_file, &file_info) &&
           !file_info.is_directory) {
         last_modification = std::max(last_modification,
                                      file_info.last_modified);
       }
     }
 
     return last_modification;
   }
 
   // Returns NULL if the policy dictionary couldn't be read.
   scoped_ptr<DictionaryValue> Load() {
     DCHECK(OnPolicyWatcherThread());
     // Enumerate the files and sort them lexicographically.
-    std::set<FilePath> files;
+    std::set<base::FilePath> files;
     file_util::FileEnumerator file_enumerator(config_dir_, false,
                                               file_util::FileEnumerator::FILES);
-    for (FilePath config_file_path = file_enumerator.Next();
+    for (base::FilePath config_file_path = file_enumerator.Next();
          !config_file_path.empty(); config_file_path = file_enumerator.Next())
       files.insert(config_file_path);
 
     // Start with an empty dictionary and merge the files' contents.
     scoped_ptr<DictionaryValue> policy(new DictionaryValue());
-    for (std::set<FilePath>::iterator config_file_iter = files.begin();
+    for (std::set<base::FilePath>::iterator config_file_iter = files.begin();
          config_file_iter != files.end(); ++config_file_iter) {
       JSONFileValueSerializer deserializer(*config_file_iter);
       deserializer.set_allow_trailing_comma(true);
       int error_code = 0;
       std::string error_msg;
       scoped_ptr<Value> value(
           deserializer.Deserialize(&error_code, &error_msg));
       if (!value.get()) {
         LOG(WARNING) << "Failed to read configuration file "
                      << config_file_iter->value() << ": " << error_msg;
@@ skipping 79 matching lines @@
 
   // Records last known modification timestamp of |config_dir_|.
   base::Time last_modification_file_;
 
   // The wall clock time at which the last modification timestamp was
   // recorded.  It's better to not assume the file notification time and the
   // wall clock times come from the same source, just in case there is some
   // non-local filesystem involved.
   base::Time last_modification_clock_;
 
-  const FilePath config_dir_;
+  const base::FilePath config_dir_;
 
   // Allows us to cancel any inflight FileWatcher events or scheduled reloads.
   base::WeakPtrFactory<PolicyWatcherLinux> weak_factory_;
 };
 
 PolicyWatcher* PolicyWatcher::Create(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  FilePath policy_dir(kPolicyDir);
+  base::FilePath policy_dir(kPolicyDir);
   return new PolicyWatcherLinux(task_runner, policy_dir);
 }
 
 }  // namespace policy_hack
 }  // namespace remoting