Move FileEnumerator to its own file, do some refactoring.

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}
 //
 // This is a reduction of the functionality in those classes.
 
 #include <set>
 
 #include "remoting/host/policy_hack/policy_watcher.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
+#include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_path_watcher.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time.h"
 #include "base/values.h"
 
@@ skipping 71 matching lines @@
     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);
+    base::FileEnumerator file_enumerator(config_dir_,
+                                         false,
+                                         base::FileEnumerator::FILES);
     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<base::FilePath> files;
-    file_util::FileEnumerator file_enumerator(config_dir_, false,
-                                              file_util::FileEnumerator::FILES);
+    base::FileEnumerator file_enumerator(config_dir_, false,
+                                         base::FileEnumerator::FILES);
     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<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);
@@ skipping 100 matching lines @@
 };
 
 PolicyWatcher* PolicyWatcher::Create(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   base::FilePath policy_dir(kPolicyDir);
   return new PolicyWatcherLinux(task_runner, policy_dir);
 }
 
 }  // namespace policy_hack
 }  // namespace remoting