Use IPC to wait for download in DownloadTest.

chrome/browser/automation/automation_provider_observers.cc

 // Copyright (c) 2009 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 "chrome/browser/automation/automation_provider_observers.h"
 
 #include "base/basictypes.h"
 #include "base/json/json_writer.h"
 #include "base/string_util.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/automation/automation_provider.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/browser_window.h"
 #include "chrome/browser/dom_operation_notification_details.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/login_prompt.h"
 #include "chrome/browser/metrics/metric_event_duration_details.h"
 #include "chrome/browser/printing/print_job.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
@@ skipping 129 matching lines @@
   if (reply_message_) {
     // This means we did not receive a notification for this navigation.
     // Send over a failed navigation status back to the caller to ensure that
     // the caller does not hang waiting for the response.
     IPC::ParamTraits<AutomationMsg_NavigationResponseValues>::Write(
         reply_message_, AUTOMATION_MSG_NAVIGATION_ERROR);
     automation_->Send(reply_message_);
     reply_message_ = NULL;
   }
 
-  automation_->RemoveNavigationStatusListener(this);
+  automation_->RemoveObserver(this);
 }
 
 void NavigationNotificationObserver::Observe(
     NotificationType type, const NotificationSource& source,
     const NotificationDetails& details) {
   // We listen for 2 events to determine when the navigation started because:
   // - when this is used by the WaitForNavigation method, we might be invoked
   // afer the load has started (but not after the entry was committed, as
   // WaitForNavigation compares times of the last navigation).
   // - when this is used with a page requiring authentication, we will not get
@@ skipping 54 matching lines @@
 TabStripNotificationObserver::~TabStripNotificationObserver() {
 }
 
 void TabStripNotificationObserver::Observe(NotificationType type,
                                            const NotificationSource& source,
                                            const NotificationDetails& details) {
   if (type == notification_) {
     ObserveTab(Source<NavigationController>(source).ptr());
 
     // If verified, no need to observe anymore
-    automation_->RemoveTabStripObserver(this);
+    automation_->RemoveObserver(this);
     delete this;
   } else {
     NOTREACHED();
   }
 }
 
 TabAppendedNotificationObserver::TabAppendedNotificationObserver(
     Browser* parent, AutomationProvider* automation,
     IPC::Message* reply_message)
     : TabStripNotificationObserver(NotificationType::TAB_PARENTED, automation),
@@ skipping 558 matching lines @@
       success_(false),
       reply_message_(reply_message) {
   registrar_.Add(this, NotificationType::PRINT_JOB_EVENT,
                  NotificationService::AllSources());
 }
 
 DocumentPrintedNotificationObserver::~DocumentPrintedNotificationObserver() {
   DCHECK(reply_message_ != NULL);
   AutomationMsg_PrintNow::WriteReplyParams(reply_message_, success_);
   automation_->Send(reply_message_);
-  automation_->RemoveNavigationStatusListener(this);
+  automation_->RemoveObserver(this);
 }
 
 void DocumentPrintedNotificationObserver::Observe(
     NotificationType type, const NotificationSource& source,
     const NotificationDetails& details) {
   using namespace printing;
   DCHECK(type == NotificationType::PRINT_JOB_EVENT);
   switch (Details<JobEventDetails>(details)->type()) {
     case JobEventDetails::JOB_DONE: {
       // Succeeded.
@@ skipping 65 matching lines @@
                                    const NotificationDetails& details) {
   DCHECK(type == NotificationType::LOGIN_AUTHENTICATION);
   Details<AuthenticationNotificationDetails> auth_details(details);
   AutomationMsg_LoginWithUserAndPass::WriteReplyParams(reply_message_,
       auth_details->success());
   automation_->Send(reply_message_);
   delete this;
 }
 #endif
 
+DownloadShelfVisibilityObserver::DownloadShelfVisibilityObserver(
+    AutomationProvider* automation,
+    Browser* browser,
+    bool visibility,
+    IPC::Message* reply_message)
+      : automation_(automation),
+        visibility_(visibility),
+        reply_message_(reply_message) {
+  registrar_.Add(this, NotificationType::DOWNLOAD_SHELF_VISIBILITY_CHANGED,
+                 Source<Browser>(browser));
+}
+
+DownloadShelfVisibilityObserver::~DownloadShelfVisibilityObserver() {
+}
+
+void DownloadShelfVisibilityObserver::Observe(
+    NotificationType type,
+    const NotificationSource& source,
+    const NotificationDetails& details) {
+  if (type == NotificationType::DOWNLOAD_SHELF_VISIBILITY_CHANGED) {
+    Browser* browser = Source<Browser>(source).ptr();
+    if (browser->window()->IsDownloadShelfVisible() == visibility_) {
+      AutomationMsg_WaitForDownloadShelfVisibilityChange::WriteReplyParams(
+          reply_message_, true);
+      automation_->Send(reply_message_);
+      automation_->RemoveObserver(this);
+      delete this;
+    }
+  } else {
+    NOTREACHED();
+  }
+}
+
 AutomationProviderBookmarkModelObserver::AutomationProviderBookmarkModelObserver(
     AutomationProvider* provider,
     IPC::Message* reply_message,
     BookmarkModel* model) {
   automation_provider_ = provider;
   reply_message_ = reply_message;
   model_ = model;
   model_->AddObserver(this);
 }
 
@@ skipping 57 matching lines @@
   : automation_(automation),
     reply_message_(reply_message),
     controller_(controller) {
   Source<NavigationController> source(controller_);
   registrar_.Add(this, NotificationType::LOAD_STOP, source);
   // Pages requiring auth don't send LOAD_STOP.
   registrar_.Add(this, NotificationType::AUTH_NEEDED, source);
 }
 
 OmniboxAcceptNotificationObserver::~OmniboxAcceptNotificationObserver() {
-  automation_->RemoveNavigationStatusListener(this);
+  automation_->RemoveObserver(this);
 }
 
 void OmniboxAcceptNotificationObserver::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   if (type == NotificationType::LOAD_STOP ||
       type == NotificationType::AUTH_NEEDED) {
     AutomationMsg_SendJSONRequest::WriteReplyParams(
         reply_message_, std::string("{}"), false);
     automation_->Send(reply_message_);
     delete this;
   } else {
     NOTREACHED();
   }
 }