Move PathExists to base namespace.

chrome/common/extensions/extension_file_util.cc

 // Copyright (c) 2013 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 "chrome/common/extensions/extension_file_util.h"
 
 #include <map>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 54 matching lines @@
 namespace extension_file_util {
 
 base::FilePath InstallExtension(const base::FilePath& unpacked_source_dir,
                                 const std::string& id,
                                 const std::string& version,
                                 const base::FilePath& extensions_dir) {
   base::FilePath extension_dir = extensions_dir.AppendASCII(id);
   base::FilePath version_dir;
 
   // Create the extension directory if it doesn't exist already.
-  if (!file_util::PathExists(extension_dir)) {
+  if (!base::PathExists(extension_dir)) {
     if (!file_util::CreateDirectory(extension_dir))
       return base::FilePath();
   }
 
   // Get a temp directory on the same file system as the profile.
   base::FilePath install_temp_dir = GetInstallTempDir(extensions_dir);
   base::ScopedTempDir extension_temp_dir;
   if (install_temp_dir.empty() ||
       !extension_temp_dir.CreateUniqueTempDirUnderPath(install_temp_dir)) {
     LOG(ERROR) << "Creating of temp dir under in the profile failed.";
     return base::FilePath();
   }
   base::FilePath crx_temp_source =
       extension_temp_dir.path().Append(unpacked_source_dir.BaseName());
   if (!base::Move(unpacked_source_dir, crx_temp_source)) {
     LOG(ERROR) << "Moving extension from : " << unpacked_source_dir.value()
                << " to : " << crx_temp_source.value() << " failed.";
     return base::FilePath();
   }
 
   // Try to find a free directory. There can be legitimate conflicts in the case
   // of overinstallation of the same version.
   const int kMaxAttempts = 100;
   for (int i = 0; i < kMaxAttempts; ++i) {
     base::FilePath candidate = extension_dir.AppendASCII(
         base::StringPrintf("%s_%u", version.c_str(), i));
-    if (!file_util::PathExists(candidate)) {
+    if (!base::PathExists(candidate)) {
       version_dir = candidate;
       break;
     }
   }
 
   if (version_dir.empty()) {
     LOG(ERROR) << "Could not find a home for extension " << id << " with "
                << "version " << version << ".";
     return base::FilePath();
   }
@@ skipping 50 matching lines @@
     return NULL;
   extension->AddInstallWarnings(warnings);
 
   return extension;
 }
 
 base::DictionaryValue* LoadManifest(const base::FilePath& extension_path,
                                     std::string* error) {
   base::FilePath manifest_path =
       extension_path.Append(extensions::kManifestFilename);
-  if (!file_util::PathExists(manifest_path)) {
+  if (!base::PathExists(manifest_path)) {
     *error = l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_UNREADABLE);
     return NULL;
   }
 
   JSONFileValueSerializer serializer(manifest_path);
   scoped_ptr<base::Value> root(serializer.Deserialize(NULL, error));
   if (!root.get()) {
     if (error->empty()) {
       // If |error| is empty, than the file could not be read.
       // It would be cleaner to have the JSON reader give a specific error
@@ skipping 38 matching lines @@
       continue;
     }
 
     result.push_back(current);
   }
   return result;
 }
 
 bool ValidateFilePath(const base::FilePath& path) {
   int64 size = 0;
-  if (!file_util::PathExists(path) ||
+  if (!base::PathExists(path) ||
       !file_util::GetFileSize(path, &size) ||
       size == 0) {
     return false;
   }
 
   return true;
 }
 
 bool ValidateExtensionIconSet(const ExtensionIconSet& icon_set,
                               const Extension* extension,
@@ skipping 159 matching lines @@
   }
 }
 
 extensions::MessageBundle* LoadMessageBundle(
     const base::FilePath& extension_path,
     const std::string& default_locale,
     std::string* error) {
   error->clear();
   // Load locale information if available.
   base::FilePath locale_path = extension_path.Append(extensions::kLocaleFolder);
-  if (!file_util::PathExists(locale_path))
+  if (!base::PathExists(locale_path))
     return NULL;
 
   std::set<std::string> locales;
   if (!extension_l10n_util::GetValidLocales(locale_path, &locales, error))
     return NULL;
 
   if (default_locale.empty() ||
       locales.find(default_locale) == locales.end()) {
     *error = l10n_util::GetStringUTF8(
         IDS_EXTENSION_LOCALES_NO_DEFAULT_LOCALE_SPECIFIED);
@@ skipping 99 matching lines @@
   std::string host = net::UnescapeURLComponent(url.host(),
       net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS);
   if (host.empty())
     return base::FilePath();
 
   base::FilePath relative_path = ExtensionURLToRelativeFilePath(url);
   if (relative_path.empty())
     return base::FilePath();
 
   base::FilePath path = root.AppendASCII(host).Append(relative_path);
-  if (!file_util::PathExists(path))
+  if (!base::PathExists(path))
     return base::FilePath();
   path = base::MakeAbsoluteFilePath(path);
   if (path.empty() || !root.IsParent(path))
     return base::FilePath();
   return path;
 }
 
 base::FilePath GetInstallTempDir(const base::FilePath& extensions_dir) {
   // We do file IO in this function, but only when the current profile's
   // Temp directory has never been used before, or in a rare error case.
   // Developers are not likely to see these situations often, so do an
   // explicit thread check.
   base::ThreadRestrictions::AssertIOAllowed();
 
   // Create the temp directory as a sub-directory of the Extensions directory.
   // This guarantees it is on the same file system as the extension's eventual
   // install target.
   base::FilePath temp_path = extensions_dir.Append(kTempDirectoryName);
-  if (file_util::PathExists(temp_path)) {
+  if (base::PathExists(temp_path)) {
     if (!file_util::DirectoryExists(temp_path)) {
       DLOG(WARNING) << "Not a directory: " << temp_path.value();
       return base::FilePath();
     }
     if (!file_util::PathIsWritable(temp_path)) {
       DLOG(WARNING) << "Can't write to path: " << temp_path.value();
       return base::FilePath();
     }
     // This is a directory we can write to.
     return temp_path;
   }
 
   // Directory doesn't exist, so create it.
   if (!file_util::CreateDirectory(temp_path)) {
     DLOG(WARNING) << "Couldn't create directory: " << temp_path.value();
     return base::FilePath();
   }
   return temp_path;
 }
 
 void DeleteFile(const base::FilePath& path, bool recursive) {
   base::Delete(path, recursive);
 }
 
 }  // namespace extension_file_util