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/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 215 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"));
+  download_prefs_->SetDownloadPath(test_download_dir());
+  download_prefs_->SetSaveFilePath(test_download_dir());
   SetDefaultDownloadPath(test_download_dir());
   delegate_.SetupDefaults();
 }
 
 void DownloadTargetDeterminerTest::TearDown() {
   download_prefs_.reset();
   message_loop_.RunUntilIdle();
   ChromeRenderViewHostTestHarness::TearDown();
 }
 
@@ skipping 56 matching lines @@
   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);
+  download_prefs()->SetDownloadPath(path);
+  download_prefs()->SetSaveFilePath(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 403 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()

[asanka, 2013/05/07 15:15:12]

Can you add a descriptive SCOPED_TRACE() here?

[benjhayden, 2013/05/17 20:31:54]

Done.

-                 << "Running with empty last_selected_directory");
     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));
   }
 }
 
@@ skipping 613 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(

[asanka, 2013/05/07 15:15:12]

The purpose of this test is to verify that that when an extension overrides a
path, we use a one relative to the default download path instead of the last
selected path. If the last save path isn't being set, then this isn't testing
anything new.

The case where the last save path is the same as the default downloads path is
already covered in the TargetDeterminer_NotifyExtensionsSafe test.

[benjhayden, 2013/05/17 20:31:54]

Done.

-      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