Track CTR of uncommon download warning.

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 "chrome/browser/download/download_browsertest.h"
 
 #include <stdint.h>
 #include <sstream>
 #include <utility>
 
@@ skipping 14 matching lines @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/test/test_file_util.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
+#include "chrome/browser/download/download_commands.h"
 #include "chrome/browser/download/download_crx_util.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_item_model.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_request_limiter.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/download/download_target_determiner.h"
 #include "chrome/browser/download/download_test_file_activity_observer.h"
@@ skipping 23 matching lines @@
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/test_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/history/content/browser/download_constants_utils.h"
 #include "components/history/core/browser/download_constants.h"
 #include "components/history/core/browser/download_row.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/infobars/core/confirm_infobar_delegate.h"
 #include "components/infobars/core/infobar.h"
 #include "components/prefs/pref_service.h"
+#include "content/public/browser/download_danger_type.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/download_save_info.h"
 #include "content/public/browser/download_url_parameters.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/resource_context.h"
@@ skipping 153 matching lines @@
     was_previously_resumable_ = is_resumable_now;
     return transitions_left_ == 0;
   }
 
   bool was_previously_resumable_;
   size_t transitions_left_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadTestObserverResumable);
 };
 
+// DownloadTestObserverTerminal subclass for testing.
+class DownloadTestObserverAcceptUncommon
+    : public content::DownloadTestObserverTerminal {
+ public:
+  DownloadTestObserverAcceptUncommon(
+      DownloadManager* download_manager,
+      size_t wait_count,
+      content::DownloadTestObserver::DangerousDownloadAction
+          dangerous_download_action)
+      : content::DownloadTestObserverTerminal(download_manager,
+                                              wait_count,
+                                              dangerous_download_action),
+        weak_factory_(this) {}
+  ~DownloadTestObserverAcceptUncommon() override {}
+
+  void OnDownloadUpdated(DownloadItem* download) override {
+    // Real UI code gets the user's response after returning from the observer.
+    if (download->IsDangerous() &&
+        !ContainsKey(dangerous_downloads_seen(), download->GetId())) {
+      dangerous_downloads_seen().insert(download->GetId());

[asanka, 2016/03/11 03:43:26]

This is inserting an item into a temporary set that's immediately destroyed.

[Jialiu Lin, 2016/03/11 05:03:48]

Oops, should be return by reference instead. fixed in download_test.observer.*
files.

+
+      switch (dangerous_download_action()) {
+        case ON_DANGEROUS_DOWNLOAD_ACCEPT:
+          BrowserThread::PostTask(
+              BrowserThread::UI, FROM_HERE,
+              base::Bind(
+                  &DownloadTestObserverAcceptUncommon::AcceptDangerousDownload,
+                  weak_factory_.GetWeakPtr(), download->GetId()));
+          break;
+        default:
+          NOTREACHED();
+      }
+    }
+
+    if (IsDownloadInFinalState(download))
+      DownloadInFinalState(download);
+  }
+
+ private:
+  void AcceptDangerousDownload(uint32_t download_id) {
+    if (!download_manager())
+      return;
+    DownloadItem* download = download_manager()->GetDownload(download_id);
+    if (download && download->IsDangerous() && !download->IsDone()) {
+      DownloadCommands(download).ExecuteCommand(DownloadCommands::KEEP);
+    }
+  }
+
+  base::WeakPtrFactory<DownloadTestObserverAcceptUncommon> weak_factory_;
+};
+
 // IDs and paths of CRX files used in tests.
 const char kGoodCrxId[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
 const char kGoodCrxPath[] = "extensions/good.crx";
 
 const char kLargeThemeCrxId[] = "pjpgmfcmabopnnfonnhmdjglfpjjfkbf";
 const char kLargeThemePath[] = "extensions/theme2.crx";
 
 // Get History Information.
 class DownloadsHistoryDataCollector {
  public:
@@ skipping 120 matching lines @@
 
  private:
   Profile* profile_;
   bool waiting_;
   bool seen_stored_;
   FilterCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryObserver);
 };
 
