Split DownloadItem into an ABC, an Impl, and a Mock.

chrome/browser/download/download_browsertest.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
@@ skipping 588 matching lines @@
 #endif  // defined(TOUCH_UI)
 
     ASSERT_TRUE(downloads_ui);
     const ActiveDownloadsUI::DownloadList& downloads =
         downloads_ui->GetDownloads();
     EXPECT_EQ(downloads.size(), 1U);
 
     FilePath full_path(DestinationFile(browser, filename));
     bool exists = false;
     for (size_t i = 0; i < downloads.size(); ++i) {
-      if (downloads[i]->full_path() == full_path) {
+      if (downloads[i]->GetFullPath() == full_path) {
         exists = true;
         break;
       }
     }
     EXPECT_TRUE(exists);
 #else
     EXPECT_EQ(expected_non_cros, browser->window()->IsDownloadShelfVisible());
     // TODO: Check for filename match in download shelf.
 #endif
   }
@@ skipping 540 matching lines @@
   scoped_ptr<DownloadTestObserver> observer1(
       CreateInProgressWaiter(browser(), 1));
   ui_test_utils::NavigateToURL(
       browser(), GURL(URLRequestSlowDownloadJob::kUnknownSizeUrl));
   observer1->WaitForFinished();
 
   std::vector<DownloadItem*> downloads;
   browser()->profile()->GetDownloadManager()->SearchDownloads(
       string16(), &downloads);
   ASSERT_EQ(1u, downloads.size());
-  ASSERT_EQ(DownloadItem::IN_PROGRESS, downloads[0]->state());
+  ASSERT_EQ(DownloadItem::IN_PROGRESS, downloads[0]->GetState());
   CheckDownloadUI(browser(), true, true, FilePath());
   DownloadItem* download1 = downloads[0];  // The only download.
 
   // Start the second download and wait until it's done.
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   // Download the file and wait.  We do not expect the Select File dialog.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   // Should now have 2 items on the download shelf.
   downloads.clear();
   browser()->profile()->GetDownloadManager()->SearchDownloads(
       string16(), &downloads);
   ASSERT_EQ(2u, downloads.size());
   // We don't know the order of the downloads.
   DownloadItem* download2 = downloads[(download1 == downloads[0]) ? 1 : 0];
 
-  ASSERT_EQ(DownloadItem::IN_PROGRESS, download1->state());
-  ASSERT_EQ(DownloadItem::COMPLETE, download2->state());
+  ASSERT_EQ(DownloadItem::IN_PROGRESS, download1->GetState());
+  ASSERT_EQ(DownloadItem::COMPLETE, download2->GetState());
   // The download shelf should be open.
   CheckDownloadUI(browser(), true, true, FilePath());
 
   // Allow the first request to finish.  We do this by loading a third URL
   // in a separate tab.
   scoped_ptr<DownloadTestObserver> observer2(CreateWaiter(browser(), 1));
   GURL finish_url(URLRequestSlowDownloadJob::kFinishDownloadUrl);
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       finish_url,
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   observer2->WaitForFinished();  // Wait for the third request.
 
   // Get the important info from other threads and check it.
   scoped_refptr<CancelTestDataCollector> info(new CancelTestDataCollector());
   info->WaitForDataCollected();
   EXPECT_EQ(0, info->dfm_pending_downloads());
 
   CheckDownloadUI(browser(), true, true, FilePath());
 
   // The |DownloadItem|s should now be done and have the final file names.
   // Verify that the files have the expected data and size.
   // |file1| should be full of '*'s, and |file2| should be the same as the
   // source file.
-  FilePath file1(download1->full_path());
+  FilePath file1(download1->GetFullPath());
   size_t file_size1 = URLRequestSlowDownloadJob::kFirstDownloadSize +
                       URLRequestSlowDownloadJob::kSecondDownloadSize;
   std::string expected_contents(file_size1, '*');
   ASSERT_TRUE(VerifyFile(file1, expected_contents, file_size1));
 
