Merge SavePackageFilePicker{,ChromeOS}

chrome/browser/download/download_target_determiner_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.h"
 #include "base/observer_list.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
@@ skipping 175 matching lines @@
   virtual void TearDown() OVERRIDE;
 
   // Creates MockDownloadItem and sets up default expectations.
   content::MockDownloadItem* CreateActiveDownloadItem(
       int32 id,
       const DownloadTestCase& test_case);
 
   // Sets the AutoOpenBasedOnExtension user preference for |path|.
   void EnableAutoOpenBasedOnExtension(const base::FilePath& path);
 
-  // Set the kDownloadDefaultDirectory user preference to |path|.
-  void SetDefaultDownloadPath(const base::FilePath& path);
-
   // Set the kDownloadDefaultDirectory managed preference to |path|.
   void SetManagedDownloadPath(const base::FilePath& path);
 
   // Set the kPromptForDownload user preference to |prompt|.
   void SetPromptForDownload(bool prompt);
 
   // Given the relative path |path|, returns the full path under the temporary
   // downloads directory.
   base::FilePath GetPathInDownloadDir(const base::FilePath::StringType& path);
 
@@ skipping 16 matching lines @@
   }
 
   MockDownloadTargetDeterminerDelegate* delegate() {
     return &delegate_;
   }
 
   DownloadPrefs* download_prefs() {
     return download_prefs_.get();
   }
 
-  void set_last_selected_directory(const base::FilePath& path) {
-    last_selected_directory_ = path;
-  }
-
  private:
   // Verifies that |target_path|, |disposition|, |expected_danger_type| and
   // |intermediate_path| matches the expectations of |test_case|. Posts
   // |closure| to the current message loop when done.
   void DownloadTargetVerifier(const base::Closure& closure,
                               const DownloadTestCase& test_case,
                               const base::FilePath& local_path,
                               DownloadItem::TargetDisposition disposition,
                               content::DownloadDangerType danger_type,
                               const base::FilePath& intermediate_path);
 
   scoped_ptr<DownloadPrefs> download_prefs_;
   ::testing::NiceMock<MockDownloadTargetDeterminerDelegate> delegate_;
   NullWebContentsDelegate web_contents_delegate_;
   base::ScopedTempDir test_download_dir_;
   base::FilePath test_virtual_dir_;
-  base::FilePath last_selected_directory_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 };
 
 DownloadTargetDeterminerTest::DownloadTargetDeterminerTest()
     : ChromeRenderViewHostTestHarness(),
       ui_thread_(content::BrowserThread::UI, &message_loop_),
       file_thread_(content::BrowserThread::FILE, &message_loop_) {
 }
 
 void DownloadTargetDeterminerTest::SetUp() {
   ChromeRenderViewHostTestHarness::SetUp();
   CHECK(profile());
   download_prefs_.reset(new DownloadPrefs(profile()));
   web_contents()->SetDelegate(&web_contents_delegate_);
   ASSERT_TRUE(test_download_dir_.CreateUniqueTempDir());
   test_virtual_dir_ = test_download_dir().Append(FILE_PATH_LITERAL("virtual"));
-  SetDefaultDownloadPath(test_download_dir());
+  download_prefs_->SetDownloadPath(test_download_dir());
   delegate_.SetupDefaults();
 }
 
 void DownloadTargetDeterminerTest::TearDown() {
   download_prefs_.reset();
   message_loop_.RunUntilIdle();
   ChromeRenderViewHostTestHarness::TearDown();
 }
 
 content::MockDownloadItem*
@@ skipping 51 matching lines @@
   ON_CALL(*item, IsTemporary())
       .WillByDefault(Return(false));
   return item;
 }
 
 void DownloadTargetDeterminerTest::EnableAutoOpenBasedOnExtension(
     const base::FilePath& path) {
   EXPECT_TRUE(download_prefs_->EnableAutoOpenBasedOnExtension(path));
 }
 