+class FakeSafeBrowsingService : public safe_browsing::SafeBrowsingService {
+ public:
+  FakeSafeBrowsingService() {}
+
+  std::string GetDownloadReport() const { return report_; }
+
+ protected:
+  ~FakeSafeBrowsingService() override {}
+
+  void SendSerializedDownloadReport(const std::string& report) override {
+    report_ = report;
+  }
+
+  std::string report_;
+};
+
+// Factory that creates FakeSafeBrowsingService instances.
+class TestSafeBrowsingServiceFactory
+    : public safe_browsing::SafeBrowsingServiceFactory {
+ public:
+  TestSafeBrowsingServiceFactory() : fake_safe_browsing_service_(nullptr) {}
+  ~TestSafeBrowsingServiceFactory() override {}
+
+  safe_browsing::SafeBrowsingService* CreateSafeBrowsingService() override {
+    if (!fake_safe_browsing_service_) {
+      fake_safe_browsing_service_ = new FakeSafeBrowsingService();
+    }
+    return fake_safe_browsing_service_.get();
+  }
+
+  scoped_refptr<FakeSafeBrowsingService> fake_safe_browsing_service() {
+    return fake_safe_browsing_service_;
+  }
+
+ private:
+  scoped_refptr<FakeSafeBrowsingService> fake_safe_browsing_service_;
+};
+
 class DownloadTest : public InProcessBrowserTest {
  public:
-  // Choice of navigation or direct fetch.  Used by |DownloadFileCheckErrors()|.
-  enum DownloadMethod {
-    DOWNLOAD_NAVIGATE,
-    DOWNLOAD_DIRECT
-  };
+  // Choice of navigation or direct fetch.  Used by
+  // |DownloadFileCheckErrors()|.
+  enum DownloadMethod { DOWNLOAD_NAVIGATE, DOWNLOAD_DIRECT };
 
   // Information passed in to |DownloadFileCheckErrors()|.
   struct DownloadInfo {
     const char* starting_url;           // URL for initiating the download.
     const char* expected_download_url;  // Expected value of DI::GetURL(). Can
                                         // be different if |starting_url|
                                         // initiates a download from another
                                         // URL.
     DownloadMethod download_method;     // Navigation or Direct.
     // Download interrupt reason (NONE is OK).
     content::DownloadInterruptReason reason;
-    bool show_download_item;  // True if the download item appears on the shelf.
-    bool should_redirect_to_documents;  // True if we save it in "My Documents".
+    bool show_download_item;  // True if the download item appears on the
+                              // shelf.
+    bool should_redirect_to_documents;  // True if we save it in "My
+                                        // Documents".
   };
 
   struct FileErrorInjectInfo {
     DownloadInfo download_info;
     content::TestFileErrorInjector::FileErrorInfo error_info;
   };
 
-  DownloadTest() {}
+  DownloadTest()
+      : test_safe_browsing_factory_(new TestSafeBrowsingServiceFactory()) {}
+
+  void SetUp() override {
+    safe_browsing::SafeBrowsingService::RegisterFactory(

[asanka, 2016/03/11 03:43:26]

Why is this necessary to be in SetUp() instead of SetUpOnMainThread()?

[Jialiu Lin, 2016/03/11 05:03:48]

Because the registerFactory function needs to be called before
InProcessBrowserTest::SetUp(), while SetUpOnMainThread() is in fact called after
the SetUp(). Also, there are other steps between SetUp() and
SetUpOnMainThread(), so merge SetUpOnMainThread() to SetUp() doesn't work
either. 

+        test_safe_browsing_factory_.get());
+    InProcessBrowserTest::SetUp();
+  }
+
+  void TearDown() override {
+    safe_browsing::SafeBrowsingService::RegisterFactory(nullptr);
+    InProcessBrowserTest::TearDown();
+  }
 
   void SetUpOnMainThread() override {
     base::FeatureList::ClearInstanceForTesting();
     scoped_ptr<base::FeatureList> feature_list(new base::FeatureList);
-    feature_list->InitializeFromCommandLine(
-        features::kDownloadResumption.name, std::string());
+    feature_list->InitializeFromCommandLine(features::kDownloadResumption.name,

[asanka, 2016/03/11 03:43:26]

Nit: There's a number of formatting only changes that are unnecessary for this
CL. Would you mind reverting them?

[Jialiu Lin, 2016/03/11 05:03:48]

No problem.... seems I need to be more careful with 'git cl format'. :-)

+                                            std::string());
     base::FeatureList::SetInstance(std::move(feature_list));
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
     ASSERT_TRUE(InitialSetup());
   }
 
   void TearDownOnMainThread() override {
-    // Needs to be torn down on the main thread. file_activity_observer_ holds a
-    // reference to the ChromeDownloadManagerDelegate which should be destroyed
+    // Needs to be torn down on the main thread. file_activity_observer_ holds
+    // a
+    // reference to the ChromeDownloadManagerDelegate which should be
+    // destroyed
     // on the UI thread.
     file_activity_observer_.reset();
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kDisablePluginsDiscovery);
   }
 
   // Returning false indicates a failure of the setup, and should be asserted
   // in the caller.
   virtual bool InitialSetup() {
     bool have_test_dir = PathService::Get(chrome::DIR_TEST_DATA, &test_dir_);
     EXPECT_TRUE(have_test_dir);
     if (!have_test_dir)
       return false;
 
     // Sanity check default values for window and tab count.
     int window_count = chrome::GetTotalBrowserCount();
     EXPECT_EQ(1, window_count);
     EXPECT_EQ(1, browser()->tab_strip_model()->count());
 
     // Set up the temporary download folder.
     bool created_downloads_dir = CreateAndSetDownloadsDirectory(browser());
     EXPECT_TRUE(created_downloads_dir);
     if (!created_downloads_dir)
       return false;
-    browser()->profile()->GetPrefs()->SetBoolean(
-        prefs::kPromptForDownload, false);
+    browser()->profile()->GetPrefs()->SetBoolean(prefs::kPromptForDownload,
+                                                 false);
 
     DownloadManager* manager = DownloadManagerForBrowser(browser());
     DownloadPrefs::FromDownloadManager(manager)->ResetAutoOpen();
     manager->RemoveAllDownloads();
 
     file_activity_observer_.reset(
         new DownloadTestFileActivityObserver(browser()->profile()));
 
     return true;
   }
 
  protected:
   enum SizeTestType {
     SIZE_TEST_TYPE_KNOWN,
     SIZE_TEST_TYPE_UNKNOWN,
   };
 
   base::FilePath GetTestDataDirectory() {
     base::FilePath test_file_directory;
     PathService::Get(chrome::DIR_TEST_DATA, &test_file_directory);
     return test_file_directory;
   }
 
