Move PathExists to 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 642 matching lines @@
 
     // Find the origin path (from which the data comes).
     base::FilePath origin_file(OriginFile(origin_filename));
     return CheckDownloadFullPaths(browser, downloaded_file, origin_file);
   }
 
   // A version of CheckDownload that allows complete path specification.
   bool CheckDownloadFullPaths(Browser* browser,
                               const base::FilePath& downloaded_file,
                               const base::FilePath& origin_file) {
-    bool origin_file_exists = file_util::PathExists(origin_file);
+    bool origin_file_exists = base::PathExists(origin_file);
     EXPECT_TRUE(origin_file_exists) << origin_file.value();
     if (!origin_file_exists)
       return false;
 
     // Confirm the downloaded data file exists.
-    bool downloaded_file_exists = file_util::PathExists(downloaded_file);
+    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(
@@ skipping 96 matching lines @@
     EXPECT_EQ(2, browser->tab_strip_model()->count());
 
     // TODO(ahendrickson): check download status text after downloading.
 
     base::FilePath basefilename(filename.BaseName());
     net::FileURLToFilePath(url, &filename);
     base::FilePath download_path =
         downloads_directory_.path().Append(basefilename);
     EXPECT_TRUE(browser->window()->IsDownloadShelfVisible());
 
-    bool downloaded_path_exists = file_util::PathExists(download_path);
+    bool downloaded_path_exists = base::PathExists(download_path);
     EXPECT_TRUE(downloaded_path_exists);
     if (!downloaded_path_exists)
       return false;
 
     // Check the file contents.
     size_t file_size = URLRequestSlowDownloadJob::kFirstDownloadSize +
                        URLRequestSlowDownloadJob::kSecondDownloadSize;
     std::string expected_contents(file_size, '*');
     EXPECT_TRUE(VerifyFile(download_path, expected_contents, file_size));
 
     // Delete the file we just downloaded.
     EXPECT_TRUE(file_util::DieFileDie(download_path, true));
-    EXPECT_FALSE(file_util::PathExists(download_path));
+    EXPECT_FALSE(base::PathExists(download_path));
 
     return true;
   }
 
   void GetDownloads(Browser* browser, std::vector<DownloadItem*>* downloads) {
     DCHECK(downloads);
     DownloadManager* manager = DownloadManagerForBrowser(browser);
     manager->GetAllDownloads(downloads);
   }
 
@@ skipping 141 matching lines @@
       }
 
       ASSERT_EQ(url, item->GetOriginalUrl()) << s.str();
 
       ASSERT_EQ(download_info.reason, item->GetLastReason()) << s.str();
 
       if (item->GetState() == content::DownloadItem::COMPLETE) {
         // Clean up the file, in case it ended up in the My Documents folder.
         base::FilePath destination_folder = GetDownloadDirectory(browser());
         base::FilePath my_downloaded_file = item->GetTargetFilePath();
-        EXPECT_TRUE(file_util::PathExists(my_downloaded_file));
+        EXPECT_TRUE(base::PathExists(my_downloaded_file));
         EXPECT_TRUE(base::Delete(my_downloaded_file, false));
 
         EXPECT_EQ(download_info.should_redirect_to_documents ?
                       std::string::npos :
                       0u,
                   my_downloaded_file.value().find(destination_folder.value()));
         if (download_info.should_redirect_to_documents) {
           // If it's not where we asked it to be, it should be in the
           // My Documents folder.
           base::FilePath my_docs_folder;
@@ skipping 230 matching lines @@
 // did not initiate.
 IN_PROC_BROWSER_TEST_F(DownloadTest, NoDownload) {
   base::FilePath file(FILE_PATH_LITERAL("download-test2.html"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   base::FilePath file_path(DestinationFile(browser(), file));
 
   // Open a web page and wait.
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Check that we did not download the web page.
-  EXPECT_FALSE(file_util::PathExists(file_path));
+  EXPECT_FALSE(base::PathExists(file_path));
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, MimeTypesToShowNotDownload) {
   ASSERT_TRUE(test_server()->Start());
 
   // These files should all be displayed in the browser.
@@ skipping 65 matching lines @@
       &download_assempted));
   ASSERT_TRUE(download_assempted);
   observer.WaitForObservation(
       base::Bind(&content::RunMessageLoop),
       base::Bind(&base::MessageLoop::Quit,
                  base::Unretained(base::MessageLoopForUI::current())));
 
   // Check that we did not download the file.
   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   base::FilePath file_path(DestinationFile(browser(), file));
-  EXPECT_FALSE(file_util::PathExists(file_path));
+  EXPECT_FALSE(base::PathExists(file_path));
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 
   // Verify that there's no pending download.  The resource throttle
   // should have deleted it before it created a download item, so it
   // shouldn't be available as a cancelled download either.
   DownloadManagerForBrowser(browser())->GetAllDownloads(&items);
   EXPECT_EQ(0u, items.size());
@@ skipping 148 matching lines @@
 // bug; this next test tests that filename deduplication happens independently
 // of DownloadManager/CDMD.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_IncognitoRegular) {
   ASSERT_TRUE(test_server()->Start());
   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(file_util::PathExists(origin));
+  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));
 
   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,
                                  ui_test_utils::BROWSER_TEST_NONE);
   EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
   GetDownloads(browser(), &download_items);
   ASSERT_EQ(1UL, download_items.size());
   ASSERT_EQ(base::FilePath(FILE_PATH_LITERAL("a_zip_file.zip")),
             download_items[0]->GetTargetFilePath().BaseName());
