Fixed issue with DownloadTestObserver.

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"
@@ skipping 36 matching lines @@
     DangerousDownloadAction dangerous_download_action)
     : download_manager_(download_manager),
       wait_count_(wait_count),
       finished_downloads_at_construction_(0),
       waiting_(false),
       download_finished_state_(download_finished_state),
       finish_on_select_file_(finish_on_select_file),
       select_file_dialog_seen_(false),
       dangerous_download_action_(dangerous_download_action) {
   download_manager_->AddObserver(this);  // Will call initial ModelChanged().
   finished_downloads_at_construction_ = finished_downloads_.size();

[Randy Smith (Not in Mondays), 2012/03/01 21:07:53]

This member variable is now redundant with keeping the full list; I'd get rid of
it and just used finished_other_downloads_.size().

[ahendrickson, 2012/03/02 17:29:41]

The list excludes items that match download_finished_state_, so it can't replace
that variable.

+  // Move the finished other downloads to an exclusion list.
+  finished_other_downloads_.swap(previously_finished_downloads_);
   EXPECT_NE(DownloadItem::REMOVING, download_finished_state)
       << "Waiting for REMOVING is not supported.  Try COMPLETE.";
 }
 
 DownloadTestObserver::~DownloadTestObserver() {
   for (DownloadSet::iterator it = downloads_observed_.begin();
        it != downloads_observed_.end(); ++it)
     (*it)->RemoveObserver(this);
 
   download_manager_->RemoveObserver(this);
 }
 
 void DownloadTestObserver::WaitForFinished() {
   if (!IsFinished()) {
     waiting_ = true;
     ui_test_utils::RunMessageLoop();
     waiting_ = false;
   }
+
+  // We do not expect to see downloads finishing in the wrong state.
+  EXPECT_EQ(0u, finished_other_downloads_.size());

[Randy Smith (Not in Mondays), 2012/03/01 21:07:53]

This is an extra constraint on behavior.  We may not currently have any tests
that rely on the old behavior, but it seems a shame to restrict behavior without
reason.

[ahendrickson, 2012/03/02 17:29:41]

Replaced with a logging statement.

 }
 
 bool DownloadTestObserver::IsFinished() const {
-  if (finished_downloads_.size() - finished_downloads_at_construction_ >=
-      wait_count_)
+  size_t finished_download_count =
+      finished_downloads_.size() +
+      finished_other_downloads_.size() -
+      finished_downloads_at_construction_;
+  if (finished_download_count >= wait_count_)
     return true;
   return (finish_on_select_file_ && select_file_dialog_seen_);
 }
 
 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());
@@ skipping 33 matching lines @@
         ADD_FAILURE() << "Unexpected dangerous download item.";
         break;
 
       default:
         NOTREACHED();
     }
   }
 
   if (download->GetState() == download_finished_state_) {
     DownloadInFinalState(download);
+  } else if (download->GetState() != DownloadItem::IN_PROGRESS) {
+    DownloadInTerminalState(download);
   }
 }
 
 void DownloadTestObserver::ModelChanged(DownloadManager* manager) {
   DCHECK_EQ(manager, download_manager_);
 
   // Regenerate DownloadItem observers.  If there are any download items
   // in our final state, note them in |finished_downloads_|
   // (done by |OnDownloadUpdated()|).
   std::vector<DownloadItem*> downloads;
@@ skipping 31 matching lines @@
     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::NumOtherDownloadsSeen() const {
+  return finished_other_downloads_.size();
+}
+
 void DownloadTestObserver::DownloadInFinalState(DownloadItem* download) {
   if (finished_downloads_.find(download) != finished_downloads_.end()) {
-    // We've already seen terminal state on this download.
+    // We've already seen the final state on this download.
     return;
   }
 
   // Record the transition.
   finished_downloads_.insert(download);
 
   SignalIfFinished();
 }
 
+void DownloadTestObserver::DownloadInTerminalState(DownloadItem* download) {
+  if (finished_downloads_.find(download) != finished_downloads_.end()) {
+    // We've already seen the final state on this download.
+    return;
+  }
+
+  if (previously_finished_downloads_.find(download) !=
+    previously_finished_downloads_.end()) {
+      // These occurred before we were constructed.
+      return;
+  }
+
+  if (finished_other_downloads_.find(download) !=
+      finished_other_downloads_.end()) {
+    // We've already seen the terminal state on this download.
+    return;
+  }
+
+  // Record the transition to a final state.
+  finished_other_downloads_.insert(download);
+
+  LOG(WARNING) << " " << __FUNCTION__ << "()"
+               << " download = " << download->DebugString(true);
+
+  SignalIfFinished();
+}
+
+
 void DownloadTestObserver::SignalIfFinished() {
   if (waiting_ && IsFinished())
     MessageLoopForUI::current()->Quit();
 }
 
 DownloadTestFlushObserver::DownloadTestFlushObserver(
     DownloadManager* download_manager)
     : download_manager_(download_manager),
       waiting_for_zero_inprogress_(true) {}
 
@@ skipping 85 matching lines @@
 void DownloadTestFlushObserver::PingIOThread(int cycle) {
   if (--cycle) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&DownloadTestFlushObserver::PingFileThread, this, cycle));
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, MessageLoop::QuitClosure());
   }
 }