-  FilePath file2(download2->full_path());
+  FilePath file2(download2->GetFullPath());
   ASSERT_TRUE(file_util::ContentsEqual(OriginFile(file), file2));
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadCancelled) {
   ASSERT_TRUE(InitialSetup(false));
   EXPECT_EQ(1, browser()->tab_count());
 
   // TODO(rdsmith): Fragile code warning!  The code below relies on the
   // DownloadTestObserver only finishing when the new download has reached
   // the state of being entered into the history and being user-visible
@@ skipping 15 matching lines @@
   scoped_ptr<DownloadTestObserver> observer(
       CreateInProgressWaiter(browser(), 1));
   ui_test_utils::NavigateToURL(
       browser(), GURL(URLRequestSlowDownloadJob::kUnknownSizeUrl));
   observer->WaitForFinished();
 
   std::vector<DownloadItem*> downloads;
   DownloadManagerForBrowser(browser())->SearchDownloads(
       string16(), &downloads);
   ASSERT_EQ(1u, downloads.size());
-  ASSERT_EQ(DownloadItem::IN_PROGRESS, downloads[0]->state());
+  ASSERT_EQ(DownloadItem::IN_PROGRESS, downloads[0]->GetState());
   CheckDownloadUI(browser(), true, true, FilePath());
 
   // Cancel the download and wait for download system quiesce.
   downloads[0]->Delete(DownloadItem::DELETE_DUE_TO_USER_DISCARD);
   scoped_refptr<DownloadTestFlushObserver> flush_observer(
       new DownloadTestFlushObserver(
           DownloadManagerForBrowser(browser())));
   flush_observer->WaitForFlush();
 
   // Get the important info from other threads and check it.
@@ skipping 17 matching lines @@
   int64 origin_size;
   file_util::GetFileSize(origin_file, &origin_size);
 
   // Download the file and wait.  We do not expect the Select File dialog.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   // Get details of what downloads have just happened.
   std::vector<DownloadItem*> downloads;
   GetDownloads(browser(), &downloads);
   ASSERT_EQ(1u, downloads.size());
-  int64 db_handle = downloads[0]->db_handle();
+  int64 db_handle = downloads[0]->GetDbHandle();
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
   CheckDownloadUI(browser(), true, true, file);
 
   // Check history results.
   DownloadsHistoryDataCollector history_collector(
       db_handle,
       DownloadManagerForBrowser(browser()));
@@ skipping 92 matching lines @@
   MockDownloadOpeningObserver observer(
       DownloadManagerForBrowser(browser()));
 
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   // Find the download and confirm it was opened.
   std::vector<DownloadItem*> downloads;
   DownloadManagerForBrowser(browser())->SearchDownloads(
       string16(), &downloads);
   ASSERT_EQ(1u, downloads.size());
-  EXPECT_EQ(DownloadItem::COMPLETE, downloads[0]->state());
-  EXPECT_TRUE(downloads[0]->opened());
+  EXPECT_EQ(DownloadItem::COMPLETE, downloads[0]->GetState());
+  EXPECT_TRUE(downloads[0]->GetOpened());
 
   // As long as we're here, confirmed everything else is good.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
   // Download shelf should close. Download panel stays open on ChromeOS.
   CheckDownloadUI(browser(), false, true, FilePath());
 }
 
 // Download an extension.  Expect a dangerous download warning.
 // Deny the download.