-  base::FilePath GetDownloadsDirectory() {
-    return downloads_directory_.path();
-  }
+  base::FilePath GetDownloadsDirectory() { return downloads_directory_.path(); }
 
   // Location of the file source (the place from which it is downloaded).
   base::FilePath OriginFile(base::FilePath file) {
     return test_dir_.Append(file);
   }
 
   // Location of the file destination (place to which it is downloaded).
   base::FilePath DestinationFile(Browser* browser, base::FilePath 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
+  // Returning false indicates a failure of the function, and should be
+  // asserted
   // in the caller.
   bool CreateAndSetDownloadsDirectory(Browser* browser) {
     if (!browser)
       return false;
 
     if (!downloads_directory_.CreateUniqueTempDir())
       return false;
 
     browser->profile()->GetPrefs()->SetFilePath(
-        prefs::kDownloadDefaultDirectory,
-        downloads_directory_.path());
+        prefs::kDownloadDefaultDirectory, downloads_directory_.path());
     browser->profile()->GetPrefs()->SetFilePath(
-        prefs::kSaveFileDefaultDirectory,
-        downloads_directory_.path());
+        prefs::kSaveFileDefaultDirectory, downloads_directory_.path());
 
     return true;
   }
 
   DownloadPrefs* GetDownloadPrefs(Browser* browser) {
     return DownloadPrefs::FromDownloadManager(
         DownloadManagerForBrowser(browser));
   }
 
   base::FilePath GetDownloadDirectory(Browser* browser) {
     return GetDownloadPrefs(browser)->DownloadPath();
   }
 
   // Create a DownloadTestObserverTerminal that will wait for the
   // specified number of downloads to finish.
