[Downloads] Gracefully handle SafeBrowsing check failures.

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/files/file.h"
@@ skipping 29 matching lines @@
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/history/download_row.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_context_menu/render_view_context_menu_browsertest_util.h"
 #include "chrome/browser/renderer_context_menu/render_view_context_menu_test_util.h"
-#include "chrome/browser/safe_browsing/download_feedback_service.h"
-#include "chrome/browser/safe_browsing/download_protection_service.h"
-#include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 25 matching lines @@
 #include "content/public/test/test_navigation_observer.h"
 #include "content/test/net/url_request_slow_download_job.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/feature_switch.h"
 #include "net/base/filename_util.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/test/url_request/url_request_mock_http_job.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
+#if defined(FULL_SAFE_BROWSING)
+#include "chrome/browser/safe_browsing/download_feedback_service.h"
+#include "chrome/browser/safe_browsing/download_protection_service.h"
+#include "chrome/browser/safe_browsing/safe_browsing_database.h"
+#include "chrome/browser/safe_browsing/safe_browsing_service.h"
+#endif
+
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DownloadItem;
 using content::DownloadManager;
 using content::DownloadUrlParameters;
 using content::URLRequestSlowDownloadJob;
 using content::WebContents;
 using extensions::Extension;
 using extensions::FeatureSwitch;
 using net::URLRequestMockHTTPJob;
@@ skipping 457 matching lines @@
         download_manager, num_downloads);
   }
 
   // Create a DownloadTestObserverTerminal that will wait for the
   // specified number of downloads to finish, or for
   // a dangerous download warning to be shown.
   content::DownloadTestObserver* DangerousDownloadWaiter(
       Browser* browser,
       int num_downloads,
       content::DownloadTestObserver::DangerousDownloadAction
-      dangerous_download_action) {
+          dangerous_download_action) {
     DownloadManager* download_manager = DownloadManagerForBrowser(browser);
     return new content::DownloadTestObserverTerminal(
-        download_manager, num_downloads,
-        dangerous_download_action);
+        download_manager, num_downloads, dangerous_download_action);
   }
 
   void CheckDownloadStatesForBrowser(Browser* browser,
                                      size_t num,
                                      DownloadItem::DownloadState state) {
     std::vector<DownloadItem*> download_items;
     GetDownloads(browser, &download_items);
 
     EXPECT_EQ(num, download_items.size());
 
@@ skipping 1317 matching lines @@
   DownloadAndWait(browser(), download_url);
   observer.WaitForStored();
   HistoryServiceFactory::GetForProfile(
       browser()->profile(), Profile::IMPLICIT_ACCESS)->FlushForTest(
       base::Bind(&base::MessageLoop::Quit,
                  base::Unretained(base::MessageLoop::current()->current())));
   content::RunMessageLoop();
 }
 
 #if defined(OS_CHROMEOS)
+// Times out on ChromeOS: http://crbug.com/217810
 #define MAYBE_DownloadTest_History DISABLED_DownloadTest_History
 #else
 #define MAYBE_DownloadTest_History DownloadTest_History
 #endif
 IN_PROC_BROWSER_TEST_F(DownloadTest, MAYBE_DownloadTest_History) {
   // This starts up right after PRE_DownloadTest_History and shares the same
   // profile directory.
   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
   std::vector<DownloadItem*> downloads;
@@ skipping 1409 matching lines @@
   GURL url(test_server()->GetURL("files/downloads/empty.bin"));
   // Downloading the same URL twice causes the second request to be served from
   // cached (with a high probability). This test verifies that that doesn't
   // happen regardless of whether the request is served via the cache or from
   // the network.
   DownloadAndWait(browser(), url);
   DownloadAndWait(browser(), url);
 }
 
 #if defined(FULL_SAFE_BROWSING)
