Prefer opening PDF downloads in the browser.

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/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
 #include "chrome/browser/download/download_prefs.h"
+#include "chrome/browser/download/download_target_info.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/mock_download_manager.h"
 #include "content/public/test/test_browser_thread.h"
@@ skipping 36 matching lines @@
 ACTION_P(ScheduleCallback, result) {
   base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(arg0, result));
 }
 
 // Similar to ScheduleCallback, but binds 2 arguments.
 ACTION_P2(ScheduleCallback2, result0, result1) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(arg0, result0, result1));
 }
 
-struct DownloadTarget {
-  base::FilePath target_path;
-  base::FilePath intermediate_path;
-  DownloadItem::TargetDisposition target_disposition;
-  content::DownloadDangerType danger_type;
-};
-
 // Subclass of the ChromeDownloadManagerDelegate that uses a mock
 // DownloadProtectionService.
 class TestChromeDownloadManagerDelegate : public ChromeDownloadManagerDelegate {
  public:
   explicit TestChromeDownloadManagerDelegate(Profile* profile)
       : ChromeDownloadManagerDelegate(profile) {
   }
 
   virtual safe_browsing::DownloadProtectionService*
       GetDownloadProtectionService() OVERRIDE {
@@ skipping 60 matching lines @@
   content::MockDownloadItem* CreateActiveDownloadItem(int32 id);
 
   // Given the relative path |path|, returns the full path under the temporary
   // downloads directory.
   base::FilePath GetPathInDownloadDir(const char* path);
 
   // Set the kDownloadDefaultDirectory user preference to |path|.
   void SetDefaultDownloadPath(const base::FilePath& path);
 
   void DetermineDownloadTarget(DownloadItem* download,
-                               DownloadTarget* result);
+                               DownloadTargetInfo* result);
 
   const base::FilePath& default_download_path() const;
   TestChromeDownloadManagerDelegate* delegate();
   content::MockDownloadManager* download_manager();
   DownloadPrefs* download_prefs();
 
  private:
-  void OnDownloadTargetDone(DownloadTarget* result,
-                            const base::FilePath& target_path,
-                            DownloadItem::TargetDisposition disposition,
-                            content::DownloadDangerType danger_type,
-                            const base::FilePath& intermediate_path);
-
   TestingPrefServiceSyncable* pref_service_;
   base::ScopedTempDir test_download_dir_;
   scoped_ptr<content::MockDownloadManager> download_manager_;
   scoped_refptr<TestChromeDownloadManagerDelegate> delegate_;
   MockWebContentsDelegate web_contents_delegate_;
 };
 
 ChromeDownloadManagerDelegateTest::ChromeDownloadManagerDelegateTest()
     : download_manager_(new ::testing::NiceMock<content::MockDownloadManager>) {
 }
@@ skipping 66 matching lines @@
       test_download_dir_.path().AppendASCII(relative_path);
   return full_path.NormalizePathSeparators();
 }
 
 void ChromeDownloadManagerDelegateTest::SetDefaultDownloadPath(
     const base::FilePath& path) {
   pref_service_->SetFilePath(prefs::kDownloadDefaultDirectory, path);
   pref_service_->SetFilePath(prefs::kSaveFileDefaultDirectory, path);
 }
 
