Persist download interrupt reason, both target and current paths, and url_chain.

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/file_path.h"
 #include "base/file_util.h"
@@ skipping 76 matching lines @@
 
 namespace {
 
 // IDs and paths of CRX files used in tests.
 const char kGoodCrxId[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
 const FilePath kGoodCrxPath(FILE_PATH_LITERAL("extensions/good.crx"));
 
 const char kLargeThemeCrxId[] = "pjpgmfcmabopnnfonnhmdjglfpjjfkbf";
 const FilePath kLargeThemePath(FILE_PATH_LITERAL("extensions/theme2.crx"));
 
+// Get History Information.
+class DownloadsHistoryDataCollector {
+ public:
+  explicit DownloadsHistoryDataCollector(Profile* profile)
+      : profile_(profile), result_valid_(false) {}
+
+  bool WaitForDownloadInfo(
+      scoped_ptr<std::vector<history::DownloadRow> >* results) {
+    HistoryService* hs = HistoryServiceFactory::GetForProfile(
+        profile_, Profile::EXPLICIT_ACCESS);
+    DCHECK(hs);
+    hs->QueryDownloads(
+        base::Bind(&DownloadsHistoryDataCollector::OnQueryDownloadsComplete,
+                   base::Unretained(this)));
+
+    content::RunMessageLoop();
+    if (result_valid_) {
+      *results = results_.Pass();
+    }
+    return result_valid_;
+  }
+
+ private:
+  void OnQueryDownloadsComplete(
+      scoped_ptr<std::vector<history::DownloadRow> > entries) {
+    result_valid_ = true;
+    results_ = entries.Pass();
+    MessageLoopForUI::current()->Quit();
+  }
+
+  Profile* profile_;
+  scoped_ptr<std::vector<history::DownloadRow> > results_;
+  bool result_valid_;
+  CancelableRequestConsumer callback_consumer_;
+
+  DISALLOW_COPY_AND_ASSIGN(DownloadsHistoryDataCollector);
+};
+
 // Mock that simulates a permissions dialog where the user denies
 // permission to install.  TODO(skerner): This could be shared with
 // extensions tests.  Find a common place for this class.
 class MockAbortExtensionInstallPrompt : public ExtensionInstallPrompt {
  public:
   MockAbortExtensionInstallPrompt() :
       ExtensionInstallPrompt(NULL) {
   }
 
   // Simulate a user abort on an extension installation.
@@ skipping 51 matching lines @@
 
 bool WasAutoOpened(DownloadItem* item) {
   return item->GetAutoOpened();
 }
 
 // Called when a download starts. Marks the download as hidden.
 void SetHiddenDownloadCallback(DownloadItem* item, net::Error error) {
   DownloadItemModel(item).SetShouldShowInShelf(false);
 }
 
+// Callback for HistoryObserver; used in DownloadHistoryCheck
+bool HasDataAndName(const history::DownloadRow& row) {
+  return row.received_bytes > 0 && !row.target_path.empty();
+}
+
 }  // namespace
 
 // While an object of this class exists, it will mock out download
 // opening for all downloads created on the specified download manager.
 class MockDownloadOpeningObserver : public DownloadManager::Observer {
  public:
   explicit MockDownloadOpeningObserver(DownloadManager* manager)
       : download_manager_(manager) {
     download_manager_->AddObserver(this);
   }
 
   ~MockDownloadOpeningObserver() {
     download_manager_->RemoveObserver(this);
   }
 
   virtual void OnDownloadCreated(
       DownloadManager* manager, DownloadItem* item) OVERRIDE {
     item->MockDownloadOpenForTesting();
   }
 
  private:
   DownloadManager* download_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(MockDownloadOpeningObserver);
 };
 
 class HistoryObserver : public DownloadHistory::Observer {
  public:
+  typedef base::Callback<bool(const history::DownloadRow&)> FilterCallback;
+
   explicit HistoryObserver(Profile* profile)
       : profile_(profile),
         waiting_(false),
         seen_stored_(false) {
     DownloadServiceFactory::GetForProfile(profile_)->
       GetDownloadHistory()->AddObserver(this);
   }
 
   virtual ~HistoryObserver() {
     DownloadService* service = DownloadServiceFactory::GetForProfile(profile_);
     if (service && service->GetDownloadHistory())
       service->GetDownloadHistory()->RemoveObserver(this);
   }
 
+  void SetFilterCallback(const FilterCallback& callback) {
+    callback_ = callback;
+  }
+
   virtual void OnDownloadStored(
       content::DownloadItem* item,
       const history::DownloadRow& info) OVERRIDE {
+    if (!callback_.is_null() && (!callback_.Run(info)))
+        return;
+
     seen_stored_ = true;
     if (waiting_)
       MessageLoopForUI::current()->Quit();
   }
 
   virtual void OnDownloadHistoryDestroyed() OVERRIDE {
     DownloadServiceFactory::GetForProfile(profile_)->
       GetDownloadHistory()->RemoveObserver(this);
   }
 
   void WaitForStored() {
     if (seen_stored_)
       return;
     waiting_ = true;
     content::RunMessageLoop();
     waiting_ = false;
   }
 
  private:
   Profile* profile_;
   bool waiting_;
   bool seen_stored_;
+  FilterCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryObserver);
 };
 
 class DownloadTest : public InProcessBrowserTest {
  public:
   // Choice of navigation or direct fetch.  Used by |DownloadFileCheckErrors()|.
   enum DownloadMethod {
     DOWNLOAD_NAVIGATE,
     DOWNLOAD_DIRECT
@@ skipping 69 matching lines @@
     SIZE_TEST_TYPE_UNKNOWN,
   };
 
   // Location of the file source (the place from which it is downloaded).
   FilePath OriginFile(FilePath file) {
     return test_dir_.Append(file);
   }
 
   // Location of the file destination (place to which it is downloaded).
   FilePath DestinationFile(Browser* browser, FilePath file) {
-    return GetDownloadDirectory(browser).Append(file);
+    return GetDownloadDirectory(browser).Append(file.BaseName());
   }
 
   // Must be called after browser creation.  Creates a temporary
   // directory for downloads that is auto-deleted on destruction.
   // Returning false indicates a failure of the function, and should be asserted
   // in the caller.
   bool CreateAndSetDownloadsDirectory(Browser* browser) {
     if (!browser)
       return false;
 
@@ skipping 1061 matching lines @@
 #endif
 
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   // Download shelf should close. Download panel stays open on ChromeOS.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 
   CheckDownload(browser(), file, file);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadHistoryCheck) {
-  FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
+  GURL download_url(URLRequestSlowDownloadJob::kKnownSizeUrl);
+  FilePath file(net::GenerateFileName(download_url, "", "", "", "", ""));
+
+  // We use the server so that we can get a redirect and test url_chain
+  // persistence.
+  ASSERT_TRUE(test_server()->Start());
+  GURL redirect_url = test_server()->GetURL(
+      "server-redirect?" + download_url.spec());
+
+  // Download the url and wait until the object has been stored.
+  base::Time start(base::Time::Now());
+  HistoryObserver observer(browser()->profile());
+  observer.SetFilterCallback(base::Bind(&HasDataAndName));
+  ui_test_utils::NavigateToURL(browser(), redirect_url);
+  observer.WaitForStored();
+
+  // Get the details on what was stored into the history.
+  scoped_ptr<std::vector<history::DownloadRow> > downloads_in_database;
+  ASSERT_TRUE(DownloadsHistoryDataCollector(
+      browser()->profile()).WaitForDownloadInfo(&downloads_in_database));
+  ASSERT_EQ(1u, downloads_in_database->size());
+
+  // Confirm history storage is what you expect for a partially completed
+  // slow download job.
+  history::DownloadRow& row(downloads_in_database->at(0));
+  EXPECT_EQ(DestinationFile(browser(), file), row.target_path);
+  EXPECT_EQ(download_util::GetCrDownloadPath(DestinationFile(browser(), file)),
+            row.current_path);
+  ASSERT_EQ(2u, row.url_chain.size());
+  EXPECT_EQ(redirect_url.spec(), row.url_chain[0].spec());
+  EXPECT_EQ(download_url.spec(), row.url_chain[1].spec());
+  EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, row.danger_type);
+  EXPECT_LE(start, row.start_time);
+  EXPECT_EQ(URLRequestSlowDownloadJob::kFirstDownloadSize, row.received_bytes);
+  EXPECT_EQ(URLRequestSlowDownloadJob::kFirstDownloadSize
+            + URLRequestSlowDownloadJob::kSecondDownloadSize, row.total_bytes);
+  EXPECT_EQ(content::DownloadItem::IN_PROGRESS, row.state);
+  EXPECT_FALSE(row.opened);
+
+  // Finish the download.  We're ok relying on the history to be flushed
+  // at this point as our queries will be behind the history updates
+  // invoked by completion.
+  scoped_ptr<content::DownloadTestObserver> download_observer(
+      CreateWaiter(browser(), 1));
+  ui_test_utils::NavigateToURL(browser(),
+      GURL(URLRequestSlowDownloadJob::kErrorDownloadUrl));
+  download_observer->WaitForFinished();
+  EXPECT_EQ(1u, download_observer->NumDownloadsSeenInState(
+      DownloadItem::INTERRUPTED));
+  base::Time end(base::Time::Now());
+
+  // Get what was stored in the history.
+  ASSERT_TRUE(DownloadsHistoryDataCollector(
+      browser()->profile()).WaitForDownloadInfo(&downloads_in_database));
+  ASSERT_EQ(1u, downloads_in_database->size());
+
+  // Confirm history storage is what you expect for a completed
+  // slow download job.
+  history::DownloadRow& row1(downloads_in_database->at(0));
+  EXPECT_EQ(DestinationFile(browser(), file), row1.target_path);
+  EXPECT_EQ(download_util::GetCrDownloadPath(DestinationFile(browser(), file)),
+            row1.current_path);
+  ASSERT_EQ(2u, row1.url_chain.size());
+  EXPECT_EQ(redirect_url.spec(), row1.url_chain[0].spec());
+  EXPECT_EQ(download_url.spec(), row1.url_chain[1].spec());
+  EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, row1.danger_type);
+  EXPECT_LE(start, row1.start_time);
+  EXPECT_GE(end, row1.end_time);
+  EXPECT_EQ(URLRequestSlowDownloadJob::kFirstDownloadSize,
+            row1.received_bytes);
+  EXPECT_EQ(URLRequestSlowDownloadJob::kFirstDownloadSize
+            + URLRequestSlowDownloadJob::kSecondDownloadSize, row1.total_bytes);
+  EXPECT_EQ(content::DownloadItem::INTERRUPTED, row1.state);
+  EXPECT_EQ(content::DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED,
+            row1.interrupt_reason);
+  EXPECT_FALSE(row1.opened);
+}
+
+// Make sure a dangerous file shows up properly in the history.
+IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadHistoryDangerCheck) {
+  FilePath file(FILE_PATH_LITERAL("downloads/dangerous/dangerous.jar"));
   GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
+
+  // Download the url and wait until the object has been stored.
+  scoped_ptr<content::DownloadTestObserver> download_observer(
+      new content::DownloadTestObserverTerminal(
+          DownloadManagerForBrowser(browser()), 1,
+          content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_IGNORE));
+  base::Time start(base::Time::Now());
   HistoryObserver observer(browser()->profile());
-  DownloadAndWait(browser(), download_url);
+  observer.SetFilterCallback(base::Bind(&HasDataAndName));
+  ui_test_utils::NavigateToURL(browser(), download_url);
   observer.WaitForStored();
+
+  // Get the details on what was stored into the history.
+  scoped_ptr<std::vector<history::DownloadRow> > downloads_in_database;
+  ASSERT_TRUE(DownloadsHistoryDataCollector(
+      browser()->profile()).WaitForDownloadInfo(&downloads_in_database));
+  ASSERT_EQ(1u, downloads_in_database->size());
+
+  // Confirm history storage is what you expect for an unvalidated
+  // dangerous file.
+  history::DownloadRow& row(downloads_in_database->at(0));
+  EXPECT_EQ(DestinationFile(browser(), file), row.target_path);
+  EXPECT_NE(download_util::GetCrDownloadPath(DestinationFile(browser(), file)),
+            row.current_path);
+  EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE, row.danger_type);
+  EXPECT_LE(start, row.start_time);
+  EXPECT_EQ(content::DownloadItem::IN_PROGRESS, row.state);
+  EXPECT_FALSE(row.opened);
+
+  // Validate the download and wait for it to finish.
+  std::vector<DownloadItem*> downloads;
+  DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
+  ASSERT_EQ(1u, downloads.size());
+  downloads[0]->DangerousDownloadValidated();
+  download_observer->WaitForFinished();
+
+  // Get history details and confirm it's what you expect.
+  downloads_in_database->clear();
+  ASSERT_TRUE(DownloadsHistoryDataCollector(
+      browser()->profile()).WaitForDownloadInfo(&downloads_in_database));
+  ASSERT_EQ(1u, downloads_in_database->size());
+  history::DownloadRow& row1(downloads_in_database->at(0));
+  EXPECT_EQ(DestinationFile(browser(), file), row1.target_path);
+  EXPECT_EQ(DestinationFile(browser(), file), row1.current_path);
+  EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED, row1.danger_type);
+  EXPECT_LE(start, row1.start_time);
+  EXPECT_EQ(content::DownloadItem::COMPLETE, row1.state);
+  EXPECT_FALSE(row1.opened);
+  EXPECT_EQ(439u, row1.received_bytes);
+  EXPECT_EQ(439u, row1.total_bytes);
 }
 
 // Test for crbug.com/14505. This tests that chrome:// urls are still functional
 // after download of a file while viewing another chrome://.
 IN_PROC_BROWSER_TEST_F(DownloadTest, ChromeURLAfterDownload) {
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
   GURL flags_url(chrome::kChromeUIFlagsURL);
   GURL extensions_url(chrome::kChromeUIExtensionsFrameURL);
 
@@ skipping 804 matching lines @@
   WebContents* web_contents = chrome::GetActiveWebContents(browser());
   scoped_ptr<DownloadUrlParameters> params(
       DownloadUrlParameters::FromWebContents(web_contents, url));
   params->set_callback(base::Bind(&SetHiddenDownloadCallback));
   download_manager->DownloadUrl(params.Pass());
   observer->WaitForFinished();
 
   // Verify that download shelf is not shown.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 }