@@ skipping 126 matching lines @@
   CheckDownloadUI(browser(), false, true, FilePath());
 
   // Check that the extension was installed.
   ExtensionService* extension_service =
       browser()->profile()->GetExtensionService();
   ASSERT_TRUE(extension_service->GetExtensionById(kLargeThemeCrxId, false));
 }
 
 // Sort download items by db_handle.
 static bool DownloadItemSorter(DownloadItem* d1, DownloadItem* d2) {
-  return d1->db_handle() < d2->db_handle();
+  return d1->GetDbHandle() < d2->GetDbHandle();
 }
 
 // Confirm that searching through the history works properly
 IN_PROC_BROWSER_TEST_F(DownloadTest, SearchDownloads) {
   ASSERT_TRUE(InitialSetup(false));
 
   // Downloads to populate history with.
   base::Time current(base::Time::Now());
   DownloadPersistentStoreInfo population_entries[] = {
     DownloadPersistentStoreInfo(
@@ skipping 43 matching lines @@
   manager->SearchDownloads(string16(), &search_results);
   ASSERT_EQ(3u, search_results.size());
   std::sort(search_results.begin(), search_results.end(),
             DownloadItemSorter);
   // We do a full check only once to protect against the data
   // somehow getting scrambled on its way into the DownloadItems.
   {
     DownloadItem* d1 = search_results[0];
     DownloadItem* d2 = search_results[1];
     DownloadItem* d3 = search_results[2];
-    EXPECT_EQ(FilePath(FILE_PATH_LITERAL("/path/to/file")), d1->full_path());
+    EXPECT_EQ(FilePath(FILE_PATH_LITERAL("/path/to/file")), d1->GetFullPath());
     EXPECT_EQ(GURL("http://www.google.com/fantasy_download"),
-              d1->original_url());
+              d1->GetOriginalUrl());
     EXPECT_EQ(current - base::TimeDelta::FromMinutes(5),
-              d1->start_time());
-    EXPECT_EQ(current, d1->end_time());
-    EXPECT_EQ(128, d1->received_bytes());
-    EXPECT_EQ(128, d1->total_bytes());
-    EXPECT_EQ(DownloadItem::COMPLETE, d1->state());
-    EXPECT_EQ(1, d1->db_handle());
-    EXPECT_FALSE(d1->opened());
+              d1->GetStartTime());
+    EXPECT_EQ(current, d1->GetEndTime());
+    EXPECT_EQ(128, d1->GetReceivedBytes());
+    EXPECT_EQ(128, d1->GetTotalBytes());
+    EXPECT_EQ(DownloadItem::COMPLETE, d1->GetState());
+    EXPECT_EQ(1, d1->GetDbHandle());
+    EXPECT_FALSE(d1->GetOpened());
 
     EXPECT_EQ(FilePath(FILE_PATH_LITERAL("/path/to/another_file")),
-              d2->full_path());
+              d2->GetFullPath());
     EXPECT_EQ(GURL("http://www.google.com/reality_download"),
-              d2->original_url());
+              d2->GetOriginalUrl());
     EXPECT_EQ(current - base::TimeDelta::FromMinutes(10),
-              d2->start_time());
-    EXPECT_EQ(current, d2->end_time());
-    EXPECT_EQ(256, d2->received_bytes());
-    EXPECT_EQ(256, d2->total_bytes());
-    EXPECT_EQ(DownloadItem::COMPLETE, d2->state());
-    EXPECT_EQ(2, d2->db_handle());
-    EXPECT_FALSE(d2->opened());
+              d2->GetStartTime());
+    EXPECT_EQ(current, d2->GetEndTime());
+    EXPECT_EQ(256, d2->GetReceivedBytes());
+    EXPECT_EQ(256, d2->GetTotalBytes());
+    EXPECT_EQ(DownloadItem::COMPLETE, d2->GetState());
+    EXPECT_EQ(2, d2->GetDbHandle());
+    EXPECT_FALSE(d2->GetOpened());
 
     EXPECT_EQ(FilePath(FILE_PATH_LITERAL("/different_path/to/another_file")),
-              d3->full_path());
+              d3->GetFullPath());
     EXPECT_EQ(GURL("http://www.izzle.com/not_really_a_download"),
-              d3->original_url());
+              d3->GetOriginalUrl());
     EXPECT_EQ(current - base::TimeDelta::FromMinutes(15),
-              d3->start_time());
-    EXPECT_EQ(current, d3->end_time());
-    EXPECT_EQ(512, d3->received_bytes());
-    EXPECT_EQ(512, d3->total_bytes());
-    EXPECT_EQ(DownloadItem::COMPLETE, d3->state());
-    EXPECT_EQ(3, d3->db_handle());
-    EXPECT_TRUE(d3->opened());
+              d3->GetStartTime());
+    EXPECT_EQ(current, d3->GetEndTime());
+    EXPECT_EQ(512, d3->GetReceivedBytes());
+    EXPECT_EQ(512, d3->GetTotalBytes());
+    EXPECT_EQ(DownloadItem::COMPLETE, d3->GetState());
+    EXPECT_EQ(3, d3->GetDbHandle());
+    EXPECT_TRUE(d3->GetOpened());
   }
   search_results.clear();
 
   string16 search_input;
   manager->SearchDownloads(UTF8ToUTF16("www.google.com"), &search_results);
   ASSERT_EQ(2u, search_results.size());
   std::sort(search_results.begin(), search_results.end(),
             DownloadItemSorter);
-  EXPECT_EQ(1, search_results[0]->db_handle());
-  EXPECT_EQ(2, search_results[1]->db_handle());
+  EXPECT_EQ(1, search_results[0]->GetDbHandle());
+  EXPECT_EQ(2, search_results[1]->GetDbHandle());
   search_results.clear();
 
   manager->SearchDownloads(UTF8ToUTF16("real"), &search_results);
   ASSERT_EQ(2u, search_results.size());
   std::sort(search_results.begin(), search_results.end(),
             DownloadItemSorter);
-  EXPECT_EQ(2, search_results[0]->db_handle());
-  EXPECT_EQ(3, search_results[1]->db_handle());
+  EXPECT_EQ(2, search_results[0]->GetDbHandle());
+  EXPECT_EQ(3, search_results[1]->GetDbHandle());
   search_results.clear();
 
   manager->SearchDownloads(UTF8ToUTF16("another_file"), &search_results);
   ASSERT_EQ(2u, search_results.size());
   std::sort(search_results.begin(), search_results.end(),
             DownloadItemSorter);
-  EXPECT_EQ(2, search_results[0]->db_handle());
-  EXPECT_EQ(3, search_results[1]->db_handle());
+  EXPECT_EQ(2, search_results[0]->GetDbHandle());
+  EXPECT_EQ(3, search_results[1]->GetDbHandle());
   search_results.clear();
 }