Added DownloadProcessHandle class.

chrome/browser/download/download_manager.cc

 // Copyright (c) 2011 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_manager.h"
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/stl_util-inl.h"
 #include "base/stringprintf.h"
 #include "base/sys_string_conversions.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_extensions.h"
 #include "chrome/browser/download/download_file_manager.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_item.h"
 #include "chrome/browser/download/download_prefs.h"
+#include "chrome/browser/download/download_process_handle.h"
 #include "chrome/browser/download/download_safe_browsing_client.h"
 #include "chrome/browser/download/download_status_updater.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/history/download_create_info.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 391 matching lines @@
 void DownloadManager::OnPathExistenceAvailable(DownloadCreateInfo* info) {
   VLOG(20) << __FUNCTION__ << "()" << " info = " << info->DebugString();
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(info);
 
   if (info->prompt_user_for_save_location) {
     // We must ask the user for the place to put the download.
     if (!select_file_dialog_.get())
       select_file_dialog_ = SelectFileDialog::Create(this);
 
-    TabContents* contents = tab_util::GetTabContentsByID(info->child_id,
-                                                         info->render_view_id);
+    TabContents* contents = info->process_handle.GetTabContents();
     SelectFileDialog::FileTypeInfo file_type_info;
     FilePath::StringType extension = info->suggested_path.Extension();
     if (!extension.empty()) {
       extension.erase(extension.begin()); // drop the .
       file_type_info.extensions.resize(1);
       file_type_info.extensions[0].push_back(extension);
     }
     file_type_info.include_all_files = true;
     gfx::NativeWindow owning_window =
         contents ? platform_util::GetTopLevel(contents->GetNativeView()) : NULL;
@@ skipping 251 matching lines @@
 
   // Clean up will happen when the history system create callback runs if we
   // don't have a valid db_handle yet.
   if (download->db_handle() != DownloadHistory::kUninitializedHandle) {
     in_progress_.erase(it);
     active_downloads_.erase(download_id);
     UpdateAppIcon();  // Reflect removal from in_progress_.
     download_history_->UpdateEntry(download);
   }
 
-  DownloadCancelledInternal(download_id,
-                            download->render_process_id(),
-                            download->request_id());
+  DownloadCancelledInternal(download_id, download->process_handle());
 }
 
-void DownloadManager::DownloadCancelledInternal(int download_id,
-                                                int render_process_id,
-                                                int request_id) {
+void DownloadManager::DownloadCancelledInternal(
+    int download_id, DownloadProcessHandle process_handle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Cancel the network request.  RDH is guaranteed to outlive the IO thread.
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      NewRunnableFunction(&download_util::CancelDownloadRequest,
-                          g_browser_process->resource_dispatcher_host(),
-                          render_process_id,
-                          request_id));
+  download_util::CancelDownloadRequest(
+      g_browser_process->resource_dispatcher_host(), process_handle);
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
           file_manager_, &DownloadFileManager::CancelDownload, download_id));
 }
 
 void DownloadManager::OnDownloadError(int32 download_id,
                                       int64 size,
                                       int os_error) {
@@ skipping 37 matching lines @@
 
   DownloadItem* download = it->second;
   if (pause == download->is_paused())
     return;
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(this,
                         &DownloadManager::PauseDownloadRequest,
                         g_browser_process->resource_dispatcher_host(),
-                        download->render_process_id(),
-                        download->request_id(),
+                        download->process_handle(),
                         pause));
 }
 
 void DownloadManager::UpdateAppIcon() {
   if (status_updater_)
     status_updater_->Update();
 }
 
 void DownloadManager::PauseDownloadRequest(ResourceDispatcherHost* rdh,
-                                           int render_process_id,
-                                           int request_id,
+                                           DownloadProcessHandle process_handle,
                                            bool pause) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  rdh->PauseRequest(render_process_id, request_id, pause);