-void DownloadTargetDeterminerTest::SetDefaultDownloadPath(
-    const base::FilePath& path) {
-  profile()->GetTestingPrefService()->
-      SetFilePath(prefs::kDownloadDefaultDirectory, path);
-}
-
 void DownloadTargetDeterminerTest::SetManagedDownloadPath(
     const base::FilePath& path) {
   profile()->GetTestingPrefService()->
       SetManagedPref(prefs::kDownloadDefaultDirectory,
                      base::CreateFilePathValue(path));
 }
 
 void DownloadTargetDeterminerTest::SetPromptForDownload(bool prompt) {
   profile()->GetTestingPrefService()->
       SetBoolean(prefs::kPromptForDownload, prompt);
 }
 
 base::FilePath DownloadTargetDeterminerTest::GetPathInDownloadDir(
     const base::FilePath::StringType& relative_path) {
   if (relative_path.empty())
     return base::FilePath();
   base::FilePath full_path(test_download_dir().Append(relative_path));
   return full_path.NormalizePathSeparators();
 }
 
 void DownloadTargetDeterminerTest::RunTestCase(
     const DownloadTestCase& test_case,
     content::MockDownloadItem* item) {
   // Kick off the test.
   base::WeakPtrFactory<DownloadTargetDeterminerTest> factory(this);
   base::RunLoop run_loop;
   DownloadTargetDeterminer::Start(
-      item, download_prefs_.get(), last_selected_directory_, delegate(),
+      item, download_prefs_.get(), delegate(),
       base::Bind(&DownloadTargetDeterminerTest::DownloadTargetVerifier,
                  factory.GetWeakPtr(), run_loop.QuitClosure(), test_case));
   run_loop.Run();
   ::testing::Mock::VerifyAndClearExpectations(delegate());
 }
 
 void DownloadTargetDeterminerTest::RunTestCasesWithActiveItem(
     const DownloadTestCase test_cases[],
     size_t test_case_count) {
   for (size_t i = 0; i < test_case_count; ++i) {
@@ skipping 405 matching lines @@
       FILE_PATH_LITERAL("virtual/foo/foo.txt"),
       FILE_PATH_LITERAL("bar.txt"),
       DownloadItem::TARGET_DISPOSITION_PROMPT,
 
       EXPECT_LOCAL_PATH
     },
   };
 
   {
     SCOPED_TRACE(testing::Message()
-                 << "Running with empty last_selected_directory");
+                 << "Running with default download path");
     base::FilePath prompt_path =
         GetPathInDownloadDir(FILE_PATH_LITERAL("foo.txt"));
     EXPECT_CALL(*delegate(), PromptUserForDownloadPath(_, prompt_path, _));
     RunTestCasesWithActiveItem(kLastSavePathTestCasesPre,
                                arraysize(kLastSavePathTestCasesPre));
   }
 
   // Try with a non-empty last save path.
   {
     SCOPED_TRACE(testing::Message()
                  << "Running with local last_selected_directory");
-    set_last_selected_directory(test_download_dir().AppendASCII("foo"));
+    download_prefs()->SetSaveFilePath(test_download_dir().AppendASCII("foo"));
     base::FilePath prompt_path =
         GetPathInDownloadDir(FILE_PATH_LITERAL("foo/foo.txt"));
     EXPECT_CALL(*delegate(), PromptUserForDownloadPath(_, prompt_path, _));
     RunTestCasesWithActiveItem(kLastSavePathTestCasesPost,
                                arraysize(kLastSavePathTestCasesPost));
   }
 
   // And again, but this time use a virtual directory.
   {
     SCOPED_TRACE(testing::Message()
                  << "Running with virtual last_selected_directory");
     base::FilePath last_selected_dir = test_virtual_dir().AppendASCII("foo");
     base::FilePath virtual_path = last_selected_dir.AppendASCII("foo.txt");
-    set_last_selected_directory(last_selected_dir);
+    download_prefs()->SetSaveFilePath(last_selected_dir);
     EXPECT_CALL(*delegate(), PromptUserForDownloadPath(
         _, last_selected_dir.AppendASCII("foo.txt"), _));
     EXPECT_CALL(*delegate(), DetermineLocalPath(_, virtual_path, _))
         .WillOnce(WithArg<2>(ScheduleCallback(
             GetPathInDownloadDir(FILE_PATH_LITERAL("bar.txt")))));
     RunTestCasesWithActiveItem(kLastSavePathTestCasesVirtual,
                                arraysize(kLastSavePathTestCasesVirtual));
   }
 }
 
 // These tests are run with the default downloads folder set to a virtual
 // directory.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_DefaultVirtual) {
   // The default download directory is the virutal path.
-  SetDefaultDownloadPath(test_virtual_dir());
+  download_prefs()->SetDownloadPath(test_virtual_dir());
 
   {
     SCOPED_TRACE(testing::Message() << "Automatic Safe Download");
     const DownloadTestCase kAutomaticDownloadToVirtualDir = {
       AUTOMATIC,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
       "http://example.com/foo.txt", "text/plain",
       FILE_PATH_LITERAL(""),
 
       // Downloaded to default virtual directory.
@@ skipping 164 matching lines @@
       FILE_PATH_LITERAL(""),
       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
       EXPECT_LOCAL_PATH
     },
   };
 
   base::FilePath expected_virtual_path(
       GetPathInDownloadDir(FILE_PATH_LITERAL("virtual/foo.txt")));
   // The default download directory is the virtual path.
-  SetDefaultDownloadPath(test_virtual_dir());
+  download_prefs()->SetDownloadPath(test_virtual_dir());
   // Simulate failed call to DetermineLocalPath.
   EXPECT_CALL(*delegate(), DetermineLocalPath(
       _, GetPathInDownloadDir(FILE_PATH_LITERAL("virtual/foo.txt")), _))
       .WillOnce(WithArg<2>(ScheduleCallback(base::FilePath())));
   RunTestCasesWithActiveItem(kLocalPathFailedCases,
                              arraysize(kLocalPathFailedCases));
 }
 
 // Downloads that have a danger level of AllowOnUserGesture should be marked as
 // safe depending on whether there was a user gesture associated with the
@@ skipping 413 matching lines @@
     EXPECT_CRDOWNLOAD
   };
 
   const DownloadTestCase& test_case = kNotifyExtensionsTestCase;
   scoped_ptr<content::MockDownloadItem> item(
       CreateActiveDownloadItem(0, test_case));
   base::FilePath overridden_path(FILE_PATH_LITERAL("overridden/foo.txt"));
   base::FilePath full_overridden_path =
       GetPathInDownloadDir(overridden_path.value());
 
-  // The last selected directory is this one. Since the test case is a SAVE_AS
-  // download, it should use this directory for the generated path.
-  set_last_selected_directory(GetPathInDownloadDir(
+  download_prefs()->SetSaveFilePath(GetPathInDownloadDir(
       FILE_PATH_LITERAL("last_selected")));
 
   EXPECT_CALL(*delegate(), NotifyExtensions(_, _, _))
       .WillOnce(WithArg<2>(
           ScheduleCallback2(overridden_path,
                             DownloadPathReservationTracker::UNIQUIFY)));
   EXPECT_CALL(*delegate(),
               PromptUserForDownloadPath(_, full_overridden_path, _))
       .WillOnce(WithArg<2>(
           ScheduleCallback(full_overridden_path)));
   RunTestCase(test_case, item.get());
 }
 }  // namespace