Move PathIsWritable, DirectoryExists, ContentsEqual, and TextContentsEqual to the base namespace.

chrome/test/chromedriver/chrome/zip.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/test/chromedriver/chrome/zip.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/logging.h"
@@ skipping 39 matching lines @@
 }
 
 bool AddEntryToZip(zipFile zip_file, const base::FilePath& path,
                    const base::FilePath& root_path) {
   std::string str_path =
       path.AsUTF8Unsafe().substr(root_path.value().length() + 1);
 #if defined(OS_WIN)
   ReplaceSubstringsAfterOffset(&str_path, 0u, "\\", "/");
 #endif
 
-  bool is_directory = file_util::DirectoryExists(path);
+  bool is_directory = base::DirectoryExists(path);
   if (is_directory)
     str_path += "/";
 
   if (ZIP_OK != zipOpenNewFileInZip(
       zip_file, str_path.c_str(),
       NULL, NULL, 0u, NULL, 0u, NULL,  // file info, extrafield local, length,
                                        // extrafield global, length, comment
       Z_DEFLATED, Z_DEFAULT_COMPRESSION)) {
     DLOG(ERROR) << "Could not open zip file entry " << str_path;
     return false;
@@ skipping 49 matching lines @@
       DLOG(WARNING) << "Failed to advance to the next file";
       return false;
     }
   }
   return true;
 }
 
 bool ZipWithFilterCallback(const base::FilePath& src_dir,
                            const base::FilePath& dest_file,
                            const FilterCallback& filter_cb) {
-  DCHECK(file_util::DirectoryExists(src_dir));
+  DCHECK(base::DirectoryExists(src_dir));
 
   zipFile zip_file = internal::OpenForZipping(dest_file.AsUTF8Unsafe(),
                                               APPEND_STATUS_CREATE);
 
   if (!zip_file) {
     DLOG(WARNING) << "couldn't create file " << dest_file.value();
     return false;
   }
 
   bool success = true;
@@ skipping 27 matching lines @@
   } else {
     return ZipWithFilterCallback(
         src_dir, dest_file, base::Bind(&ExcludeHiddenFilesFilter));
   }
 }
 
 #if defined(OS_POSIX)
 bool ZipFiles(const base::FilePath& src_dir,
               const std::vector<base::FilePath>& src_relative_paths,
               int dest_fd) {
-  DCHECK(file_util::DirectoryExists(src_dir));
+  DCHECK(base::DirectoryExists(src_dir));
   zipFile zip_file = internal::OpenFdForZipping(dest_fd, APPEND_STATUS_CREATE);
 
   if (!zip_file) {
     DLOG(ERROR) << "couldn't create file for fd " << dest_fd;
     return false;
   }
 
   bool success = true;
   for (std::vector<base::FilePath>::const_iterator iter =
            src_relative_paths.begin();
       iter != src_relative_paths.end(); ++iter) {
     const base::FilePath& path = src_dir.Append(*iter);
     if (!AddEntryToZip(zip_file, path, src_dir)) {
       // TODO(hshi): clean up the partial zip file when error occurs.
       success = false;
       break;
     }
   }
 
   if (ZIP_OK != zipClose(zip_file, NULL)) {
     DLOG(ERROR) << "Error closing zip file for fd " << dest_fd;
     success = false;
   }
 
   return success;
 }
 #endif  // defined(OS_POSIX)
 
 }  // namespace zip