+  rdh->PauseRequest(process_handle.child_id(),
+                    process_handle.request_id(),
+                    pause);
 }
 
 void DownloadManager::RemoveDownload(int64 download_handle) {
   DownloadMap::iterator it = history_downloads_.find(download_handle);
   if (it == history_downloads_.end())
     return;
 
   // Make history update.
   DownloadItem* download = it->second;
   download_history_->RemoveEntry(download);
@@ skipping 170 matching lines @@
     last_download_path_ = path.DirName();
 
   info->path = path;
   AttachDownloadItem(info);
 }
 
 void DownloadManager::FileSelectionCanceled(void* params) {
   // The user didn't pick a place to save the file, so need to cancel the
   // download that's already in progress to the temporary location.
   DownloadCreateInfo* info = reinterpret_cast<DownloadCreateInfo*>(params);
-  DownloadCancelledInternal(info->download_id,
-                            info->child_id,
-                            info->request_id);
+  DownloadCancelledInternal(info->download_id, info->process_handle);
 }
 
 void DownloadManager::DangerousDownloadValidated(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(DownloadItem::DANGEROUS, download->safety_state());
   download->set_safety_state(DownloadItem::DANGEROUS_BUT_VALIDATED);
   download->UpdateObservers();
 
   MaybeCompleteDownload(download);
 }
@@ skipping 39 matching lines @@
     db_handle = download_history_->GetNextFakeDbHandle();
 
   DCHECK(download->db_handle() == DownloadHistory::kUninitializedHandle);
   download->set_db_handle(db_handle);
 
   DCHECK(!ContainsKey(history_downloads_, download->db_handle()));
   history_downloads_[download->db_handle()] = download;
 
   // Show in the appropriate browser UI.
   // This includes buttons to save or cancel, for a dangerous download.
-  ShowDownloadInBrowser(info, download);
+  ShowDownloadInBrowser(&info.process_handle, download);
 
   // Inform interested objects about the new download.
   NotifyModelChanged();
 
   // If the download is still in progress, try to complete it.
   //
   // Otherwise, download has been cancelled or interrupted before we've
   // received the DB handle.  We post one final message to the history
   // service so that it can be properly in sync with the DownloadItem's
   // completion status, and also inform any observers so that they get
   // more than just the start notification.
   if (download->IsInProgress()) {
     MaybeCompleteDownload(download);
   } else {
     DCHECK(download->IsCancelled())
         << " download = " << download->DebugString(true);
     in_progress_.erase(it);
     active_downloads_.erase(info.download_id);
     download_history_->UpdateEntry(download);
     download->UpdateObservers();
   }
 }
 
-void DownloadManager::ShowDownloadInBrowser(const DownloadCreateInfo& info,
-                                            DownloadItem* download) {
+void DownloadManager::ShowDownloadInBrowser(
+    DownloadProcessHandle* process_handle, DownloadItem* download) {
+  if (!process_handle)
+    return;
+
   // The 'contents' may no longer exist if the user closed the tab before we
   // get this start completion event. If it does, tell the origin TabContents
   // to display its download shelf.
-  TabContents* contents = tab_util::GetTabContentsByID(info.child_id,
-                                                       info.render_view_id);
+  TabContents* contents = process_handle->GetTabContents();
 
   // If the contents no longer exists, we start the download in the last active
   // browser. This is not ideal but better than fully hiding the download from
   // the user.
   if (!contents) {
     Browser* last_active = BrowserList::GetLastActive();
     if (last_active)
       contents = last_active->GetSelectedTabContents();
   }
 
-  if (contents)
-    contents->OnStartDownload(download);
+  if (!contents)
+    return;
+
+  contents->OnStartDownload(download);
 }
 
 // Clears the last download path, used to initialize "save as" dialogs.
 void DownloadManager::ClearLastDownloadPath() {
   last_download_path_ = FilePath();
 }
 
 void DownloadManager::NotifyModelChanged() {
   FOR_EACH_OBSERVER(Observer, observers_, ModelChanged());
 }
@@ skipping 74 matching lines @@
     observed_download_manager_->RemoveObserver(this);
 }
 
 void DownloadManager::OtherDownloadManagerObserver::ModelChanged() {
   observing_download_manager_->NotifyModelChanged();
 }
 
 void DownloadManager::OtherDownloadManagerObserver::ManagerGoingDown() {
   observed_download_manager_ = NULL;
 }