Move Copy* into the base namespace.

chrome/browser/extensions/extension_service_unittest.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/browser/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 495 matching lines @@
 
 void ExtensionServiceTestBase::InitializeInstalledExtensionService(
     const base::FilePath& prefs_file,
     const base::FilePath& source_install_dir) {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   base::FilePath path = temp_dir_.path();
   path = path.Append(FILE_PATH_LITERAL("TestingExtensionsPath"));
   base::Delete(path, true);
   file_util::CreateDirectory(path);
   base::FilePath temp_prefs = path.Append(FILE_PATH_LITERAL("Preferences"));
-  file_util::CopyFile(prefs_file, temp_prefs);
+  base::CopyFile(prefs_file, temp_prefs);
 
   extensions_install_dir_ = path.Append(FILE_PATH_LITERAL("Extensions"));
   base::Delete(extensions_install_dir_, true);
-  file_util::CopyDirectory(source_install_dir, extensions_install_dir_, true);
+  base::CopyDirectory(source_install_dir, extensions_install_dir_, true);
 
   ExtensionServiceInitParams params;
   params.profile_path = path;
   params.pref_file = temp_prefs;
   params.extensions_install_dir = extensions_install_dir_;
   InitializeExtensionService(params);
 }
 
 void ExtensionServiceTestBase::InitializeEmptyExtensionService() {
   InitializeExtensionServiceHelper(false, true);
@@ skipping 326 matching lines @@
   }
 
   void UpdateExtension(const std::string& id, const base::FilePath& in_path,
                        UpdateState expected_state) {
     ASSERT_TRUE(file_util::PathExists(in_path));
 
     // We need to copy this to a temporary location because Update() will delete
     // it.
     base::FilePath path = temp_dir_.path();
     path = path.Append(in_path.BaseName());
-    ASSERT_TRUE(file_util::CopyFile(in_path, path));
+    ASSERT_TRUE(base::CopyFile(in_path, path));
 
     int previous_enabled_extension_count =
         service_->extensions()->size();
     int previous_installed_extension_count =
         previous_enabled_extension_count +
         service_->disabled_extensions()->size();
 
     service_->UpdateExtension(id, path, GURL(), NULL);
     loop_.RunUntilIdle();
 
@@ skipping 1232 matching lines @@
         FILE_PATH_LITERAL(".thisextensionsnamestartswithaperiod.pem")),
     base::FilePath(FILE_PATH_LITERAL("thisextensionhasaslashinitsname.pem")),
   };
 
   for (size_t i = 0; i < arraysize(punctuated_names); ++i) {
     SCOPED_TRACE(punctuated_names[i].value().c_str());
     base::FilePath output_dir = temp_dir.path().Append(punctuated_names[i]);
 
     // Copy the extension into the output directory, as PackExtensionJob doesn't
     // let us choose where to output the packed extension.
-    ASSERT_TRUE(file_util::CopyDirectory(input_directory, output_dir, true));
+    ASSERT_TRUE(base::CopyDirectory(input_directory, output_dir, true));
 
     base::FilePath expected_crx_path =
         temp_dir.path().Append(expected_crx_names[i]);
     base::FilePath expected_private_key_path =
         temp_dir.path().Append(expected_private_key_names[i]);
     PackExtensionTestClient pack_client(expected_crx_path,
                                         expected_private_key_path);
     scoped_refptr<extensions::PackExtensionJob> packer(
         new extensions::PackExtensionJob(&pack_client, output_dir,
                                          base::FilePath(),
@@ skipping 13 matching lines @@
     InstallCRX(expected_crx_path, INSTALL_NEW);
   }
 }
 
 TEST_F(ExtensionServiceTest, PackExtensionContainingKeyFails) {
   InitializeEmptyExtensionService();
 
   base::ScopedTempDir extension_temp_dir;
   ASSERT_TRUE(extension_temp_dir.CreateUniqueTempDir());
   base::FilePath input_directory = extension_temp_dir.path().AppendASCII("ext");
-  ASSERT_TRUE(file_util::CopyDirectory(
+  ASSERT_TRUE(base::CopyDirectory(
       data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0"),
       input_directory,
       /*recursive=*/true));
 
   base::ScopedTempDir output_temp_dir;
   ASSERT_TRUE(output_temp_dir.CreateUniqueTempDir());
@@ skipping 132 matching lines @@
       AppendASCII("manifest_no_key.json");
 
   base::FilePath manifest_with_key = data_dir_.
       AppendASCII("unpacked").
       AppendASCII("manifest_with_key.json");
 
   ASSERT_TRUE(file_util::PathExists(manifest_no_key));
   ASSERT_TRUE(file_util::PathExists(manifest_with_key));
 
   // Load the unpacked extension with no key.
-  file_util::CopyFile(manifest_no_key, manifest_path);
+  base::CopyFile(manifest_no_key, manifest_path);
   extensions::UnpackedInstaller::Create(service_)->Load(extension_path);
 
   loop_.RunUntilIdle();
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   EXPECT_EQ(1u, service_->extensions()->size());
 
   // Add the key to the manifest.
-  file_util::CopyFile(manifest_with_key, manifest_path);
+  base::CopyFile(manifest_with_key, manifest_path);
   loaded_.clear();
 
   // Reload the extensions.
   service_->ReloadExtensions();
   const Extension* extension = service_->GetExtensionById(unpacked, false);
   EXPECT_EQ(unpacked, extension->id());
   ASSERT_EQ(1u, loaded_.size());
 
   // TODO(jstritar): Right now this just makes sure we don't crash and burn, but
   // we should also test that preferences are preserved.
@@ skipping 11 matching lines @@
   base::FilePath source_icon = source_data_dir.AppendASCII("icon.png");
   ASSERT_TRUE(file_util::PathExists(source_icon));
 
   // Set up the temporary extension directory.
   base::ScopedTempDir temp;
   ASSERT_TRUE(temp.CreateUniqueTempDir());
   base::FilePath extension_path = temp.path();
   base::FilePath manifest = extension_path.Append(
       extensions::kManifestFilename);
   base::FilePath icon_symlink = extension_path.AppendASCII("icon.png");
-  file_util::CopyFile(source_manifest, manifest);
+  base::CopyFile(source_manifest, manifest);
   file_util::CreateSymbolicLink(source_icon, icon_symlink);
 
   // Load extension.
   InitializeEmptyExtensionService();
   extensions::UnpackedInstaller::Create(service_)->Load(extension_path);
   loop_.RunUntilIdle();
 
   EXPECT_TRUE(GetErrors().empty());
   ASSERT_EQ(1u, loaded_.size());
   EXPECT_EQ(1u, service_->extensions()->size());
@@ skipping 3736 matching lines @@
       new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
   AddMockExternalProvider(provider);
   provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
 
   service_->CheckForExternalUpdates();
   loop_.RunUntilIdle();
   EXPECT_TRUE(extensions::HasExternalInstallError(service_));
   EXPECT_FALSE(extensions::HasExternalInstallBubble(service_));
   EXPECT_FALSE(service_->IsExtensionEnabled(updates_from_webstore));
 }