Download filename determination refactor (3/3)

chrome/browser/download/download_test_observer.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 <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
+#include "chrome/browser/download/chrome_download_manager_delegate.h"
+#include "chrome/browser/download/download_service.h"
+#include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_test_observer.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_url_parameters.h"
 
 using content::BrowserThread;
 using content::DownloadItem;
 using content::DownloadManager;
 
+namespace {
+
 // These functions take scoped_refptr's to DownloadManager because they
 // are posted to message queues, and hence may execute arbitrarily after
 // their actual posting.  Once posted, there is no connection between
 // these routines and the DownloadTestObserver class from which
 // they came, so the DownloadTestObserver's reference to the
 // DownloadManager cannot be counted on to keep the DownloadManager around.
 
 // Fake user click on "Accept".
 void AcceptDangerousDownload(scoped_refptr<DownloadManager> download_manager,
                              int32 download_id) {
   DownloadItem* download = download_manager->GetDownloadItem(download_id);
   download->DangerousDownloadValidated();
 }
 
 // Fake user click on "Deny".
 void DenyDangerousDownload(scoped_refptr<DownloadManager> download_manager,
                            int32 download_id) {
   DownloadItem* download = download_manager->GetDownloadItem(download_id);
   ASSERT_TRUE(download->IsPartialDownload());
   download->Cancel(true);
   download->Delete(DownloadItem::DELETE_DUE_TO_USER_DISCARD);
 }
 
+}  // namespace
+
 DownloadTestObserver::DownloadTestObserver(
     DownloadManager* download_manager,
     size_t wait_count,
-    bool finish_on_select_file,
     DangerousDownloadAction dangerous_download_action)
     : download_manager_(download_manager),
       wait_count_(wait_count),
       finished_downloads_at_construction_(0),
       waiting_(false),
-      finish_on_select_file_(finish_on_select_file),
-      select_file_dialog_seen_(false),
       dangerous_download_action_(dangerous_download_action) {
 }
 
 DownloadTestObserver::~DownloadTestObserver() {
   for (DownloadSet::iterator it = downloads_observed_.begin();
        it != downloads_observed_.end(); ++it)
     (*it)->RemoveObserver(this);
 
   download_manager_->RemoveObserver(this);
 }
 
 void DownloadTestObserver::Init() {
   download_manager_->AddObserver(this);  // Will call initial ModelChanged().
   finished_downloads_at_construction_ = finished_downloads_.size();
   states_observed_.clear();
 }
 
 void DownloadTestObserver::WaitForFinished() {
   if (!IsFinished()) {
     waiting_ = true;
     ui_test_utils::RunMessageLoop();
     waiting_ = false;
   }
 }
 
 bool DownloadTestObserver::IsFinished() const {
-  if (finished_downloads_.size() - finished_downloads_at_construction_ >=
-      wait_count_)
-    return true;
-  return (finish_on_select_file_ && select_file_dialog_seen_);
+  return (finished_downloads_.size() - finished_downloads_at_construction_ >=
+          wait_count_);
 }
 
 void DownloadTestObserver::OnDownloadUpdated(DownloadItem* download) {
   // The REMOVING state indicates that the download is being destroyed.
   // Stop observing.  Do not do anything with it, as it is about to be gone.
   if (download->GetState() == DownloadItem::REMOVING) {
     DownloadSet::iterator it = downloads_observed_.find(download);
     ASSERT_TRUE(it != downloads_observed_.end());
     downloads_observed_.erase(it);
     download->RemoveObserver(this);
@@ skipping 70 matching lines @@
     // If it is finished and we are observing it, stop.
     if (finished_it != finished_downloads_.end() &&
         observed_it != downloads_observed_.end()) {
       (*it)->RemoveObserver(this);
       downloads_observed_.erase(observed_it);
       continue;
     }
   }
 }
 
