Move ReadFileToString to the base namespace.

chrome/browser/download/download_browsertest.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.
 
 #include <sstream>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 661 matching lines @@
 
     // Confirm the downloaded data file exists.
     bool downloaded_file_exists = base::PathExists(downloaded_file);
     EXPECT_TRUE(downloaded_file_exists) << downloaded_file.value();
     if (!downloaded_file_exists)
       return false;
 
     int64 origin_file_size = 0;
     EXPECT_TRUE(file_util::GetFileSize(origin_file, &origin_file_size));
     std::string original_file_contents;
-    EXPECT_TRUE(
-        file_util::ReadFileToString(origin_file, &original_file_contents));
+    EXPECT_TRUE(base::ReadFileToString(origin_file, &original_file_contents));
     EXPECT_TRUE(
         VerifyFile(downloaded_file, original_file_contents, origin_file_size));
 
     // Delete the downloaded copy of the file.
     bool downloaded_file_deleted =
         file_util::DieFileDie(downloaded_file, false);
     EXPECT_TRUE(downloaded_file_deleted);
     return downloaded_file_deleted;
   }
 
@@ skipping 130 matching lines @@
     return file_activity_observer_->TestAndResetDidShowFileChooser();
   }
 
   // Checks that |path| is has |file_size| bytes, and matches the |value|
   // string.
   bool VerifyFile(const base::FilePath& path,
                   const std::string& value,
                   const int64 file_size) {
     std::string file_contents;
 
-    bool read = file_util::ReadFileToString(path, &file_contents);
+    bool read = base::ReadFileToString(path, &file_contents);
     EXPECT_TRUE(read) << "Failed reading file: " << path.value() << std::endl;
     if (!read)
       return false;  // Couldn't read the file.
 
     // Note: we don't handle really large files (more than size_t can hold)
     // so we will fail in that case.
     size_t expected_size = static_cast<size_t>(file_size);
 
     // Check the size.
     EXPECT_EQ(expected_size, file_contents.size());
@@ skipping 623 matching lines @@
   GURL url(test_server()->GetURL("files/downloads/a_zip_file.zip"));
 
   // Read the origin file now so that we can compare the downloaded files to it
   // later.
   base::FilePath origin(OriginFile(base::FilePath(FILE_PATH_LITERAL(
       "downloads/a_zip_file.zip"))));
   ASSERT_TRUE(base::PathExists(origin));
   int64 origin_file_size = 0;
   EXPECT_TRUE(file_util::GetFileSize(origin, &origin_file_size));
   std::string original_contents;
-  EXPECT_TRUE(file_util::ReadFileToString(origin, &original_contents));
+  EXPECT_TRUE(base::ReadFileToString(origin, &original_contents));
 
   std::vector<DownloadItem*> download_items;
   GetDownloads(browser(), &download_items);
   ASSERT_TRUE(download_items.empty());
 
   // Download a file in the on-record browser and check that it was downloaded
   // correctly.
   DownloadAndWaitWithDisposition(browser(),
                                  url,
                                  CURRENT_TAB,
@@ skipping 1350 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_Renaming) {
   ASSERT_TRUE(test_server()->Start());
   GURL url(test_server()->GetURL("files/downloads/a_zip_file.zip"));
   content::DownloadManager* manager = DownloadManagerForBrowser(browser());
   base::FilePath origin_file(OriginFile(base::FilePath(FILE_PATH_LITERAL(
       "downloads/a_zip_file.zip"))));
   ASSERT_TRUE(base::PathExists(origin_file));
   std::string origin_contents;
-  ASSERT_TRUE(file_util::ReadFileToString(origin_file, &origin_contents));
+  ASSERT_TRUE(base::ReadFileToString(origin_file, &origin_contents));
 
   // Download the same url several times and expect that all downloaded files
   // after the zero-th contain a deduplication counter.
   for (int index = 0; index < 5; ++index) {
     DownloadAndWait(browser(), url);
     EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
     content::DownloadItem* item = manager->GetDownload(
         content::DownloadItem::kInvalidId + 1 + index);
     ASSERT_TRUE(item);
     ASSERT_EQ(DownloadItem::COMPLETE, item->GetState());
@@ skipping 386 matching lines @@
 
   // No errors this time. The download should complete successfully.
   EXPECT_FALSE(completion_observer->IsFinished());
   completion_observer->StartObserving();
   download->Resume();
   completion_observer->WaitForFinished();
   EXPECT_EQ(DownloadItem::COMPLETE, download->GetState());
 
   EXPECT_FALSE(DidShowFileChooser());
 }