-  content::DownloadTestObserver* CreateWaiter(
-      Browser* browser, int num_downloads) {
+  content::DownloadTestObserver* CreateWaiter(Browser* browser,
+                                              int num_downloads) {
     DownloadManager* download_manager = DownloadManagerForBrowser(browser);
     return new content::DownloadTestObserverTerminal(
         download_manager, num_downloads,
         content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL);
   }
 
   // Create a DownloadTestObserverInProgress that will wait for the
   // specified number of downloads to start.
-  content::DownloadTestObserver* CreateInProgressWaiter(
-      Browser* browser, int num_downloads) {
+  content::DownloadTestObserver* CreateInProgressWaiter(Browser* browser,
+                                                        int num_downloads) {
     DownloadManager* download_manager = DownloadManagerForBrowser(browser);
-    return new content::DownloadTestObserverInProgress(
-        download_manager, num_downloads);
+    return new content::DownloadTestObserverInProgress(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) {
     DownloadManager* download_manager = DownloadManagerForBrowser(browser);
     return new content::DownloadTestObserverTerminal(
         download_manager, num_downloads, dangerous_download_action);
   }
 
+  // Create a DownloadTestObserverAcceptUncommon that will wait for the
+  // specified number of downloads to finish, or for
+  // an uncommon download warning to be shown.
+  content::DownloadTestObserver* UncommonDownloadWaiter(
+      Browser* browser,
+      int num_downloads,
+      content::DownloadTestObserver::DangerousDownloadAction
+          dangerous_download_action) {
+    DownloadManager* download_manager = DownloadManagerForBrowser(browser);
+    return new DownloadTestObserverAcceptUncommon(
+        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());
 
     for (size_t i = 0; i < download_items.size(); ++i) {
       EXPECT_EQ(state, download_items[i]->GetState()) << " Item " << i;
@@ skipping 17 matching lines @@
   // values in the ui_test_utils::BrowserTestWaitFlags enum.
   void DownloadAndWaitWithDisposition(Browser* browser,
                                       const GURL& url,
                                       WindowOpenDisposition disposition,
                                       int browser_test_flags) {
     // Setup notification, navigate, and block.
     scoped_ptr<content::DownloadTestObserver> observer(
         CreateWaiter(browser, 1));
     // This call will block until the condition specified by
     // |browser_test_flags|, but will not wait for the download to finish.
-    ui_test_utils::NavigateToURLWithDisposition(browser,
-                                                url,
-                                                disposition,
+    ui_test_utils::NavigateToURLWithDisposition(browser, url, disposition,
                                                 browser_test_flags);
     // Waits for the download to complete.
     observer->WaitForFinished();
     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
     // We don't expect a file chooser to be shown.
     EXPECT_FALSE(DidShowFileChooser());
   }
 
   // Download a file in the current tab, then wait for the download to finish.
-  void DownloadAndWait(Browser* browser,
-                       const GURL& url) {
+  void DownloadAndWait(Browser* browser, const GURL& url) {
     DownloadAndWaitWithDisposition(
-        browser,
-        url,
-        CURRENT_TAB,
+        browser, url, CURRENT_TAB,
         ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   }
 
   // Should only be called when the download is known to have finished
   // (in error or not).
-  // Returning false indicates a failure of the function, and should be asserted
+  // Returning false indicates a failure of the function, and should be
+  // asserted
   // in the caller.
   bool CheckDownload(Browser* browser,
                      const base::FilePath& downloaded_filename,
                      const base::FilePath& origin_filename) {
     // Find the path to which the data will be downloaded.
     base::FilePath downloaded_file(
         DestinationFile(browser, downloaded_filename));
 
     // Find the origin path (from which the data comes).
     base::FilePath origin_file(OriginFile(origin_filename));
@@ skipping 24 matching lines @@
 
     // Delete the downloaded copy of the file.
     bool downloaded_file_deleted = base::DieFileDie(downloaded_file, false);
     EXPECT_TRUE(downloaded_file_deleted);
     return downloaded_file_deleted;
   }
 
   content::DownloadTestObserver* CreateInProgressDownloadObserver(
       size_t download_count) {
     DownloadManager* manager = DownloadManagerForBrowser(browser());
-    return new content::DownloadTestObserverInProgress(
-        manager, download_count);
+    return new content::DownloadTestObserverInProgress(manager, download_count);
   }
 
   DownloadItem* CreateSlowTestDownload() {
     scoped_ptr<content::DownloadTestObserver> observer(
         CreateInProgressDownloadObserver(1));
     GURL slow_download_url(net::URLRequestSlowDownloadJob::kUnknownSizeUrl);
     DownloadManager* manager = DownloadManagerForBrowser(browser());
 
     EXPECT_EQ(0, manager->NonMaliciousInProgressCount());
     EXPECT_EQ(0, manager->InProgressCount());
@@ skipping 20 matching lines @@
     return new_item;
   }
 
   bool RunSizeTest(Browser* browser,
                    SizeTestType type,
                    const std::string& partial_indication,
                    const std::string& total_indication) {
     EXPECT_TRUE(type == SIZE_TEST_TYPE_UNKNOWN || type == SIZE_TEST_TYPE_KNOWN);
     if (type != SIZE_TEST_TYPE_KNOWN && type != SIZE_TEST_TYPE_UNKNOWN)
       return false;
-    GURL url(type == SIZE_TEST_TYPE_KNOWN ?
-             net::URLRequestSlowDownloadJob::kKnownSizeUrl :
-             net::URLRequestSlowDownloadJob::kUnknownSizeUrl);
+    GURL url(type == SIZE_TEST_TYPE_KNOWN
+                 ? net::URLRequestSlowDownloadJob::kKnownSizeUrl
+                 : net::URLRequestSlowDownloadJob::kUnknownSizeUrl);
 
     // TODO(ahendrickson) -- |expected_title_in_progress| and
     // |expected_title_finished| need to be checked.
     base::FilePath filename;
     net::FileURLToFilePath(url, &filename);
     base::string16 expected_title_in_progress(
         base::ASCIIToUTF16(partial_indication) + filename.LossyDisplayName());
     base::string16 expected_title_finished(
         base::ASCIIToUTF16(total_indication) + filename.LossyDisplayName());
 
     // Download a partial web page in a background tab and wait.
     // The mock system will not complete until it gets a special URL.
     scoped_ptr<content::DownloadTestObserver> observer(
         CreateWaiter(browser, 1));
     ui_test_utils::NavigateToURL(browser, url);
 
     // TODO(ahendrickson): check download status text before downloading.
     // Need to:
     //  - Add a member function to the |DownloadShelf| interface class, that
     //    indicates how many members it has.
     //  - Add a member function to |DownloadShelf| to get the status text
     //    of a given member (for example, via the name in |DownloadItemView|'s
     //    GetAccessibleState() member function), by index.
     //  - Iterate over browser->window()->GetDownloadShelf()'s members
-    //    to see if any match the status text we want.  Start with the last one.
+    //    to see if any match the status text we want.  Start with the last
+    //    one.
 
     // Allow the request to finish.  We do this by loading a second URL in a
     // separate tab.
     GURL finish_url(net::URLRequestSlowDownloadJob::kFinishDownloadUrl);
     ui_test_utils::NavigateToURLWithDisposition(
-        browser,
-        finish_url,
-        NEW_FOREGROUND_TAB,
+        browser, finish_url, NEW_FOREGROUND_TAB,
         ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
     observer->WaitForFinished();
     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
     CheckDownloadStatesForBrowser(browser, 1, DownloadItem::COMPLETE);
 
     EXPECT_EQ(2, browser->tab_strip_model()->count());
 
     // TODO(ahendrickson): check download status text after downloading.
 
     base::FilePath basefilename(filename.BaseName());
@@ skipping 144 matching lines @@
     } else {
       // Navigate to URL normally, wait until done.
       ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
           browser(), starting_url, 1);
     }
 
     if (download_info.show_download_item) {
       downloads_expected++;
       observer->WaitForFinished();
       DownloadItem::DownloadState final_state =
-          (download_info.reason == content::DOWNLOAD_INTERRUPT_REASON_NONE) ?
-              DownloadItem::COMPLETE :
-              DownloadItem::INTERRUPTED;
+          (download_info.reason == content::DOWNLOAD_INTERRUPT_REASON_NONE)
+              ? DownloadItem::COMPLETE
+              : DownloadItem::INTERRUPTED;
       EXPECT_EQ(1u, observer->NumDownloadsSeenInState(final_state));
     }
 
     // Wait till the |DownloadFile|s are destroyed.
     content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
 
     // Validate that the correct files were downloaded.
     download_items.clear();
     GetDownloads(browser(), &download_items);
@@ skipping 10 matching lines @@
       EXPECT_EQ(download_url, item->GetURL());
       EXPECT_EQ(download_info.reason, item->GetLastReason());
 
       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(base::PathExists(my_downloaded_file));
         EXPECT_TRUE(base::DeleteFile(my_downloaded_file, false));
 
-        EXPECT_EQ(download_info.should_redirect_to_documents ?
-                      std::string::npos :
-                      0u,
-                  my_downloaded_file.value().find(destination_folder.value()));
+        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;
-          EXPECT_TRUE(PathService::Get(chrome::DIR_USER_DOCUMENTS,
-                                       &my_docs_folder));
+          EXPECT_TRUE(
+              PathService::Get(chrome::DIR_USER_DOCUMENTS, &my_docs_folder));
           EXPECT_EQ(0u,
                     my_downloaded_file.value().find(my_docs_folder.value()));
         }
       }
     }
   }
 
   // Attempts to download a set of files, based on information in the
   // |download_info| array.  |count| is the number of files.
   // If a Select File dialog appears, it will choose the default and return
@@ skipping 53 matching lines @@
              << " folder = '" << destination_folder.value() << "'";
     base::FilePermissionRestorer permission_restorer(destination_folder);
     EXPECT_TRUE(base::MakeFileUnwritable(destination_folder));
 
     for (size_t i = 0; i < count; ++i) {
       DownloadFilesCheckErrorsLoopBody(download_info[i], i);
     }
   }
 
   // This method:
-  // * Starts a mock download by navigating browser() to a URLRequestMockHTTPJob
+  // * Starts a mock download by navigating browser() to a
+  // URLRequestMockHTTPJob
   //   mock URL.
   // * Injects |error| on the first write using |error_injector|.
   // * Waits for the download to be interrupted.
   // * Clears the errors on |error_injector|.
   // * Returns the resulting interrupted download.
   DownloadItem* StartMockDownloadAndInjectError(
       content::TestFileErrorInjector* error_injector,
       content::DownloadInterruptReason error) {
     content::TestFileErrorInjector::FileErrorInfo error_info;
     error_info.code = content::TestFileErrorInjector::FILE_OPERATION_WRITE;
     error_info.operation_instance = 0;
     error_info.error = error;
     error_injector->InjectError(error_info);
 
     scoped_ptr<content::DownloadTestObserver> observer(
-        new DownloadTestObserverResumable(
-            DownloadManagerForBrowser(browser()), 1));
+        new DownloadTestObserverResumable(DownloadManagerForBrowser(browser()),
+                                          1));
 
     GURL url = URLRequestMockHTTPJob::GetMockUrl(kDownloadTest1Path);
     ui_test_utils::NavigateToURL(browser(), url);
     observer->WaitForFinished();
 
     content::DownloadManager::DownloadVector downloads;
     DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
     EXPECT_EQ(1u, downloads.size());
 
     if (downloads.size() != 1)
       return NULL;
 
     error_injector->ClearError();
     DownloadItem* download = downloads[0];
     EXPECT_EQ(DownloadItem::INTERRUPTED, download->GetState());
     EXPECT_EQ(error, download->GetLastReason());
     return download;
   }
 
+ protected:
+  scoped_ptr<TestSafeBrowsingServiceFactory> test_safe_browsing_factory_;
+
  private:
   static void EnsureNoPendingDownloadJobsOnIO(bool* result) {
     if (net::URLRequestSlowDownloadJob::NumberOutstandingRequests())
       *result = false;
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::MessageLoop::QuitWhenIdleClosure());
   }
 
   // Location of the test data.
   base::FilePath test_dir_;
@@ skipping 2191 matching lines @@
   ASSERT_TRUE(safe_browsing::DownloadFeedbackService::IsEnabledForDownload(
       *(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());
 }
+
+IN_PROC_BROWSER_TEST_F(DownloadTest, SendUncommonDownloadAcceptReport) {
+  browser()->profile()->GetPrefs()->SetBoolean(prefs::kSafeBrowsingEnabled,
+                                               true);
+  // Make a dangerous file.
+  GURL download_url(
+      net::URLRequestMockHTTPJob::GetMockUrl(kDangerousMockFilePath));
+  scoped_ptr<content::DownloadTestObserver> dangerous_observer(
+      UncommonDownloadWaiter(
+          browser(), 1,
+          content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
+  scoped_ptr<content::DownloadTestObserver> in_progress_observer(
+      new content::DownloadTestObserverInProgress(
+          DownloadManagerForBrowser(browser()), 1));
+
+  ui_test_utils::NavigateToURL(browser(), download_url);
+  in_progress_observer->WaitForFinished();
+
+  std::vector<DownloadItem*> downloads;
+  DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
+  ASSERT_EQ(1u, downloads.size());
+  DownloadItem* download = downloads[0];
+  // Simulates an uncommon download.
+  download->OnContentCheckCompleted(
+      content::DownloadDangerType::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT);
+  ASSERT_EQ(download->GetDangerType(),
+            content::DownloadDangerType::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT);
+  dangerous_observer->WaitForFinished();
+
+  safe_browsing::ClientSafeBrowsingReportRequest actual_report;
+  actual_report.ParseFromString(
+      test_safe_browsing_factory_->fake_safe_browsing_service()
+          ->GetDownloadReport());
+  EXPECT_EQ(safe_browsing::ClientSafeBrowsingReportRequest::
+                DANGEROUS_DOWNLOAD_WARNING,
+            actual_report.type());
+  EXPECT_EQ(safe_browsing::ClientDownloadResponse::UNCOMMON,
+            actual_report.download_verdict());
+  EXPECT_EQ(download->GetURL().spec(), actual_report.url());
+  EXPECT_TRUE(actual_report.did_proceed());
+
+  download->Cancel(true);
+}
 #endif  // FULL_SAFE_BROWSING
 
 class DownloadTestWithShelf : public DownloadTest {
   void SetUpCommandLine(base::CommandLine* command_line) override {
 #if defined(OS_CHROMEOS)
     command_line->AppendSwitch(switches::kDisableDownloadNotification);
 #endif
     DownloadTest::SetUpCommandLine(command_line);
   }
 };
@@ skipping 242 matching lines @@
 
   scoped_ptr<content::DownloadTestObserver> observer(DangerousDownloadWaiter(
       browser(), 1, content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_DENY));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
 
   // Download shelf should close.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 }