-  ASSERT_TRUE(file_util::PathExists(download_items[0]->GetTargetFilePath()));
+  ASSERT_TRUE(base::PathExists(download_items[0]->GetTargetFilePath()));
   EXPECT_TRUE(VerifyFile(download_items[0]->GetTargetFilePath(),
                          original_contents, origin_file_size));
 
   // Setup an incognito window.
   Browser* incognito = CreateIncognitoBrowser();
   ASSERT_TRUE(incognito);
   int window_count = BrowserList::GetInstance(
       browser()->host_desktop_type())->size();
   EXPECT_EQ(2, window_count);
   incognito->profile()->GetPrefs()->SetFilePath(
@@ skipping 11 matching lines @@
   // correctly.
   DownloadAndWaitWithDisposition(incognito,
                                  url,
                                  CURRENT_TAB,
                                  ui_test_utils::BROWSER_TEST_NONE);
   EXPECT_TRUE(incognito->window()->IsDownloadShelfVisible());
   GetDownloads(incognito, &download_items);
   ASSERT_EQ(1UL, download_items.size());
   ASSERT_EQ(base::FilePath(FILE_PATH_LITERAL("a_zip_file (1).zip")),
             download_items[0]->GetTargetFilePath().BaseName());
-  ASSERT_TRUE(file_util::PathExists(download_items[0]->GetTargetFilePath()));
+  ASSERT_TRUE(base::PathExists(download_items[0]->GetTargetFilePath()));
   EXPECT_TRUE(VerifyFile(download_items[0]->GetTargetFilePath(),
                          original_contents, origin_file_size));
 }
 
 // Navigate to a new background page, but don't download.  Confirm that the
 // download shelf is not visible and that we have two tabs.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DontCloseNewTab1) {
   // Because it's an HTML link, it should open a web page rather than
   // downloading.
   base::FilePath file1(FILE_PATH_LITERAL("download-test2.html"));
@@ skipping 472 matching lines @@
   scoped_ptr<content::DownloadTestObserver> observer(
       CreateWaiter(browser(), 1));
   ui_test_utils::NavigateToURL(browser(), url);
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
   CheckDownloadStates(1, DownloadItem::COMPLETE);
 
   // Confirm the downloaded data exists.
   base::FilePath downloaded_file = GetDownloadDirectory(browser());
   downloaded_file = downloaded_file.Append(FILE_PATH_LITERAL("a_red_dot.png"));
-  EXPECT_TRUE(file_util::PathExists(downloaded_file));
+  EXPECT_TRUE(base::PathExists(downloaded_file));
 }
 
 // Test to make sure auto-open works.
 IN_PROC_BROWSER_TEST_F(DownloadTest, AutoOpen) {
   base::FilePath file(FILE_PATH_LITERAL("download-autoopen.txt"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   ASSERT_TRUE(
       GetDownloadPrefs(browser())->EnableAutoOpenBasedOnExtension(file));
 
@@ skipping 788 matching lines @@
   EXPECT_EQ(2u, downloads_observer->NumDownloadsSeenInState(
       DownloadItem::COMPLETE));
 }
 
 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(file_util::PathExists(origin_file));
+  ASSERT_TRUE(base::PathExists(origin_file));
   std::string origin_contents;
   ASSERT_TRUE(file_util::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(index);
     ASSERT_TRUE(item);
     ASSERT_EQ(DownloadItem::COMPLETE, item->GetState());
     base::FilePath target_path(item->GetTargetFilePath());
     EXPECT_EQ(std::string("a_zip_file") +
         (index == 0 ? std::string(".zip") :
                       base::StringPrintf(" (%d).zip", index)),
               target_path.BaseName().AsUTF8Unsafe());
-    ASSERT_TRUE(file_util::PathExists(target_path));
+    ASSERT_TRUE(base::PathExists(target_path));
     ASSERT_TRUE(VerifyFile(target_path, origin_contents,
                            origin_contents.size()));
   }
 }
 
 // Test that the entire download pipeline handles unicode correctly.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_CrazyFilenames) {
   const wchar_t* kCrazyFilenames[] = {
     L"a_file_name.zip",
     L"\u89c6\u9891\u76f4\u64ad\u56fe\u7247.zip",  // chinese chars
@@ skipping 164 matching lines @@
 
   // Wait for the download to complete, checking along the way that the
   // PercentComplete() never regresses.
   PercentWaiter waiter(download_items[0]);
   EXPECT_TRUE(waiter.WaitForFinished());
   EXPECT_EQ(DownloadItem::COMPLETE, download_items[0]->GetState());
   ASSERT_EQ(100, download_items[0]->PercentComplete());
   EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
 
   // Check that the file downloaded correctly.
-  ASSERT_TRUE(file_util::PathExists(download_items[0]->GetTargetFilePath()));
+  ASSERT_TRUE(base::PathExists(download_items[0]->GetTargetFilePath()));
   int64 downloaded_size = 0;
   ASSERT_TRUE(file_util::GetFileSize(
       download_items[0]->GetTargetFilePath(), &downloaded_size));
 #if defined(OS_WIN)
   ASSERT_EQ(1, downloaded_size);
 #else
   ASSERT_EQ(size + 1, downloaded_size);
 #endif
   ASSERT_TRUE(file_util::DieFileDie(file_path, false));
   ASSERT_TRUE(file_util::DieFileDie(download_items[0]->GetTargetFilePath(),
@@ skipping 185 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());
 }