Move WriteFile and WriteFileDescriptor from file_util to base namespace.

chrome/test/chromedriver/chrome_launcher.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_launcher.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 47 matching lines @@
 #endif
 
 Status UnpackAutomationExtension(const base::FilePath& temp_dir,
                                  base::FilePath* automation_extension) {
   std::string decoded_extension;
   if (!base::Base64Decode(kAutomationExtension, &decoded_extension))
     return Status(kUnknownError, "failed to base64decode automation extension");
 
   base::FilePath extension_zip = temp_dir.AppendASCII("internal.zip");
   int size = static_cast<int>(decoded_extension.length());
-  if (file_util::WriteFile(extension_zip, decoded_extension.c_str(), size)
+  if (base::WriteFile(extension_zip, decoded_extension.c_str(), size)
       != size) {
     return Status(kUnknownError, "failed to write automation extension zip");
   }
 
   base::FilePath extension_dir = temp_dir.AppendASCII("internal");
   if (!zip::Unzip(extension_zip, extension_dir))
     return Status(kUnknownError, "failed to unzip automation extension");
 
   *automation_extension = extension_dir;
   return Status(kOk);
@@ skipping 427 matching lines @@
   std::string public_key_base64;
   base::Base64Encode(public_key, &public_key_base64);
   std::string id = GenerateExtensionId(public_key);
 
   // Unzip the crx file.
   base::ScopedTempDir temp_crx_dir;
   if (!temp_crx_dir.CreateUniqueTempDir())
     return Status(kUnknownError, "cannot create temp dir");
   base::FilePath extension_crx = temp_crx_dir.path().AppendASCII("temp.crx");
   int size = static_cast<int>(decoded_extension.length());
-  if (file_util::WriteFile(extension_crx, decoded_extension.c_str(), size) !=
+  if (base::WriteFile(extension_crx, decoded_extension.c_str(), size) !=
       size) {
     return Status(kUnknownError, "cannot write file");
   }
   base::FilePath extension_dir = temp_dir.AppendASCII("extension_" + id);
   if (!zip::Unzip(extension_crx, extension_dir))
     return Status(kUnknownError, "cannot unzip");
 
   // Parse the manifest and set the 'key' if not already present.
   base::FilePath manifest_path(extension_dir.AppendASCII("manifest.json"));
   std::string manifest_data;
@@ skipping 19 matching lines @@
           << std::endl << "key from header:   " << public_key_base64
           << std::endl << "key from manifest: " << manifest_key_base64
           << std::endl << "generated extension id from header key:   " << id
           << std::endl << "generated extension id from manifest key: "
           << manifest_id;
       id = manifest_id;
     }
   } else {
     manifest->SetString("key", public_key_base64);
     base::JSONWriter::Write(manifest, &manifest_data);
-    if (file_util::WriteFile(
+    if (base::WriteFile(
             manifest_path, manifest_data.c_str(), manifest_data.size()) !=
         static_cast<int>(manifest_data.size())) {
       return Status(kUnknownError, "cannot add 'key' to manifest");
     }
   }
 
   // Get extension's background page URL, if there is one.
   std::string bg_page_tmp;
   Status status = GetExtensionBackgroundPage(manifest, id, &bg_page_tmp);
   if (status.IsError())
@@ skipping 77 matching lines @@
     for (base::DictionaryValue::Iterator it(*custom_prefs); !it.IsAtEnd();
          it.Advance()) {
       prefs->Set(it.key(), it.value().DeepCopy());
     }
   }
 
   std::string prefs_str;
   base::JSONWriter::Write(prefs, &prefs_str);
   VLOG(0) << "Populating " << path.BaseName().value()
           << " file: " << PrettyPrintValue(*prefs);
-  if (static_cast<int>(prefs_str.length()) != file_util::WriteFile(
+  if (static_cast<int>(prefs_str.length()) != base::WriteFile(
           path, prefs_str.c_str(), prefs_str.length())) {
     return Status(kUnknownError, "failed to write prefs file");
   }
   return Status(kOk);
 }
 
 Status PrepareUserDataDir(
     const base::FilePath& user_data_dir,
     const base::DictionaryValue* custom_prefs,
     const base::DictionaryValue* custom_local_state) {
@@ skipping 10 matching lines @@
     return status;
 
   status = WritePrefsFile(kLocalState,
                           custom_local_state,
                           user_data_dir.Append(chrome::kLocalStateFilename));
   if (status.IsError())
     return status;
 
   // Write empty "First Run" file, otherwise Chrome will wipe the default
   // profile that was written.
-  if (file_util::WriteFile(
+  if (base::WriteFile(
           user_data_dir.Append(chrome::kFirstRunSentinel), "", 0) != 0) {
     return Status(kUnknownError, "failed to write first run file");
   }
   return Status(kOk);
 }
 
 }  // namespace internal