Make web store resilient against download completion happening before opening.

content/public/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"
@@ skipping 26 matching lines @@
 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
 
+DownloadUpdatedObserver::DownloadUpdatedObserver(
+    DownloadItem* item, DownloadUpdatedObserver::EventFilter filter)
+    : item_(item), filter_(filter), waiting_(false), event_seen_(false) {
+  item->AddObserver(this);
+}
+
+DownloadUpdatedObserver::~DownloadUpdatedObserver() {
+  if (item_)
+    item_->RemoveObserver(this);
+}
+
+bool DownloadUpdatedObserver::WaitForEvent() {
+  if (item_ && filter_.Run(item_))
+    return true;
+
+  waiting_ = true;
+  RunMessageLoop();
+  waiting_ = false;
+  return event_seen_;

[benjhayden, 2012/09/10 17:37:29]

Nice!

What if WaitForEvent() is called on the same DUO twice?
bool seen = event_seen_;
event_seen_ = false;
return seen;

[Randy Smith (Not in Mondays), 2012/09/10 18:32:34]

I think of this type of class as tracking whether the event occurred in the
window between when the class is constructed and when WaitForEvent() is called. 
For that, event_seen_ shouldn't be reset.  Having said that, it *should* be
tested upon entry so that you don't wait forever.  I'll fix that.  

+}
+
+void DownloadUpdatedObserver::OnDownloadUpdated(DownloadItem* item) {
+  DCHECK_EQ(item_, item);
+  if (filter_.Run(item_))
+    event_seen_ = true;
+  if (waiting_ && event_seen_)
+    MessageLoopForUI::current()->Quit();
+}
+
+void DownloadUpdatedObserver::OnDownloadDestroyed(DownloadItem* item) {
+  DCHECK_EQ(item_, item);
+  item_->RemoveObserver(this);
+  item_ = NULL;
+  if (waiting_)
+    MessageLoopForUI::current()->Quit();
+}
+
 DownloadTestObserver::DownloadTestObserver(
     DownloadManager* download_manager,
     size_t wait_count,
     DangerousDownloadAction dangerous_download_action)
     : download_manager_(download_manager),
       wait_count_(wait_count),
       finished_downloads_at_construction_(0),
       waiting_(false),
       dangerous_download_action_(dangerous_download_action) {
 }
@@ skipping 319 matching lines @@
     MessageLoopForUI::current()->Quit();
 }
 
 const DownloadUrlParameters::OnStartedCallback
     DownloadTestItemCreationObserver::callback() {
   return base::Bind(
       &DownloadTestItemCreationObserver::DownloadItemCreationCallback, this);
 }
 
 }  // namespace content