-void DownloadTestObserver::SelectFileDialogDisplayed(
-    DownloadManager* manager, int32 /* id */) {
-  DCHECK_EQ(manager, download_manager_);
-  select_file_dialog_seen_ = true;
-  SignalIfFinished();
-}
-
 size_t DownloadTestObserver::NumDangerousDownloadsSeen() const {
   return dangerous_downloads_seen_.size();
 }
 
 size_t DownloadTestObserver::NumDownloadsSeenInState(
     content::DownloadItem::DownloadState state) const {
   StateMap::const_iterator it = states_observed_.find(state);
 
   if (it == states_observed_.end())
     return 0;
@@ skipping 17 matching lines @@
 }
 
 void DownloadTestObserver::SignalIfFinished() {
   if (waiting_ && IsFinished())
     MessageLoopForUI::current()->Quit();
 }
 
 DownloadTestObserverTerminal::DownloadTestObserverTerminal(
     content::DownloadManager* download_manager,
     size_t wait_count,
-    bool finish_on_select_file,
     DangerousDownloadAction dangerous_download_action)
         : DownloadTestObserver(download_manager,
                                wait_count,
-                               finish_on_select_file,
                                dangerous_download_action) {
   // You can't rely on overriden virtual functions in a base class constructor;
   // the virtual function table hasn't been set up yet.  So, we have to do any
   // work that depends on those functions in the derived class constructor
   // instead.  In this case, it's because of |IsDownloadInFinalState()|.
   Init();
 }
 
 DownloadTestObserverTerminal::~DownloadTestObserverTerminal() {
 }
 
 
 bool DownloadTestObserverTerminal::IsDownloadInFinalState(
     content::DownloadItem* download) {
   return (download->GetState() != DownloadItem::IN_PROGRESS);
 }
 
 DownloadTestObserverInProgress::DownloadTestObserverInProgress(
     content::DownloadManager* download_manager,
-    size_t wait_count,
-    bool finish_on_select_file)
+    size_t wait_count)
         : DownloadTestObserver(download_manager,
                                wait_count,
-                               finish_on_select_file,
                                ON_DANGEROUS_DOWNLOAD_ACCEPT) {
   // You can't override virtual functions in a base class constructor; the
   // virtual function table hasn't been set up yet.  So, we have to do any
   // work that depends on those functions in the derived class constructor
   // instead.  In this case, it's because of |IsDownloadInFinalState()|.
   Init();
 }
 
 DownloadTestObserverInProgress::~DownloadTestObserverInProgress() {
 }
@@ skipping 137 matching lines @@
   if (waiting_)
     MessageLoopForUI::current()->Quit();
 }
 
 const content::DownloadUrlParameters::OnStartedCallback
     DownloadTestItemCreationObserver::callback() {
   return base::Bind(
       &DownloadTestItemCreationObserver::DownloadItemCreationCallback, this);
 }
 
+namespace internal {
+
+// Test ChromeDownloadManagerDelegate that controls whether how file chooser
+// dialogs are handled. By default, file chooser dialogs are disabled.
+class MockFileChooserDownloadManagerDelegate
+    : public ChromeDownloadManagerDelegate {
+ public:
+  explicit MockFileChooserDownloadManagerDelegate(Profile* profile)
+      : ChromeDownloadManagerDelegate(profile),
+        file_chooser_enabled_(false),
+        file_chooser_displayed_(false) {}
+
+  void EnableFileChooser(bool enable) {
+    file_chooser_enabled_ = enable;
+  }
+
+  bool TestAndResetDidShowFileChooser() {
+    bool did_show = file_chooser_displayed_;
+    file_chooser_displayed_ = false;
+    return did_show;
+  }
+
+ private:
+  virtual ~MockFileChooserDownloadManagerDelegate() {}
+
+  virtual void ChooseDownloadPath(DownloadItem* item,
+                                  const FilePath& suggested_path,
+                                  const FileSelectedCallback&
+                                      callback) OVERRIDE {
+    file_chooser_displayed_ = true;
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   (file_chooser_enabled_ ? suggested_path : FilePath())));
+  }
+
+  bool file_chooser_enabled_;
+  bool file_chooser_displayed_;
+};
+
+}  // namespace internal
+
+DownloadTestFileChooserObserver::DownloadTestFileChooserObserver(
+    Profile* profile) {
+  test_delegate_ =
+      new internal::MockFileChooserDownloadManagerDelegate(profile);
+  DownloadServiceFactory::GetForProfile(profile)->
+      SetDownloadManagerDelegateForTesting(test_delegate_.get());
+}
+
+DownloadTestFileChooserObserver::~DownloadTestFileChooserObserver() {
+}
+
+void DownloadTestFileChooserObserver::EnableFileChooser(bool enable) {
+  test_delegate_->EnableFileChooser(enable);
+}
+
+bool DownloadTestFileChooserObserver::TestAndResetDidShowFileChooser() {
+  return test_delegate_->TestAndResetDidShowFileChooser();
+}