Create the download folder if it doesn't exist. That is, the actual download ...

chrome/browser/download/save_file_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 "build/build_config.h"
 
 #include "chrome/browser/download/save_file_manager.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 18 matching lines @@
 SaveFileManager::SaveFileManager(MessageLoop* ui_loop,
                                  MessageLoop* io_loop,
                                  ResourceDispatcherHost* rdh)
     : next_id_(0),
       ui_loop_(ui_loop),
       io_loop_(io_loop),
       resource_dispatcher_host_(rdh) {
   DCHECK(ui_loop_);
   // Need to make sure that we are in UI thread because using g_browser_process
   // on a non-UI thread can cause crashes during shutdown.
-  DCHECK(ui_loop_ == MessageLoop::current());
+  DCHECK_EQ(ui_loop_, MessageLoop::current());
   // Cache the message loop of file thread.
   base::Thread* thread = g_browser_process->file_thread();
   if (thread)
     file_loop_ = thread->message_loop();
   else
     // It could be NULL when it is created in unit test of
     // ResourceDispatcherHost.
     file_loop_ = NULL;
   DCHECK(resource_dispatcher_host_);
 }
 
 SaveFileManager::~SaveFileManager() {
   // Check for clean shutdown.
   DCHECK(save_file_map_.empty());
 }
 
 // Called during the browser shutdown process to clean up any state (open files,
 // timers) that live on the saving thread (file thread).
 void SaveFileManager::Shutdown() {
   MessageLoop* loop = file_loop();
   if (loop) {
     loop->PostTask(FROM_HERE,
         NewRunnableMethod(this, &SaveFileManager::OnShutdown));
   }
 }
 
 // Stop file thread operations.
 void SaveFileManager::OnShutdown() {
-  DCHECK(MessageLoop::current() == file_loop());
+  DCHECK_EQ(MessageLoop::current(), file_loop());
   STLDeleteValues(&save_file_map_);
 }
 
 SaveFile* SaveFileManager::LookupSaveFile(int save_id) {
   SaveFileMap::iterator it = save_file_map_.find(save_id);
   return it == save_file_map_.end() ? NULL : it->second;
 }
 
 // Called on the IO thread when
 // a) The ResourceDispatcherHost has decided that a request is savable.
 // b) The resource does not come from the network, but we still need a
 // save ID for for managing the status of the saving operation. So we
 // file a request from the file thread to the IO thread to generate a
 // unique save ID.
 int SaveFileManager::GetNextId() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK_EQ(MessageLoop::current(), io_loop_);
   return next_id_++;
 }
 
 void SaveFileManager::RegisterStartingRequest(const GURL& save_url,
                                               SavePackage* save_package) {
   // Make sure it runs in the UI thread.
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK_EQ(MessageLoop::current(), ui_loop_);
   int tab_id = save_package->tab_id();
 
   // Register this starting request.
   StartingRequestsMap& starting_requests = tab_starting_requests_[tab_id];
   bool never_present = starting_requests.insert(
       StartingRequestsMap::value_type(save_url.spec(), save_package)).second;
   DCHECK(never_present);
 }
 
 SavePackage* SaveFileManager::UnregisterStartingRequest(
     const GURL& save_url, int tab_id) {
   // Make sure it runs in UI thread.
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK_EQ(MessageLoop::current(), ui_loop_);
 
   TabToStartingRequestsMap::iterator it = tab_starting_requests_.find(tab_id);
   if (it != tab_starting_requests_.end()) {
     StartingRequestsMap& requests = it->second;
     StartingRequestsMap::iterator sit = requests.find(save_url.spec());
     if (sit == requests.end())
       return NULL;
 
     // Found, erase it from starting list and return SavePackage.
     SavePackage* save_package = sit->second;
     requests.erase(sit);
     // If there is no element in requests, remove it
     if (requests.empty())
       tab_starting_requests_.erase(it);
     return save_package;
   }
 
   return NULL;
 }
 
 void SaveFileManager::RequireSaveJobFromOtherSource(SaveFileCreateInfo* info) {
   // This function must be called on the UI thread, because the io_loop_
   // pointer may be junk when we use it on file thread. We can only rely on the
   // io_loop_ pointer being valid when we run code on the UI thread (or on
   // the IO thread.
-  DCHECK(MessageLoop::current() == ui_loop_);
-  DCHECK(info->save_id == -1);
+  DCHECK_EQ(MessageLoop::current(), ui_loop_);
+  DCHECK_EQ(info->save_id, -1);
   // Since the data will come from render process, so we need to start
   // this kind of save job by ourself.
   io_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this,
                         &SaveFileManager::OnRequireSaveJobFromOtherSource,
                         info));
 }
 
 // Look up a SavePackage according to a save id.
 SavePackage* SaveFileManager::LookupPackage(int save_id) {
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK_EQ(MessageLoop::current(), ui_loop_);
   SavePackageMap::iterator it = packages_.find(save_id);
   if (it != packages_.end())
     return it->second;
   return NULL;
 }
 
 // Call from SavePackage for starting a saving job
 void SaveFileManager::SaveURL(const GURL& url,
                               const GURL& referrer,
                               int render_process_host_id,
                               int render_view_id,
                               SaveFileCreateInfo::SaveFileSource save_source,
                               const FilePath& file_full_path,
                               URLRequestContext* request_context,
                               SavePackage* save_package) {
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK_EQ(MessageLoop::current(), ui_loop_);
   if (!io_loop_) {
     NOTREACHED();  // Net IO thread must exist.
     return;
   }
 
   // Register a saving job.
   RegisterStartingRequest(url, save_package);
   if (save_source == SaveFileCreateInfo::SAVE_FILE_FROM_NET) {
     DCHECK(url.is_valid());
 
@@ skipping 18 matching lines @@
 }
 
 // Utility function for look up table maintenance, called on the UI thread.
 // A manager may have multiple save page job (SavePackage) in progress,
 // so we just look up the save id and remove it from the tracking table.
 // If the save id is -1, it means we just send a request to save, but the
 // saving action has still not happened, need to call UnregisterStartingRequest
 // to remove it from the tracking map.
 void SaveFileManager::RemoveSaveFile(int save_id, const GURL& save_url,
                                      SavePackage* package) {
-  DCHECK(MessageLoop::current() == ui_loop_ && package);
+  DCHECK(package);
+  DCHECK_EQ(MessageLoop::current(), ui_loop_);
   // A save page job(SavePackage) can only have one manager,
   // so remove it if it exists.
   if (save_id == -1) {
     SavePackage* old_package = UnregisterStartingRequest(save_url,
                                                          package->tab_id());
-    DCHECK(old_package == package);
+    DCHECK_EQ(old_package, package);
   } else {
     SavePackageMap::iterator it = packages_.find(save_id);
     if (it != packages_.end())
       packages_.erase(it);
   }
 }
 
 // Static
 // Utility function for converting request IDs to a TabContents. Must be called
 // only on the UI thread.
 SavePackage* SaveFileManager::GetSavePackageFromRenderIds(
     int render_process_id, int render_view_id) {
   TabContents* contents = tab_util::GetTabContentsByID(render_process_id,
                                                        render_view_id);
   if (contents)
     return contents->save_package();
 
   return NULL;
 }
 
 // Utility function for deleting specified file.
 void SaveFileManager::DeleteDirectoryOrFile(const FilePath& full_path,
                                             bool is_dir) {
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK_EQ(MessageLoop::current(), ui_loop_);
   MessageLoop* loop = file_loop();
   DCHECK(loop);
   loop->PostTask(FROM_HERE,
       NewRunnableMethod(this,
                         &SaveFileManager::OnDeleteDirectoryOrFile,
                         full_path,
                         is_dir));
 }
 
 void SaveFileManager::SendCancelRequest(int save_id) {
   // Cancel the request which has specific save id.
-  DCHECK(save_id > -1);
+  DCHECK_GT(save_id, -1);
   MessageLoop* loop = file_loop();
   DCHECK(loop);
   loop->PostTask(FROM_HERE,
       NewRunnableMethod(this,
                         &SaveFileManager::CancelSave,
                         save_id));
 }
 
 // Notifications sent from the IO thread and run on the file thread:
 
 // The IO thread created |info|, but the file thread (this method) uses it
 // to create a SaveFile which will hold and finally destroy |info|. It will
 // then passes |info| to the UI thread for reporting saving status.
 void SaveFileManager::StartSave(SaveFileCreateInfo* info) {
-  DCHECK(MessageLoop::current() == file_loop());
+  DCHECK_EQ(MessageLoop::current(), file_loop());
   DCHECK(info);
   SaveFile* save_file = new SaveFile(info);
-  DCHECK(LookupSaveFile(info->save_id) == NULL);
+  DCHECK(!LookupSaveFile(info->save_id));
   save_file_map_[info->save_id] = save_file;
   info->path = save_file->full_path();
 
   ui_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this,
                         &SaveFileManager::OnStartSave,
                         info));
 }
 
 // We do forward an update to the UI thread here, since we do not use timer to
 // update the UI. If the user has canceled the saving action (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 SaveFile has been deleted.
 void SaveFileManager::UpdateSaveProgress(int save_id,
                                          net::IOBuffer* data,
                                          int data_len) {
-  DCHECK(MessageLoop::current() == file_loop());
+  DCHECK_EQ(MessageLoop::current(), file_loop());
   SaveFile* save_file = LookupSaveFile(save_id);
   if (save_file) {
     bool write_success = save_file->AppendDataToFile(data->data(), data_len);
     ui_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this,
                           &SaveFileManager::OnUpdateSaveProgress,
                           save_file->save_id(),
                           save_file->bytes_so_far(),
                           write_success));
   }
   data->Release();
 }
 
 // The IO thread will call this when saving is completed or it got error when
 // fetching data. In the former case, we forward the message to OnSaveFinished
 // in UI thread. In the latter case, the save ID will be -1, which means the
 // saving action did not even start, so we need to call OnErrorFinished in UI
 // thread, which will use the save URL to find corresponding request record and
 // delete it.
 void SaveFileManager::SaveFinished(int save_id,
                                    GURL save_url,
                                    int render_process_id,
                                    bool is_success) {
-  DCHECK(MessageLoop::current() == file_loop());
+  DCHECK_EQ(MessageLoop::current(), file_loop());
   SaveFileMap::iterator it = save_file_map_.find(save_id);
   if (it != save_file_map_.end()) {
     SaveFile* save_file = it->second;
     ui_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this,
                           &SaveFileManager::OnSaveFinished,
                           save_id,
                           save_file->bytes_so_far(),
                           is_success));
 
     save_file->Finish();
   } else if (save_id == -1) {
     // Before saving started, we got error. We still call finish process.
     DCHECK(!save_url.is_empty());
     ui_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this,
                           &SaveFileManager::OnErrorFinished,
                           save_url,
                           render_process_id));
   }
 }
 
 // Notifications sent from the file thread and run on the UI thread.
 
 void SaveFileManager::OnStartSave(const SaveFileCreateInfo* info) {
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK_EQ(MessageLoop::current(), ui_loop_);
   SavePackage* save_package =
       GetSavePackageFromRenderIds(info->render_process_id,
                                   info->render_view_id);
   if (!save_package) {
     // Cancel this request.
     SendCancelRequest(info->save_id);
     return;
   }
 
   // Insert started saving job to tracking list.
   SavePackageMap::iterator sit = packages_.find(info->save_id);
   if (sit == packages_.end()) {
     // Find the registered request. If we can not find, it means we have
     // canceled the job before.
     SavePackage* old_save_package = UnregisterStartingRequest(info->url,
         info->render_process_id);
     if (!old_save_package) {
       // Cancel this request.
       SendCancelRequest(info->save_id);
       return;
     }
-    DCHECK(old_save_package == save_package);
+    DCHECK_EQ(old_save_package, save_package);
     packages_[info->save_id] = save_package;
   } else {
     NOTREACHED();
   }
 
   // Forward this message to SavePackage.
   save_package->StartSave(info);
 }
 
 void SaveFileManager::OnUpdateSaveProgress(int save_id, int64 bytes_so_far,
                                            bool write_success) {
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK_EQ(MessageLoop::current(), ui_loop_);
   SavePackage* package = LookupPackage(save_id);
   if (package)
     package->UpdateSaveProgress(save_id, bytes_so_far, write_success);
   else
     SendCancelRequest(save_id);
 }
 
 void SaveFileManager::OnSaveFinished(int save_id,
                                      int64 bytes_so_far,
                                      bool is_success) {
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK_EQ(MessageLoop::current(), ui_loop_);
   SavePackage* package = LookupPackage(save_id);
   if (package)
     package->SaveFinished(save_id, bytes_so_far, is_success);
 }
 
 void SaveFileManager::OnErrorFinished(GURL save_url, int tab_id) {
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK_EQ(MessageLoop::current(), ui_loop_);
   SavePackage* save_package = UnregisterStartingRequest(save_url, tab_id);
   if (save_package)
     save_package->SaveFailed(save_url);
 }
 
 void SaveFileManager::OnCancelSaveRequest(int render_process_id,
                                           int request_id) {
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK_EQ(MessageLoop::current(), ui_loop_);
   DCHECK(io_loop_);
   io_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this,
                         &SaveFileManager::ExecuteCancelSaveRequest,
                         render_process_id,
                         request_id));
 }
 
 // Notifications sent from the UI thread and run on the IO thread.
 
 void SaveFileManager::OnSaveURL(const GURL& url,
                                 const GURL& referrer,
                                 int render_process_host_id,
                                 int render_view_id,
                                 URLRequestContext* request_context) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK_EQ(MessageLoop::current(), io_loop_);
   resource_dispatcher_host_->BeginSaveFile(url,
                                            referrer,
                                            render_process_host_id,
                                            render_view_id,
                                            request_context);
 }
 
 void SaveFileManager::OnRequireSaveJobFromOtherSource(
     SaveFileCreateInfo* info) {
-  DCHECK(MessageLoop::current() == io_loop_);
-  DCHECK(info->save_id == -1);
+  DCHECK_EQ(MessageLoop::current(), io_loop_);
+  DCHECK_EQ(info->save_id, -1);
   // Generate a unique save id.
   info->save_id = GetNextId();
   // Start real saving action.
   MessageLoop* loop = file_loop();
   DCHECK(loop);
   loop->PostTask(FROM_HERE,
                  NewRunnableMethod(this,
                                    &SaveFileManager::StartSave,
                                    info));
 }
 
 void SaveFileManager::ExecuteCancelSaveRequest(int render_process_id,
                                                int request_id) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK_EQ(MessageLoop::current(), io_loop_);
   resource_dispatcher_host_->CancelRequest(render_process_id,
                                            request_id,
                                            false);
 }
 
 // Notifications sent from the UI thread and run on the file thread.
 
 // This method will be sent via a user action, or shutdown on the UI thread,
 // and run on the file thread. We don't post a message back for cancels,
 // but we do forward the cancel to the IO thread. Since this message has been
 // sent from the UI thread, the saving job may have already completed and
 // won't exist in our map.
 void SaveFileManager::CancelSave(int save_id) {
-  DCHECK(MessageLoop::current() == file_loop());
+  DCHECK_EQ(MessageLoop::current(), file_loop());
   SaveFileMap::iterator it = save_file_map_.find(save_id);
   if (it != save_file_map_.end()) {
     SaveFile* save_file = it->second;
 
     // If the data comes from the net IO thread, then forward the cancel
     // message to IO thread. If the data comes from other sources, just
     // ignore the cancel message.
     if (save_file->save_source() == SaveFileCreateInfo::SAVE_FILE_FROM_NET) {
       ui_loop_->PostTask(FROM_HERE,
           NewRunnableMethod(this,
@@ skipping 16 matching lines @@
     delete save_file;
   }
 }
 
 // It is possible that SaveItem which has specified save_id has been canceled
 // before this function runs. So if we can not find corresponding SaveFile by
 // using specified save_id, just return.
 void SaveFileManager::SaveLocalFile(const GURL& original_file_url,
                                     int save_id,
                                     int render_process_id) {
-  DCHECK(MessageLoop::current() == file_loop());
+  DCHECK_EQ(MessageLoop::current(), file_loop());
   SaveFile* save_file = LookupSaveFile(save_id);
   if (!save_file)
     return;
   DCHECK(!save_file->path_renamed());
   // If it has finished, just return.
   if (!save_file->in_progress())
     return;
 
   // Close the save file before the copy operation.
   save_file->Finish();
 
   DCHECK(original_file_url.SchemeIsFile());
   FilePath file_path;
   net::FileURLToFilePath(original_file_url, &file_path);
   // If we can not get valid file path from original URL, treat it as
   // disk error.
   if (file_path.empty())
     SaveFinished(save_id, original_file_url, render_process_id, false);
 
   // Copy the local file to the temporary file. It will be renamed to its
   // final name later.
   bool success = file_util::CopyFile(file_path, save_file->full_path());
   if (!success)
     file_util::Delete(save_file->full_path(), false);
   SaveFinished(save_id, original_file_url, render_process_id, success);
 }
 
 void SaveFileManager::OnDeleteDirectoryOrFile(const FilePath& full_path,
                                               bool is_dir) {
-  DCHECK(MessageLoop::current() == file_loop());
+  DCHECK_EQ(MessageLoop::current(), file_loop());
   DCHECK(!full_path.empty());
 
   file_util::Delete(full_path, is_dir);
 }
 
 // Open a saved page package, show it in a Windows Explorer window.
 // We run on this thread to avoid blocking the UI with slow Shell operations.
 #if !defined(OS_MACOSX)
 void SaveFileManager::OnShowSavedFileInShell(const FilePath full_path) {
-  DCHECK(MessageLoop::current() == file_loop());
+  DCHECK_EQ(MessageLoop::current(), file_loop());
   platform_util::ShowItemInFolder(full_path);
 }
 #endif
 
 void SaveFileManager::RenameAllFiles(
     const FinalNameList& final_names,
     const FilePath& resource_dir,
     int render_process_id,
     int render_view_id) {
-  DCHECK(MessageLoop::current() == file_loop());
+  DCHECK_EQ(MessageLoop::current(), file_loop());
 
   if (!resource_dir.empty() && !file_util::PathExists(resource_dir))
     file_util::CreateDirectory(resource_dir);
 
   for (FinalNameList::const_iterator i = final_names.begin();
       i != final_names.end(); ++i) {
     SaveFileMap::iterator it = save_file_map_.find(i->first);
     if (it != save_file_map_.end()) {
       SaveFile* save_file = it->second;
       DCHECK(!save_file->in_progress());
       save_file->Rename(i->second);
       delete save_file;
       save_file_map_.erase(it);
     }
   }
 
   ui_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this,
                         &SaveFileManager::OnFinishSavePageJob,
                         render_process_id,
                         render_view_id));
 }
 
 void SaveFileManager::OnFinishSavePageJob(int render_process_id,
                                           int render_view_id) {
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK_EQ(MessageLoop::current(), ui_loop_);
 
   SavePackage* save_package =
       GetSavePackageFromRenderIds(render_process_id, render_view_id);
 
   if (save_package) {
     // save_package is null if save was canceled.
     save_package->Finish();
   }
 }
 
 void SaveFileManager::RemoveSavedFileFromFileMap(
     const SaveIDList& save_ids) {
-  DCHECK(MessageLoop::current() == file_loop());
+  DCHECK_EQ(MessageLoop::current(), file_loop());
 
   for (SaveIDList::const_iterator i = save_ids.begin();
       i != save_ids.end(); ++i) {
     SaveFileMap::iterator it = save_file_map_.find(*i);
     if (it != save_file_map_.end()) {
       SaveFile* save_file = it->second;
       DCHECK(!save_file->in_progress());
       file_util::Delete(save_file->full_path(), false);
       delete save_file;
       save_file_map_.erase(it);
     }
   }
 }
+
+void SaveFileManager::CreateDownloadDirectory(FilePath save_dir,
+                                              SavePackage* save_package) {
+  file_util::CreateDirectory(save_dir);
+  ui_loop_->PostTask(FROM_HERE,
+      NewRunnableMethod(save_package,
+                        &SavePackage::ContinueGetSaveInfo,
+                        save_dir));
+}