// 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_file_manager.h" #include "base/file_util.h" #include "base/logging.h" #include "base/stl_util-inl.h" #include "base/task.h" #include "base/utf_string_conversions.h" #include "build/build_config.h" #include "chrome/browser/download/download_manager.h" #include "chrome/browser/download/download_util.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/safe_browsing/safe_browsing_service.h" #include "chrome/browser/tab_contents/tab_util.h" #include "content/browser/browser_thread.h" #include "content/browser/renderer_host/resource_dispatcher_host.h" #include "content/browser/tab_contents/tab_contents.h" #include "googleurl/src/gurl.h" #include "net/base/io_buffer.h" namespace { // Throttle updates to the UI thread so that a fast moving download doesn't // cause it to become unresponsive (in milliseconds). const int kUpdatePeriodMs = 500; DownloadManager* DownloadManagerForRenderViewHost(int render_process_id, int render_view_id) { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); TabContents* contents = tab_util::GetTabContentsByID(render_process_id, render_view_id); if (contents) { Profile* profile = contents->profile(); if (profile) return profile->GetDownloadManager(); } return NULL; } } // namespace DownloadFileManager::DownloadFileManager(ResourceDispatcherHost* rdh) : next_id_(0), resource_dispatcher_host_(rdh) { } DownloadFileManager::~DownloadFileManager() { DCHECK(downloads_.empty()); } void DownloadFileManager::Shutdown() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); BrowserThread::PostTask( BrowserThread::FILE, FROM_HERE, NewRunnableMethod(this, &DownloadFileManager::OnShutdown)); } void DownloadFileManager::OnShutdown() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); StopUpdateTimer(); STLDeleteValues(&downloads_); } void DownloadFileManager::CreateDownloadFile(DownloadCreateInfo* info, DownloadManager* download_manager, bool get_hash) { VLOG(20) << __FUNCTION__ << "()" << " info = " << info->DebugString(); DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); scoped_ptr<DownloadFile> download_file(new DownloadFile(info, download_manager)); if (!download_file->Initialize(get_hash)) { BrowserThread::PostTask( BrowserThread::IO, FROM_HERE, NewRunnableFunction(&download_util::CancelDownloadRequest, resource_dispatcher_host_, info->child_id, info->request_id)); delete info; return; } DCHECK(GetDownloadFile(info->download_id) == NULL); downloads_[info->download_id] = download_file.release(); // TODO(phajdan.jr): fix the duplication of path info below. info->path = info->save_info.file_path; // The file is now ready, we can un-pause the request and start saving data. BrowserThread::PostTask( BrowserThread::IO, FROM_HERE, NewRunnableMethod(this, &DownloadFileManager::ResumeDownloadRequest, info->child_id, info->request_id)); StartUpdateTimer(); BrowserThread::PostTask( BrowserThread::UI, FROM_HERE, NewRunnableMethod(download_manager, &DownloadManager::StartDownload, info)); } void DownloadFileManager::ResumeDownloadRequest(int child_id, int request_id) { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); // This balances the pause in DownloadResourceHandler::OnResponseStarted. resource_dispatcher_host_->PauseRequest(child_id, request_id, false); } DownloadFile* DownloadFileManager::GetDownloadFile(int id) { DownloadFileMap::iterator it = downloads_.find(id); return it == downloads_.end() ? NULL : it->second; } void DownloadFileManager::StartUpdateTimer() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); if (!update_timer_.IsRunning()) { update_timer_.Start(base::TimeDelta::FromMilliseconds(kUpdatePeriodMs), this, &DownloadFileManager::UpdateInProgressDownloads); } } void DownloadFileManager::StopUpdateTimer() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); update_timer_.Stop(); } void DownloadFileManager::UpdateInProgressDownloads() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); for (DownloadFileMap::iterator i = downloads_.begin(); i != downloads_.end(); ++i) { int id = i->first; DownloadFile* download_file = i->second; DownloadManager* manager = download_file->GetDownloadManager(); if (manager) { BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, NewRunnableMethod(manager, &DownloadManager::UpdateDownload, id, download_file->bytes_so_far())); } } } // Called on the IO thread once the ResourceDispatcherHost has decided that a // request is a download. int DownloadFileManager::GetNextId() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); return next_id_++; } void DownloadFileManager::StartDownload(DownloadCreateInfo* info) { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); DCHECK(info); DownloadManager* manager = DownloadManagerForRenderViewHost( info->child_id, info->render_view_id); if (!manager) { BrowserThread::PostTask( BrowserThread::IO, FROM_HERE, NewRunnableFunction(&download_util::CancelDownloadRequest, resource_dispatcher_host_, info->child_id, info->request_id)); delete info; return; } manager->CreateDownloadItem(info); bool hash_needed = resource_dispatcher_host_->safe_browsing_service()-> DownloadBinHashNeeded(); BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, NewRunnableMethod(this, &DownloadFileManager::CreateDownloadFile, info, make_scoped_refptr(manager), hash_needed)); } // We don't forward an update to the UI thread here, since we want to throttle // the UI update rate via a periodic timer. If the user has cancelled the // download (in the UI thread), we may receive a few more updates before the IO // thread gets the cancel message: we just delete the data since the // DownloadFile has been deleted. void DownloadFileManager::UpdateDownload(int id, DownloadBuffer* buffer) { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); std::vector<DownloadBuffer::Contents> contents; { base::AutoLock auto_lock(buffer->lock); contents.swap(buffer->contents); } DownloadFile* download = GetDownloadFile(id); for (size_t i = 0; i < contents.size(); ++i) { net::IOBuffer* data = contents[i].first; const int data_len = contents[i].second; if (download) download->AppendDataToFile(data->data(), data_len); data->Release(); } } void DownloadFileManager::OnResponseCompleted( int id, DownloadBuffer* buffer, int os_error, const std::string& security_info) { VLOG(20) << __FUNCTION__ << "()" << " id = " << id << " os_error = " << os_error << " security_info = \"" << security_info << "\""; DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); delete buffer; DownloadFile* download = GetDownloadFile(id); if (!download) return; download->Finish(); DownloadManager* download_manager = download->GetDownloadManager(); if (!download_manager) { CancelDownload(id); return; } std::string hash; if (!download->GetSha256Hash(&hash)) hash.clear(); BrowserThread::PostTask( BrowserThread::UI, FROM_HERE, NewRunnableMethod( download_manager, &DownloadManager::OnResponseCompleted, id, download->bytes_so_far(), os_error, hash)); // We need to keep the download around until the UI thread has finalized // the name. } // This method will be sent via a user action, or shutdown on the UI thread, and // run on the download thread. Since this message has been sent from the UI // thread, the download may have already completed and won't exist in our map. void DownloadFileManager::CancelDownload(int id) { VLOG(20) << __FUNCTION__ << "()" << " id = " << id; DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); DownloadFileMap::iterator it = downloads_.find(id); if (it == downloads_.end()) return; DownloadFile* download = it->second; VLOG(20) << __FUNCTION__ << "()" << " download = " << download->DebugString(); download->Cancel(); EraseDownload(id); } void DownloadFileManager::CompleteDownload(int id) { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); if (!ContainsKey(downloads_, id)) return; DownloadFile* download_file = downloads_[id]; VLOG(20) << " " << __FUNCTION__ << "()" << " id = " << id << " download_file = " << download_file->DebugString(); download_file->Detach(); EraseDownload(id); } void DownloadFileManager::OnDownloadManagerShutdown(DownloadManager* manager) { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); DCHECK(manager); std::set<DownloadFile*> to_remove; for (DownloadFileMap::iterator i = downloads_.begin(); i != downloads_.end(); ++i) { DownloadFile* download_file = i->second; if (download_file->GetDownloadManager() == manager) { download_file->CancelDownloadRequest(resource_dispatcher_host_); to_remove.insert(download_file); } } for (std::set<DownloadFile*>::iterator i = to_remove.begin(); i != to_remove.end(); ++i) { downloads_.erase((*i)->id()); delete *i; } } // Actions from the UI thread and run on the download thread // The DownloadManager in the UI thread has provided an intermediate .crdownload // name for the download specified by 'id'. Rename the in progress download. // // There are 2 possible rename cases where this method can be called: // 1. tmp -> foo.crdownload (not final, safe) // 2. tmp-> Unconfirmed.xxx.crdownload (not final, dangerous) void DownloadFileManager::RenameInProgressDownloadFile( int id, const FilePath& full_path) { VLOG(20) << __FUNCTION__ << "()" << " id = " << id << " full_path = \"" << full_path.value() << "\""; DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); DownloadFile* download = GetDownloadFile(id); if (!download) return; VLOG(20) << __FUNCTION__ << "()" << " download = " << download->DebugString(); if (!download->Rename(full_path)) { // Error. Between the time the UI thread generated 'full_path' to the time // this code runs, something happened that prevents us from renaming. CancelDownloadOnRename(id); } } // The DownloadManager in the UI thread has provided a final name for the // download specified by 'id'. Rename the download that's in the process // of completing. // // There are 2 possible rename cases where this method can be called: // 1. foo.crdownload -> foo (final, safe) // 2. Unconfirmed.xxx.crdownload -> xxx (final, validated) void DownloadFileManager::RenameCompletingDownloadFile( int id, const FilePath& full_path, bool overwrite_existing_file) { VLOG(20) << __FUNCTION__ << "()" << " id = " << id << " overwrite_existing_file = " << overwrite_existing_file << " full_path = \"" << full_path.value() << "\""; DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); DownloadFile* download = GetDownloadFile(id); if (!download) return; DCHECK(download->GetDownloadManager()); DownloadManager* download_manager = download->GetDownloadManager(); VLOG(20) << __FUNCTION__ << "()" << " download = " << download->DebugString(); int uniquifier = 0; FilePath new_path = full_path; if (!overwrite_existing_file) { // Make our name unique at this point, as if a dangerous file is // downloading and a 2nd download is started for a file with the same // name, they would have the same path. This is because we uniquify // the name on download start, and at that time the first file does // not exists yet, so the second file gets the same name. // This should not happen in the SAFE case, and we check for that in the UI // thread. uniquifier = download_util::GetUniquePathNumber(new_path); if (uniquifier > 0) { download_util::AppendNumberToPath(&new_path, uniquifier); } } // Rename the file, overwriting if necessary. if (!download->Rename(new_path)) { // Error. Between the time the UI thread generated 'full_path' to the time // this code runs, something happened that prevents us from renaming. CancelDownloadOnRename(id); return; } #if defined(OS_MACOSX) // Done here because we only want to do this once; see // http://crbug.com/13120 for details. download->AnnotateWithSourceInformation(); #endif BrowserThread::PostTask( BrowserThread::UI, FROM_HERE, NewRunnableMethod( download_manager, &DownloadManager::OnDownloadRenamedToFinalName, id, new_path, uniquifier)); } // Called only from RenameInProgressDownloadFile and // RenameCompletingDownloadFile on the FILE thread. void DownloadFileManager::CancelDownloadOnRename(int id) { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); DownloadFile* download = GetDownloadFile(id); if (!download) return; DownloadManager* download_manager = download->GetDownloadManager(); if (!download_manager) { // Without a download manager, we can't cancel the request normally, so we // need to do it here. The normal path will also update the download // history before cancelling the request. download->CancelDownloadRequest(resource_dispatcher_host_); return; } BrowserThread::PostTask( BrowserThread::UI, FROM_HERE, NewRunnableMethod(download_manager, &DownloadManager::DownloadCancelled, id)); } void DownloadFileManager::EraseDownload(int id) { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); if (!ContainsKey(downloads_, id)) return; DownloadFile* download_file = downloads_[id]; VLOG(20) << " " << __FUNCTION__ << "()" << " id = " << id << " download_file = " << download_file->DebugString(); downloads_.erase(id); delete download_file; if (downloads_.empty()) StopUpdateTimer(); }