Show or open downloaded items on the UI thread for Mac

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 38 matching lines @@
 }
 
 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 = GetSaveLoop();
+  MessageLoop* loop = file_loop();
   if (loop) {
     loop->PostTask(FROM_HERE,
         NewRunnableMethod(this, &SaveFileManager::OnShutdown));
   }
 }
 
 // Stop file thread operations.
 void SaveFileManager::OnShutdown() {
-  DCHECK(MessageLoop::current() == GetSaveLoop());
+  DCHECK(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.
@@ skipping 139 matching lines @@
   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_);
-  MessageLoop* loop = GetSaveLoop();
+  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);
-  MessageLoop* loop = GetSaveLoop();
+  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() == GetSaveLoop());
+  DCHECK(MessageLoop::current() == file_loop());
   DCHECK(info);
   SaveFile* save_file = new SaveFile(info);
   DCHECK(LookupSaveFile(info->save_id) == NULL);
   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() == GetSaveLoop());
+  DCHECK(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() == GetSaveLoop());
+  DCHECK(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));
 
@@ skipping 96 matching lines @@
                                            request_context);
 }
 
 void SaveFileManager::OnRequireSaveJobFromOtherSource(
     SaveFileCreateInfo* info) {
   DCHECK(MessageLoop::current() == io_loop_);
   DCHECK(info->save_id == -1);
   // Generate a unique save id.
   info->save_id = GetNextId();
   // Start real saving action.
-  MessageLoop* loop = GetSaveLoop();
+  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_);
   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() == GetSaveLoop());
+  DCHECK(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() == GetSaveLoop());
+  DCHECK(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() == GetSaveLoop());
+  DCHECK(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() == GetSaveLoop());
+  DCHECK(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() == GetSaveLoop());
+  DCHECK(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());
@@ skipping 18 matching lines @@
       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() == GetSaveLoop());
+  DCHECK(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);
     }
   }
 }