Home | History | Annotate | Download | only in test 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/public/test/download_test_observer.h"
      6 
      7 #include <vector>
      8 
      9 #include "base/bind.h"
     10 #include "base/logging.h"
     11 #include "base/message_loop/message_loop.h"
     12 #include "base/stl_util.h"
     13 #include "base/threading/sequenced_worker_pool.h"
     14 #include "content/public/browser/browser_thread.h"
     15 #include "content/public/browser/download_url_parameters.h"
     16 #include "content/public/test/test_utils.h"
     17 #include "testing/gtest/include/gtest/gtest.h"
     18 
     19 namespace content {
     20 
     21 DownloadUpdatedObserver::DownloadUpdatedObserver(
     22     DownloadItem* item, DownloadUpdatedObserver::EventFilter filter)
     23     : item_(item),
     24       filter_(filter),
     25       waiting_(false),
     26       event_seen_(false) {
     27   item->AddObserver(this);
     28 }
     29 
     30 DownloadUpdatedObserver::~DownloadUpdatedObserver() {
     31   if (item_)
     32     item_->RemoveObserver(this);
     33 }
     34 
     35 bool DownloadUpdatedObserver::WaitForEvent() {
     36   if (item_ && filter_.Run(item_))
     37     event_seen_ = true;
     38   if (event_seen_)
     39     return true;
     40 
     41   waiting_ = true;
     42   RunMessageLoop();
     43   waiting_ = false;
     44   return event_seen_;
     45 }
     46 
     47 void DownloadUpdatedObserver::OnDownloadUpdated(DownloadItem* item) {
     48   DCHECK_EQ(item_, item);
     49   if (filter_.Run(item_))
     50     event_seen_ = true;
     51   if (waiting_ && event_seen_)
     52     base::MessageLoopForUI::current()->Quit();
     53 }
     54 
     55 void DownloadUpdatedObserver::OnDownloadDestroyed(DownloadItem* item) {
     56   DCHECK_EQ(item_, item);
     57   item_->RemoveObserver(this);
     58   item_ = NULL;
     59   if (waiting_)
     60     base::MessageLoopForUI::current()->Quit();
     61 }
     62 
     63 DownloadTestObserver::DownloadTestObserver(
     64     DownloadManager* download_manager,
     65     size_t wait_count,
     66     DangerousDownloadAction dangerous_download_action)
     67     : download_manager_(download_manager),
     68       wait_count_(wait_count),
     69       finished_downloads_at_construction_(0),
     70       waiting_(false),
     71       dangerous_download_action_(dangerous_download_action),
     72       weak_factory_(this) {
     73 }
     74 
     75 DownloadTestObserver::~DownloadTestObserver() {
     76   for (DownloadSet::iterator it = downloads_observed_.begin();
     77        it != downloads_observed_.end(); ++it)
     78     (*it)->RemoveObserver(this);
     79 
     80   if (download_manager_)
     81     download_manager_->RemoveObserver(this);
     82 }
     83 
     84 void DownloadTestObserver::Init() {
     85   download_manager_->AddObserver(this);
     86   std::vector<DownloadItem*> downloads;
     87   download_manager_->GetAllDownloads(&downloads);
     88   for (std::vector<DownloadItem*>::iterator it = downloads.begin();
     89        it != downloads.end(); ++it) {
     90     OnDownloadCreated(download_manager_, *it);
     91   }
     92   finished_downloads_at_construction_ = finished_downloads_.size();
     93   states_observed_.clear();
     94 }
     95 
     96 void DownloadTestObserver::ManagerGoingDown(DownloadManager* manager) {
     97   CHECK_EQ(manager, download_manager_);
     98   download_manager_ = NULL;
     99   SignalIfFinished();
    100 }
    101 
    102 void DownloadTestObserver::WaitForFinished() {
    103   if (!IsFinished()) {
    104     waiting_ = true;
    105     RunMessageLoop();
    106     waiting_ = false;
    107   }
    108 }
    109 
    110 bool DownloadTestObserver::IsFinished() const {
    111   return (finished_downloads_.size() - finished_downloads_at_construction_ >=
    112           wait_count_) || (download_manager_ == NULL);
    113 }
    114 
    115 void DownloadTestObserver::OnDownloadCreated(
    116     DownloadManager* manager,
    117     DownloadItem* item) {
    118   // NOTE: This method is called both by DownloadManager when a download is
    119   // created as well as in DownloadTestObserver::Init() for downloads that
    120   // existed before |this| was created.
    121   OnDownloadUpdated(item);
    122   DownloadSet::const_iterator finished_it(finished_downloads_.find(item));
    123   // If it isn't finished, start observing it.
    124   if (finished_it == finished_downloads_.end()) {
    125     item->AddObserver(this);
    126     downloads_observed_.insert(item);
    127   }
    128 }
    129 
    130 void DownloadTestObserver::OnDownloadDestroyed(DownloadItem* download) {
    131   // Stop observing.  Do not do anything with it, as it is about to be gone.
    132   DownloadSet::iterator it = downloads_observed_.find(download);
    133   ASSERT_TRUE(it != downloads_observed_.end());
    134   downloads_observed_.erase(it);
    135   download->RemoveObserver(this);
    136 }
    137 
    138 void DownloadTestObserver::OnDownloadUpdated(DownloadItem* download) {
    139   // Real UI code gets the user's response after returning from the observer.
    140   if (download->IsDangerous() &&
    141       !ContainsKey(dangerous_downloads_seen_, download->GetId())) {
    142     dangerous_downloads_seen_.insert(download->GetId());
    143 
    144     // Calling ValidateDangerousDownload() at this point will
    145     // cause the download to be completed twice.  Do what the real UI
    146     // code does: make the call as a delayed task.
    147     switch (dangerous_download_action_) {
    148       case ON_DANGEROUS_DOWNLOAD_ACCEPT:
    149         // Fake user click on "Accept".  Delay the actual click, as the
    150         // real UI would.
    151         BrowserThread::PostTask(
    152             BrowserThread::UI, FROM_HERE,
    153             base::Bind(&DownloadTestObserver::AcceptDangerousDownload,
    154                        weak_factory_.GetWeakPtr(),
    155                        download->GetId()));
    156         break;
    157 
    158       case ON_DANGEROUS_DOWNLOAD_DENY:
    159         // Fake a user click on "Deny".  Delay the actual click, as the
    160         // real UI would.
    161         BrowserThread::PostTask(
    162             BrowserThread::UI, FROM_HERE,
    163             base::Bind(&DownloadTestObserver::DenyDangerousDownload,
    164                        weak_factory_.GetWeakPtr(),
    165                        download->GetId()));
    166         break;
    167 
    168       case ON_DANGEROUS_DOWNLOAD_FAIL:
    169         ADD_FAILURE() << "Unexpected dangerous download item.";
    170         break;
    171 
    172       case ON_DANGEROUS_DOWNLOAD_IGNORE:
    173         break;
    174 
    175       case ON_DANGEROUS_DOWNLOAD_QUIT:
    176         DownloadInFinalState(download);
    177         break;
    178 
    179       default:
    180         NOTREACHED();
    181     }
    182   }
    183 
    184   if (IsDownloadInFinalState(download))
    185     DownloadInFinalState(download);
    186 }
    187 
    188 size_t DownloadTestObserver::NumDangerousDownloadsSeen() const {
    189   return dangerous_downloads_seen_.size();
    190 }
    191 
    192 size_t DownloadTestObserver::NumDownloadsSeenInState(
    193     DownloadItem::DownloadState state) const {
    194   StateMap::const_iterator it = states_observed_.find(state);
    195 
    196   if (it == states_observed_.end())
    197     return 0;
    198 
    199   return it->second;
    200 }
    201 
    202 void DownloadTestObserver::DownloadInFinalState(DownloadItem* download) {
    203   if (finished_downloads_.find(download) != finished_downloads_.end()) {
    204     // We've already seen the final state on this download.
    205     return;
    206   }
    207 
    208   // Record the transition.
    209   finished_downloads_.insert(download);
    210 
    211   // Record the state.
    212   states_observed_[download->GetState()]++;  // Initializes to 0 the first time.
    213 
    214   SignalIfFinished();
    215 }
    216 
    217 void DownloadTestObserver::SignalIfFinished() {
    218   if (waiting_ && IsFinished())
    219     base::MessageLoopForUI::current()->Quit();
    220 }
    221 
    222 void DownloadTestObserver::AcceptDangerousDownload(uint32 download_id) {
    223   // Download manager was shutdown before the UI thread could accept the
    224   // download.
    225   if (!download_manager_)
    226     return;
    227   DownloadItem* download = download_manager_->GetDownload(download_id);
    228   if (download && !download->IsDone())
    229     download->ValidateDangerousDownload();
    230 }
    231 
    232 void DownloadTestObserver::DenyDangerousDownload(uint32 download_id) {
    233   // Download manager was shutdown before the UI thread could deny the
    234   // download.
    235   if (!download_manager_)
    236     return;
    237   DownloadItem* download = download_manager_->GetDownload(download_id);
    238   if (download && !download->IsDone())
    239     download->Remove();
    240 }
    241 
    242 DownloadTestObserverTerminal::DownloadTestObserverTerminal(
    243     DownloadManager* download_manager,
    244     size_t wait_count,
    245     DangerousDownloadAction dangerous_download_action)
    246         : DownloadTestObserver(download_manager,
    247                                wait_count,
    248                                dangerous_download_action) {
    249   // You can't rely on overriden virtual functions in a base class constructor;
    250   // the virtual function table hasn't been set up yet.  So, we have to do any
    251   // work that depends on those functions in the derived class constructor
    252   // instead.  In this case, it's because of |IsDownloadInFinalState()|.
    253   Init();
    254 }
    255 
    256 DownloadTestObserverTerminal::~DownloadTestObserverTerminal() {
    257 }
    258 
    259 
    260 bool DownloadTestObserverTerminal::IsDownloadInFinalState(
    261     DownloadItem* download) {
    262   return download->IsDone();
    263 }
    264 
    265 DownloadTestObserverInProgress::DownloadTestObserverInProgress(
    266     DownloadManager* download_manager,
    267     size_t wait_count)
    268         : DownloadTestObserver(download_manager,
    269                                wait_count,
    270                                ON_DANGEROUS_DOWNLOAD_ACCEPT) {
    271   // You can't override virtual functions in a base class constructor; the
    272   // virtual function table hasn't been set up yet.  So, we have to do any
    273   // work that depends on those functions in the derived class constructor
    274   // instead.  In this case, it's because of |IsDownloadInFinalState()|.
    275   Init();
    276 }
    277 
    278 DownloadTestObserverInProgress::~DownloadTestObserverInProgress() {
    279 }
    280 
    281 
    282 bool DownloadTestObserverInProgress::IsDownloadInFinalState(
    283     DownloadItem* download) {
    284   return (download->GetState() == DownloadItem::IN_PROGRESS) &&
    285       !download->GetTargetFilePath().empty();
    286 }
    287 
    288 DownloadTestObserverInterrupted::DownloadTestObserverInterrupted(
    289     DownloadManager* download_manager,
    290     size_t wait_count,
    291     DangerousDownloadAction dangerous_download_action)
    292         : DownloadTestObserver(download_manager,
    293                                wait_count,
    294                                dangerous_download_action) {
    295   // You can't rely on overriden virtual functions in a base class constructor;
    296   // the virtual function table hasn't been set up yet.  So, we have to do any
    297   // work that depends on those functions in the derived class constructor
    298   // instead.  In this case, it's because of |IsDownloadInFinalState()|.
    299   Init();
    300 }
    301 
    302 DownloadTestObserverInterrupted::~DownloadTestObserverInterrupted() {
    303 }
    304 
    305 
    306 bool DownloadTestObserverInterrupted::IsDownloadInFinalState(
    307     DownloadItem* download) {
    308   return download->GetState() == DownloadItem::INTERRUPTED;
    309 }
    310 
    311 DownloadTestFlushObserver::DownloadTestFlushObserver(
    312     DownloadManager* download_manager)
    313     : download_manager_(download_manager),
    314       waiting_for_zero_inprogress_(true) {}
    315 
    316 void DownloadTestFlushObserver::WaitForFlush() {
    317   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    318   download_manager_->AddObserver(this);
    319   // The wait condition may have been met before WaitForFlush() was called.
    320   CheckDownloadsInProgress(true);
    321   BrowserThread::GetBlockingPool()->FlushForTesting();
    322   RunMessageLoop();
    323 }
    324 
    325 void DownloadTestFlushObserver::OnDownloadCreated(
    326     DownloadManager* manager,
    327     DownloadItem* item) {
    328   CheckDownloadsInProgress(true);
    329 }
    330 
    331 void DownloadTestFlushObserver::OnDownloadDestroyed(DownloadItem* download) {
    332   // Stop observing.  Do not do anything with it, as it is about to be gone.
    333   DownloadSet::iterator it = downloads_observed_.find(download);
    334   ASSERT_TRUE(it != downloads_observed_.end());
    335   downloads_observed_.erase(it);
    336   download->RemoveObserver(this);
    337 }
    338 
    339 void DownloadTestFlushObserver::OnDownloadUpdated(DownloadItem* download) {
    340   // No change in DownloadItem set on manager.
    341   CheckDownloadsInProgress(false);
    342 }
    343 
    344 DownloadTestFlushObserver::~DownloadTestFlushObserver() {
    345   download_manager_->RemoveObserver(this);
    346   for (DownloadSet::iterator it = downloads_observed_.begin();
    347        it != downloads_observed_.end(); ++it) {
    348     (*it)->RemoveObserver(this);
    349   }
    350 }
    351 
    352 // If we're waiting for that flush point, check the number
    353 // of downloads in the IN_PROGRESS state and take appropriate
    354 // action.  If requested, also observes all downloads while iterating.
    355 void DownloadTestFlushObserver::CheckDownloadsInProgress(
    356     bool observe_downloads) {
    357   if (waiting_for_zero_inprogress_) {
    358     int count = 0;
    359 
    360     std::vector<DownloadItem*> downloads;
    361     download_manager_->GetAllDownloads(&downloads);
    362     for (std::vector<DownloadItem*>::iterator it = downloads.begin();
    363          it != downloads.end(); ++it) {
    364       if ((*it)->GetState() == DownloadItem::IN_PROGRESS)
    365         count++;
    366       if (observe_downloads) {
    367         if (downloads_observed_.find(*it) == downloads_observed_.end()) {
    368           (*it)->AddObserver(this);
    369           downloads_observed_.insert(*it);
    370         }
    371         // Download items are forever, and we don't want to make
    372         // assumptions about future state transitions, so once we
    373         // start observing them, we don't stop until destruction.
    374       }
    375     }
    376 
    377     if (count == 0) {
    378       waiting_for_zero_inprogress_ = false;
    379       // Stop observing DownloadItems.  We maintain the observation
    380       // of DownloadManager so that we don't have to independently track
    381       // whether we are observing it for conditional destruction.
    382       for (DownloadSet::iterator it = downloads_observed_.begin();
    383            it != downloads_observed_.end(); ++it) {
    384         (*it)->RemoveObserver(this);
    385       }
    386       downloads_observed_.clear();
    387 
    388       // Trigger next step.  We need to go past the IO thread twice, as
    389       // there's a self-task posting in the IO thread cancel path.
    390       BrowserThread::PostTask(
    391           BrowserThread::FILE, FROM_HERE,
    392           base::Bind(&DownloadTestFlushObserver::PingFileThread, this, 2));
    393     }
    394   }
    395 }
    396 
    397 void DownloadTestFlushObserver::PingFileThread(int cycle) {
    398   BrowserThread::PostTask(
    399       BrowserThread::IO, FROM_HERE,
    400       base::Bind(&DownloadTestFlushObserver::PingIOThread, this, cycle));
    401 }
    402 
    403 void DownloadTestFlushObserver::PingIOThread(int cycle) {
    404   if (--cycle) {
    405     BrowserThread::PostTask(
    406         BrowserThread::UI, FROM_HERE,
    407         base::Bind(&DownloadTestFlushObserver::PingFileThread, this, cycle));
    408   } else {
    409     BrowserThread::PostTask(
    410         BrowserThread::UI, FROM_HERE, base::MessageLoop::QuitClosure());
    411   }
    412 }
    413 
    414 DownloadTestItemCreationObserver::DownloadTestItemCreationObserver()
    415     : download_id_(DownloadItem::kInvalidId),
    416       interrupt_reason_(DOWNLOAD_INTERRUPT_REASON_NONE),
    417       called_back_count_(0),
    418       waiting_(false) {
    419 }
    420 
    421 DownloadTestItemCreationObserver::~DownloadTestItemCreationObserver() {
    422 }
    423 
    424 void DownloadTestItemCreationObserver::WaitForDownloadItemCreation() {
    425   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    426 
    427   if (called_back_count_ == 0) {
    428     waiting_ = true;
    429     RunMessageLoop();
    430     waiting_ = false;
    431   }
    432 }
    433 
    434 void DownloadTestItemCreationObserver::DownloadItemCreationCallback(
    435     DownloadItem* item,
    436     DownloadInterruptReason interrupt_reason) {
    437   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    438 
    439   if (item)
    440     download_id_ = item->GetId();
    441   interrupt_reason_ = interrupt_reason;
    442   ++called_back_count_;
    443   DCHECK_EQ(1u, called_back_count_);
    444 
    445   if (waiting_)
    446     base::MessageLoopForUI::current()->Quit();
    447 }
    448 
    449 const DownloadUrlParameters::OnStartedCallback
    450     DownloadTestItemCreationObserver::callback() {
    451   return base::Bind(
    452       &DownloadTestItemCreationObserver::DownloadItemCreationCallback, this);
    453 }
    454 
    455 }  // namespace content
    456