Use DownloadItem directly in DownloadProtectionService.

chrome/browser/download/chrome_download_manager_delegate_unittest.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 "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop.h"
 #include "base/observer_list.h"
 #include "base/prefs/pref_service.h"
@@ skipping 14 matching lines @@
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/mock_download_manager.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_renderer_host.h"
 #include "content/public/test/web_contents_tester.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AtMost;
 using ::testing::Invoke;
+using ::testing::Ref;
 using ::testing::Return;
 using ::testing::ReturnPointee;
 using ::testing::ReturnRef;
 using ::testing::ReturnRefOfCopy;
 using ::testing::SetArgPointee;
 using ::testing::WithArg;
 using ::testing::_;
 using content::DownloadItem;
 using safe_browsing::DownloadProtectionService;
 
@@ skipping 13 matching lines @@
 //    public:
 //     virtual void Foo(base::Callback<void(bool)> callback);
 //   };
 //   ...
 //   EXPECT_CALL(mock_fooclass_instance, Foo(callback))
 //     .WillOnce(ScheduleCallback(false));
 ACTION_P(ScheduleCallback, result) {
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(arg0, result));
 }
 
-// Matches a safe_browsing::DownloadProtectionService::DownloadInfo that has
-// |url| as the first URL in the |download_url_chain|.
-// Example:
-//   EXPECT_CALL(Foo(InfoMatchinURL(url)))
-MATCHER_P(InfoMatchingURL, url, "DownloadInfo matching URL " + url.spec()) {
-  return url == arg.download_url_chain.front();
-}
-
 // Used with DownloadTestCase. Indicates the type of test case. The expectations
 // for the test is set based on the type.
 enum TestCaseType {
   SAVE_AS,
   AUTOMATIC,
   FORCED  // Requires that forced_file_path be non-empty.
 };
 
 // Used with DownloadTestCase. Indicates whether the a file should be
 // overwritten.
@@ skipping 52 matching lines @@
 #if defined(FULL_SAFE_BROWSING)
 // DownloadProtectionService with mock methods. Since the SafeBrowsingService is
 // set to NULL, it is not safe to call any non-mocked methods other than
 // SetEnabled() and enabled().
 class TestDownloadProtectionService
     : public safe_browsing::DownloadProtectionService {
  public:
   TestDownloadProtectionService()
       : safe_browsing::DownloadProtectionService(NULL, NULL) {}
   MOCK_METHOD2(CheckClientDownload,
-               void(const DownloadProtectionService::DownloadInfo&,
+               void(content::DownloadItem*,
                     const DownloadProtectionService::CheckDownloadCallback&));
   MOCK_METHOD2(CheckDownloadUrl,
-               void(const DownloadProtectionService::DownloadInfo&,
+               void(const content::DownloadItem&,
                     const DownloadProtectionService::CheckDownloadCallback&));
-  MOCK_CONST_METHOD1(IsSupportedDownload,
-                     bool(const DownloadProtectionService::DownloadInfo&));
+  MOCK_CONST_METHOD2(IsSupportedDownload,
+                     bool(const content::DownloadItem&,
+                          const base::FilePath&));
 };
 #endif
 
 // Subclass of the ChromeDownloadManagerDelegate that uses a mock
 // DownloadProtectionService and IsDangerousFile.
 class TestChromeDownloadManagerDelegate : public ChromeDownloadManagerDelegate {
  public:
   explicit TestChromeDownloadManagerDelegate(Profile* profile)
       : ChromeDownloadManagerDelegate(profile) {
 #if defined(FULL_SAFE_BROWSING)
@@ skipping 232 matching lines @@
   EXPECT_CALL(*download_manager_, GetAllDownloads(_))
       .WillRepeatedly(SetArgPointee<0>(items));
 
 #if defined(FULL_SAFE_BROWSING)
   // Results of SafeBrowsing URL check.
   DownloadProtectionService::DownloadCheckResult url_check_result =
       (test_case.danger_type == content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL) ?
           DownloadProtectionService::DANGEROUS :
           DownloadProtectionService::SAFE;
   EXPECT_CALL(*delegate_->test_download_protection_service(),
-              CheckDownloadUrl(InfoMatchingURL(download_url), _))
+              CheckDownloadUrl(Ref(*item), _))
       .WillOnce(WithArg<1>(ScheduleCallback(url_check_result)));
 
   // Downloads that are flagged as DANGEROUS_URL aren't checked for dangerous
   // content. So we never end up calling IsSupportedDownload for them.
   if (test_case.danger_type != content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL) {
     bool maybe_dangerous =
         (test_case.danger_type ==
          content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT);
     EXPECT_CALL(*delegate_->test_download_protection_service(),
-                IsSupportedDownload(InfoMatchingURL(download_url)))
+                IsSupportedDownload(Ref(*item), _))
         .WillOnce(Return(maybe_dangerous));
   }
 #else // FULL_SAFE_BROWSING
   // If safe browsing is not enabled, then these tests would fail. If such a
   // test was added, then fail early.
   EXPECT_NE(content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL, test_case.danger_type);
   EXPECT_NE(content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
             test_case.danger_type);
 #endif // !FULL_SAFE_BROWSING
 
@@ skipping 495 matching lines @@
   // Run the first test case again. Since the last download path was cleared,
   // this test case should behave identically to the first time it was run.
   RunTestCases(kLastSavePathTestCases, 1);
 }
 
 // TODO(asanka): Add more tests.
 // * Default download path is not writable.
 // * Download path doesn't exist.
 // * IsDangerousFile().
 // * Filename generation.