+
+// The following two tests are only meaningful on OS_WIN since that's the only
+// platform where client download checks are currently performed.
+// TODO(asanka): Relax this restriction as other platforms are added.
+#if defined(OS_WIN)
+namespace {
+
+// This is a custom DownloadTestObserver for
+// DangerousFileWithSBDisabledBeforeCompletion test that disables the
+// SafeBrowsing service when a single download is IN_PROGRESS and has a target
+// path assigned.  DownloadItemImpl is expected to call MaybeCompleteDownload
+// soon afterwards and we want to disable the service before then.
+class DisableSafeBrowsingOnInProgressDownload
+    : public content::DownloadTestObserver {
+ public:
+  explicit DisableSafeBrowsingOnInProgressDownload(Browser* browser)
+      : DownloadTestObserver(DownloadManagerForBrowser(browser),
+                             1,
+                             ON_DANGEROUS_DOWNLOAD_QUIT),
+        browser_(browser),
+        final_state_seen_(false) {
+    Init();
+  }
+  virtual ~DisableSafeBrowsingOnInProgressDownload() {}
+
+  virtual bool IsDownloadInFinalState(DownloadItem* download) OVERRIDE {
+    if (download->GetState() != DownloadItem::IN_PROGRESS ||
+        download->GetTargetFilePath().empty())
+      return false;
+
+    if (final_state_seen_)
+      return true;
+
+    final_state_seen_ = true;
+    browser_->profile()->GetPrefs()->SetBoolean(prefs::kSafeBrowsingEnabled,
+                                                false);
+    EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
+              download->GetDangerType());
+    EXPECT_FALSE(download->IsDangerous());
+    EXPECT_TRUE(DownloadItemModel(download).IsDangerousFileBasedOnType());
+    return true;
+  }
+
+ private:
+  Browser* browser_;
+  bool final_state_seen_;
+};
+
+}  // namespace
+
+IN_PROC_BROWSER_TEST_F(DownloadTest,
+                       DangerousFileWithSBDisabledBeforeCompletion) {
+  browser()->profile()->GetPrefs()->SetBoolean(prefs::kSafeBrowsingEnabled,
+                                               true);
+  ASSERT_TRUE(test_server()->Start());
+  GURL download_url(
+      test_server()->GetURL("files/downloads/dangerous/dangerous.exe"));
+  scoped_ptr<content::DownloadTestObserver> dangerous_observer(
+      DangerousDownloadWaiter(
+          browser(),
+          1,
+          content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_QUIT));
+  scoped_ptr<content::DownloadTestObserver> in_progress_observer(
+      new DisableSafeBrowsingOnInProgressDownload(browser()));
+  ui_test_utils::NavigateToURLWithDisposition(browser(),
+                                              download_url,
+                                              NEW_BACKGROUND_TAB,
+                                              ui_test_utils::BROWSER_TEST_NONE);
+  in_progress_observer->WaitForFinished();
+
+  // SafeBrowsing should have been disabled by our observer.
+  ASSERT_FALSE(browser()->profile()->GetPrefs()->GetBoolean(
+      prefs::kSafeBrowsingEnabled));
+
+  std::vector<DownloadItem*> downloads;
+  DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
+  ASSERT_EQ(1u, downloads.size());
+  DownloadItem* download = downloads[0];
+
+  dangerous_observer->WaitForFinished();
+
+  EXPECT_TRUE(download->IsDangerous());
+  EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
+            download->GetDangerType());
+  download->Cancel(true);
+}
+
+IN_PROC_BROWSER_TEST_F(DownloadTest, DangerousFileWithSBDisabledBeforeStart) {
+  // Disable SafeBrowsing
+  browser()->profile()->GetPrefs()->SetBoolean(prefs::kSafeBrowsingEnabled,
+                                               false);
+
+  ASSERT_TRUE(test_server()->Start());
+  GURL download_url(
+      test_server()->GetURL("files/downloads/dangerous/dangerous.exe"));
+  scoped_ptr<content::DownloadTestObserver> dangerous_observer(
+      DangerousDownloadWaiter(
+          browser(),
+          1,
+          content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_QUIT));
+  ui_test_utils::NavigateToURLWithDisposition(browser(),
+                                              download_url,
+                                              NEW_BACKGROUND_TAB,
+                                              ui_test_utils::BROWSER_TEST_NONE);
+  dangerous_observer->WaitForFinished();
+
+  std::vector<DownloadItem*> downloads;
+  DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
+  ASSERT_EQ(1u, downloads.size());
+
+  DownloadItem* download = downloads[0];
+  EXPECT_TRUE(download->IsDangerous());
+  EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
+            download->GetDangerType());
+
+  download->Cancel(true);
+}
+
+IN_PROC_BROWSER_TEST_F(DownloadTest, SafeSupportedFile) {
+  ASSERT_TRUE(test_server()->Start());
+  GURL download_url(test_server()->GetURL("files/downloads/a_zip_file.zip"));
+  DownloadAndWait(browser(), download_url);
+
+  std::vector<DownloadItem*> downloads;
+  DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
+  ASSERT_EQ(1u, downloads.size());
+
+  DownloadItem* download = downloads[0];
+  EXPECT_FALSE(download->IsDangerous());
+  EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
+            download->GetDangerType());
+
+  download->Cancel(true);
+}
+
+#endif // OS_WIN
+
 IN_PROC_BROWSER_TEST_F(DownloadTest, FeedbackService) {
   // Make a dangerous file.
   base::FilePath file(FILE_PATH_LITERAL("downloads/dangerous/dangerous.swf"));
   GURL download_url(net::URLRequestMockHTTPJob::GetMockUrl(file));
   scoped_ptr<content::DownloadTestObserverInterrupted> observer(
       new content::DownloadTestObserverInterrupted(
           DownloadManagerForBrowser(browser()), 1,
           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_QUIT));
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
@@ skipping 31 matching lines @@
       *(downloads[0])));
 
   // Begin feedback and check that the file is "stolen".
   download_protection_service->feedback_service()->BeginFeedbackForDownload(
       downloads[0]);
   std::vector<DownloadItem*> updated_downloads;
   GetDownloads(browser(), &updated_downloads);
   ASSERT_TRUE(updated_downloads.empty());
 }
 #endif