Move DownloadTestObserver and friends down into content.

content/test/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 "content/public/test/download_test_observer.h"
+
 #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"
+#include "content/public/test/test_utils.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
-using content::BrowserThread;
-using content::DownloadItem;
-using content::DownloadManager;
+namespace content {
 
 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.
 
@@ skipping 36 matching lines @@
 
 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;
-    content::RunMessageLoop();
+    RunMessageLoop();
     waiting_ = false;
   }
 }
 
 bool DownloadTestObserver::IsFinished() const {
   return (finished_downloads_.size() - finished_downloads_at_construction_ >=
           wait_count_);
 }
 
 void DownloadTestObserver::OnDownloadDestroyed(DownloadItem* download) {
@@ skipping 80 matching lines @@
       continue;
     }
   }
 }
 
 size_t DownloadTestObserver::NumDangerousDownloadsSeen() const {
   return dangerous_downloads_seen_.size();
 }
 
 size_t DownloadTestObserver::NumDownloadsSeenInState(
-    content::DownloadItem::DownloadState state) const {
+    DownloadItem::DownloadState state) const {
   StateMap::const_iterator it = states_observed_.find(state);
 
   if (it == states_observed_.end())
     return 0;
 
   return it->second;
 }
 
 void DownloadTestObserver::DownloadInFinalState(DownloadItem* download) {
   if (finished_downloads_.find(download) != finished_downloads_.end()) {
     // We've already seen the final state on this download.
     return;
   }
 
   // Record the transition.
   finished_downloads_.insert(download);
 
   // Record the state.
   states_observed_[download->GetState()]++;  // Initializes to 0 the first time.
 
   SignalIfFinished();
 }
 
 void DownloadTestObserver::SignalIfFinished() {
   if (waiting_ && IsFinished())
     MessageLoopForUI::current()->Quit();
 }
 
 DownloadTestObserverTerminal::DownloadTestObserverTerminal(
-    content::DownloadManager* download_manager,
+    DownloadManager* download_manager,
     size_t wait_count,
     DangerousDownloadAction dangerous_download_action)
         : DownloadTestObserver(download_manager,
                                wait_count,
                                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) {
+    DownloadItem* download) {
   return (download->GetState() != DownloadItem::IN_PROGRESS);
 }
 
 DownloadTestObserverInProgress::DownloadTestObserverInProgress(
-    content::DownloadManager* download_manager,
+    DownloadManager* download_manager,
     size_t wait_count)
         : DownloadTestObserver(download_manager,
                                wait_count,
                                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() {
 }
 
 
 bool DownloadTestObserverInProgress::IsDownloadInFinalState(
-    content::DownloadItem* download) {
+    DownloadItem* download) {
   return (download->GetState() == DownloadItem::IN_PROGRESS);
 }
 
 DownloadTestFlushObserver::DownloadTestFlushObserver(
     DownloadManager* download_manager)
     : download_manager_(download_manager),
       waiting_for_zero_inprogress_(true) {}
 
 void DownloadTestFlushObserver::WaitForFlush() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   download_manager_->AddObserver(this);
-  content::RunMessageLoop();
+  RunMessageLoop();
 }
 
 void DownloadTestFlushObserver::ModelChanged(DownloadManager* manager) {
   // Model has changed, so there may be more DownloadItems to observe.
   CheckDownloadsInProgress(true);
 }
 
 void DownloadTestFlushObserver::OnDownloadDestroyed(DownloadItem* download) {
   // Stop observing.  Do not do anything with it, as it is about to be gone.
   DownloadSet::iterator it = downloads_observed_.find(download);
@@ skipping 71 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&DownloadTestFlushObserver::PingFileThread, this, cycle));
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, MessageLoop::QuitClosure());
   }
 }
 
 DownloadTestItemCreationObserver::DownloadTestItemCreationObserver()
-    : download_id_(content::DownloadId::Invalid()),
+    : download_id_(DownloadId::Invalid()),
       error_(net::OK),
       called_back_count_(0),
       waiting_(false) {
 }
 
 DownloadTestItemCreationObserver::~DownloadTestItemCreationObserver() {
 }
 
 void DownloadTestItemCreationObserver::WaitForDownloadItemCreation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (called_back_count_ == 0) {
     waiting_ = true;
-    content::RunMessageLoop();
+    RunMessageLoop();
     waiting_ = false;
   }
 }
 
 void DownloadTestItemCreationObserver::DownloadItemCreationCallback(
-    content::DownloadId download_id, net::Error error) {
+    DownloadId download_id, net::Error error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   download_id_ = download_id;
   error_ = error;
   ++called_back_count_;
   DCHECK_EQ(1u, called_back_count_);
 
   if (waiting_)
     MessageLoopForUI::current()->Quit();
 }
 
-const content::DownloadUrlParameters::OnStartedCallback
+const 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();
-}
+}  // namespace content