[Downloads] Factor out request handling logic between DRH and UD.

content/browser/download/download_manager_impl.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/browser/download/download_manager_impl.h"
 
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 107 matching lines @@
   scoped_ptr<DownloadSaveInfo> save_info(new DownloadSaveInfo());
   save_info->file_path = params->file_path();
   save_info->suggested_name = params->suggested_name();
   save_info->offset = params->offset();
   save_info->hash_state = params->hash_state();
   save_info->prompt_for_save_location = params->prompt();
   save_info->file = params->GetFile();
 
   if (params->render_process_host_id() != -1) {
     ResourceDispatcherHost::Get()->BeginDownload(
-        request.Pass(), params->referrer(), params->content_initiated(),
+        std::move(request), params->referrer(), params->content_initiated(),
         params->resource_context(), params->render_process_host_id(),
         params->render_view_host_routing_id(),
         params->render_frame_host_routing_id(), params->prefer_cache(),
-        params->do_not_prompt_for_login(), save_info.Pass(), download_id,
+        params->do_not_prompt_for_login(), std::move(save_info), download_id,
         params->callback());
     return nullptr;
   }
   return scoped_ptr<UrlDownloader, BrowserThread::DeleteOnIOThread>(
-      UrlDownloader::BeginDownload(
-          download_manager, request.Pass(), params->referrer(), false,
-          params->prefer_cache(), true, save_info.Pass(), download_id,
-          params->callback())
+      UrlDownloader::BeginDownload(download_manager, std::move(request),
+                                   params->referrer(), params->prefer_cache(),
+                                   std::move(save_info), download_id,
+                                   params->callback())
           .release());
 }
 
 class DownloadItemFactoryImpl : public DownloadItemFactory {
  public:
   DownloadItemFactoryImpl() {}
   ~DownloadItemFactoryImpl() override {}
 
   DownloadItemImpl* CreatePersistedItem(
       DownloadItemImplDelegate* delegate,
@@ skipping 190 matching lines @@
     scoped_ptr<DownloadCreateInfo> info,
     scoped_ptr<ByteStreamReader> stream,
     const DownloadUrlParameters::OnStartedCallback& on_started) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(info);
   uint32 download_id = info->download_id;
   const bool new_download = (download_id == content::DownloadItem::kInvalidId);
   base::Callback<void(uint32)> got_id(base::Bind(
       &DownloadManagerImpl::StartDownloadWithId,
       weak_factory_.GetWeakPtr(),
-      base::Passed(info.Pass()),
-      base::Passed(stream.Pass()),
+      base::Passed(&info),
+      base::Passed(&stream),
       on_started,
       new_download));
   if (new_download) {
     GetNextId(got_id);
   } else {
     got_id.Run(download_id);
   }
 }
 
 void DownloadManagerImpl::StartDownloadWithId(
     scoped_ptr<DownloadCreateInfo> info,
     scoped_ptr<ByteStreamReader> stream,
     const DownloadUrlParameters::OnStartedCallback& on_started,
     bool new_download,
     uint32 id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_NE(content::DownloadItem::kInvalidId, id);
   DownloadItemImpl* download = NULL;
   if (new_download) {
     download = CreateActiveItem(id, *info);
   } else {
     DownloadMap::iterator item_iterator = downloads_.find(id);
     // Trying to resume an interrupted download.
     if (item_iterator == downloads_.end() ||
         (item_iterator->second->GetState() == DownloadItem::CANCELLED)) {
       // If the download is no longer known to the DownloadManager, then it was
       // removed after it was resumed. Ignore. If the download is cancelled
       // while resuming, then also ignore the request.
-      info->request_handle.CancelRequest();
+      info->request_handle->CancelRequest();
       if (!on_started.is_null())
         on_started.Run(NULL, DOWNLOAD_INTERRUPT_REASON_USER_CANCELED);
       return;
     }
     download = item_iterator->second;
     DCHECK_EQ(DownloadItem::INTERRUPTED, download->GetState());
     download->MergeOriginInfoOnResume(*info);
   }
 
   base::FilePath default_download_directory;
   if (delegate_) {
     base::FilePath website_save_directory;  // Unused
     bool skip_dir_check = false;            // Unused
     delegate_->GetSaveDir(GetBrowserContext(), &website_save_directory,
                           &default_download_directory, &skip_dir_check);
   }
 
   // Create the download file and start the download.
-  scoped_ptr<DownloadFile> download_file(
-      file_factory_->CreateFile(
-          info->save_info.Pass(), default_download_directory,
-          info->url(), info->referrer_url,
-          delegate_ && delegate_->GenerateFileHash(),
-          stream.Pass(), download->GetBoundNetLog(),
-          download->DestinationObserverAsWeakPtr()));
+  scoped_ptr<DownloadFile> download_file(file_factory_->CreateFile(
+      std::move(info->save_info), default_download_directory, info->url(),
+      info->referrer_url, delegate_ && delegate_->GenerateFileHash(),
+      std::move(stream), download->GetBoundNetLog(),
+      download->DestinationObserverAsWeakPtr()));
 
   // Attach the client ID identifying the app to the AV system.
   if (download_file.get() && delegate_) {
     download_file->SetClientGuid(
         delegate_->ApplicationClientIdForFileScanning());
   }
 
-  scoped_ptr<DownloadRequestHandleInterface> req_handle(
-      new DownloadRequestHandle(info->request_handle));
-  download->Start(download_file.Pass(), req_handle.Pass());
+  download->Start(std::move(download_file), std::move(info->request_handle));
 
   // For interrupted downloads, Start() will transition the state to
   // IN_PROGRESS and consumers will be notified via OnDownloadUpdated().
   // For new downloads, we notify here, rather than earlier, so that
   // the download_file is bound to download and all the usual
   // setters (e.g. Cancel) work.
   if (new_download)
     FOR_EACH_OBSERVER(Observer, observers_, OnDownloadCreated(this, download));
 
   if (!on_started.is_null())
@@ skipping 324 matching lines @@
   if (delegate_)
     delegate_->OpenDownload(download);
 }
 
 void DownloadManagerImpl::ShowDownloadInShell(DownloadItemImpl* download) {
   if (delegate_)
     delegate_->ShowDownloadInShell(download);
 }
 
 }  // namespace content