+void StoreDownloadTargetInfo(const base::Closure& closure,
+                         DownloadTargetInfo* target_info,
+                         const base::FilePath& target_path,
+                         DownloadItem::TargetDisposition target_disposition,
+                         content::DownloadDangerType danger_type,
+                         const base::FilePath& intermediate_path) {
+  target_info->target_path = target_path;
+  target_info->target_disposition = target_disposition;
+  target_info->danger_type = danger_type;
+  target_info->intermediate_path = intermediate_path;
+  closure.Run();
+}
+
 void ChromeDownloadManagerDelegateTest::DetermineDownloadTarget(
     DownloadItem* download_item,
-    DownloadTarget* result) {
-  base::WeakPtrFactory<ChromeDownloadManagerDelegateTest> factory(this);
+    DownloadTargetInfo* result) {
+  base::RunLoop loop_runner;
   delegate()->DetermineDownloadTarget(
       download_item,
-      base::Bind(&ChromeDownloadManagerDelegateTest::OnDownloadTargetDone,
-                 factory.GetWeakPtr(), base::Unretained(result)));
-  base::RunLoop loop_runner;
-  loop_runner.RunUntilIdle();
-}
-
-void ChromeDownloadManagerDelegateTest::OnDownloadTargetDone(
-    DownloadTarget* result,
-    const base::FilePath& target_path,
-    DownloadItem::TargetDisposition target_disposition,
-    content::DownloadDangerType danger_type,
-    const base::FilePath& intermediate_path) {
-  result->target_path = target_path;
-  result->intermediate_path = intermediate_path;
-  result->target_disposition = target_disposition;
-  result->danger_type = danger_type;
+      base::Bind(&StoreDownloadTargetInfo, loop_runner.QuitClosure(), result));
+  loop_runner.Run();
 }
 
 const base::FilePath& ChromeDownloadManagerDelegateTest::default_download_path()
     const {
   return test_download_dir_.path();
 }
 
 TestChromeDownloadManagerDelegate*
     ChromeDownloadManagerDelegateTest::delegate() {
   return delegate_.get();
@@ skipping 27 matching lines @@
   EXPECT_CALL(*automatic_download, GetURL())
       .Times(::testing::AnyNumber())
       .WillRepeatedly(ReturnRef(download_url));
   EXPECT_CALL(*automatic_download, GetTargetDisposition())
       .Times(::testing::AnyNumber())
       .WillRepeatedly(Return(DownloadItem::TARGET_DISPOSITION_OVERWRITE));
 
   {
     // When the prompt is displayed for the first download, the user selects a
     // path in a different directory.
-    DownloadTarget result;
+    DownloadTargetInfo result;
     base::FilePath expected_prompt_path(GetPathInDownloadDir("foo.txt"));
     base::FilePath user_selected_path(GetPathInDownloadDir("bar/baz.txt"));
     EXPECT_CALL(*delegate(),
                 MockPromptUserForDownloadPath(save_as_download.get(),
                                               expected_prompt_path, _))
         .WillOnce(Return(user_selected_path));
     DetermineDownloadTarget(save_as_download.get(), &result);
     EXPECT_EQ(user_selected_path, result.target_path);
     VerifyAndClearExpectations();
   }
 
   {
     // The prompt path for the second download is the user selected directroy
     // from the previous download.
-    DownloadTarget result;
+    DownloadTargetInfo result;
     base::FilePath expected_prompt_path(GetPathInDownloadDir("bar/foo.txt"));
     EXPECT_CALL(*delegate(),
                 MockPromptUserForDownloadPath(save_as_download.get(),
                                               expected_prompt_path, _))
         .WillOnce(Return(base::FilePath()));
     DetermineDownloadTarget(save_as_download.get(), &result);
     VerifyAndClearExpectations();
   }
 
   {
     // Start an automatic download. This one should get the default download
     // path since the last download path only affects Save As downloads.
-    DownloadTarget result;
+    DownloadTargetInfo result;
     base::FilePath expected_path(GetPathInDownloadDir("foo.txt"));
     DetermineDownloadTarget(automatic_download.get(), &result);
     EXPECT_EQ(expected_path, result.target_path);
     VerifyAndClearExpectations();
   }
 
   {
     // The prompt path for the next download should be the default.
     download_prefs()->SetSaveFilePath(download_prefs()->DownloadPath());
-    DownloadTarget result;
+    DownloadTargetInfo result;
     base::FilePath expected_prompt_path(GetPathInDownloadDir("foo.txt"));
     EXPECT_CALL(*delegate(),
                 MockPromptUserForDownloadPath(save_as_download.get(),
                                               expected_prompt_path, _))
         .WillOnce(Return(base::FilePath()));
     DetermineDownloadTarget(save_as_download.get(), &result);
     VerifyAndClearExpectations();
   }
 }