Make the multiple download request dialog an infobar....

chrome/browser/download/download_request_manager.cc

 // Copyright (c) 2006-2008 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/download/download_request_manager.h"
 
 #include "base/message_loop.h"
 #include "base/thread.h"
-#include "chrome/browser/download/download_request_dialog_delegate.h"
+#include "chrome/browser/download/download_request_infobar_delegate.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents_delegate.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/notification_service.h"
 
 // TabDownloadState ------------------------------------------------------------
 
 DownloadRequestManager::TabDownloadState::TabDownloadState(
     DownloadRequestManager* host,
     NavigationController* controller,
     NavigationController* originating_controller)
     : host_(host),
       controller_(controller),
       status_(DownloadRequestManager::ALLOW_ONE_DOWNLOAD),
-      dialog_delegate_(NULL) {
+      infobar_(NULL) {
   Source<NavigationController> notification_source(controller);
   registrar_.Add(this, NotificationType::NAV_ENTRY_PENDING,
                  notification_source);
   registrar_.Add(this, NotificationType::TAB_CLOSED, notification_source);
 
   NavigationEntry* active_entry = originating_controller ?
       originating_controller->GetActiveEntry() : controller->GetActiveEntry();
   if (active_entry)
     initial_page_host_ = active_entry->url().host();
 }
 
 DownloadRequestManager::TabDownloadState::~TabDownloadState() {
   // We should only be destroyed after the callbacks have been notified.
   DCHECK(callbacks_.empty());
 
-  // And we should have closed the message box.
-  DCHECK(!dialog_delegate_);
+  // And we should have closed the infobar.
+  DCHECK(!infobar_);
 }
 
 void DownloadRequestManager::TabDownloadState::OnUserGesture() {
   if (is_showing_prompt()) {
     // Don't change the state if the user clicks on the page some where.
     return;
   }
 
   if (status_ != DownloadRequestManager::ALLOW_ALL_DOWNLOADS &&
       status_ != DownloadRequestManager::DOWNLOADS_NOT_ALLOWED) {
     // Revert to default status.
     host_->Remove(this);
     // WARNING: We've been deleted.
     return;
   }
 }
 
 void DownloadRequestManager::TabDownloadState::PromptUserForDownload(
     TabContents* tab,
     DownloadRequestManager::Callback* callback) {
   callbacks_.push_back(callback);
 
   if (is_showing_prompt())
     return;  // Already showing prompt.
 
   if (DownloadRequestManager::delegate_) {
     NotifyCallbacks(DownloadRequestManager::delegate_->ShouldAllowDownload());
   } else {
-    dialog_delegate_ = DownloadRequestDialogDelegate::Create(tab, this);
+    infobar_ = new DownloadRequestInfoBarDelegate(tab, this);
   }
 }
 
 void DownloadRequestManager::TabDownloadState::Cancel() {
   NotifyCallbacks(false);
 }
 
 void DownloadRequestManager::TabDownloadState::Accept() {
   NotifyCallbacks(true);
 }
@@ skipping 19 matching lines @@
       // 100% right, so we don't deal with it.
       NavigationEntry* entry = controller_->pending_entry();
       if (!entry)
         return;
 
       if (PageTransition::IsRedirect(entry->transition_type())) {
         // Redirects don't count.
         return;
       }
 
-      if (is_showing_prompt()) {
-        // We're prompting the user and they navigated away. Close the popup and
-        // cancel the downloads.
-        dialog_delegate_->CloseWindow();
-        // After switch we'll notify callbacks and get deleted.
-      } else if (status_ == DownloadRequestManager::ALLOW_ALL_DOWNLOADS ||
-                 status_ == DownloadRequestManager::DOWNLOADS_NOT_ALLOWED) {
+      if (status_ == DownloadRequestManager::ALLOW_ALL_DOWNLOADS ||
+          status_ == DownloadRequestManager::DOWNLOADS_NOT_ALLOWED) {
         // User has either allowed all downloads or canceled all downloads. Only
         // reset the download state if the user is navigating to a different
         // host (or host is empty).
         if (!initial_page_host_.empty() && !entry->url().host().empty() &&
             entry->url().host() == initial_page_host_) {
           return;
         }
-      }  // else case: we're not prompting user and user hasn't allowed or
-         // disallowed downloads, break so that we get deleted after switch.
+      }
       break;
     }
 
     case NotificationType::TAB_CLOSED:
       // Tab closed, no need to handle closing the dialog as it's owned by the
       // TabContents, break so that we get deleted after switch.
       break;
 
     default:
       NOTREACHED();
   }
 
   NotifyCallbacks(false);
   host_->Remove(this);
 }
 
 void DownloadRequestManager::TabDownloadState::NotifyCallbacks(bool allow) {
-  if (dialog_delegate_) {
+  if (infobar_) {
     // Reset the delegate so we don't get notified again.
-    dialog_delegate_->set_host(NULL);
-    dialog_delegate_ = NULL;
+    infobar_->set_host(NULL);
+    infobar_ = NULL;
   }
   status_ = allow ?
       DownloadRequestManager::ALLOW_ALL_DOWNLOADS :
       DownloadRequestManager::DOWNLOADS_NOT_ALLOWED;
   std::vector<DownloadRequestManager::Callback*> callbacks;
   callbacks.swap(callbacks_);
   for (size_t i = 0; i < callbacks.size(); ++i)
     host_->ScheduleNotification(callbacks[i], allow);
 }
 
@@ skipping 132 matching lines @@
 
 void DownloadRequestManager::Remove(TabDownloadState* state) {
   DCHECK(state_map_.find(state->controller()) != state_map_.end());
   state_map_.erase(state->controller());
   delete state;
 }
 
 // static
 DownloadRequestManager::TestingDelegate* DownloadRequestManager::delegate_ =
     NULL;