Downloads: replace BrowserThread::FILE with task scheduler.

content/browser/download/save_package.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/save_package.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_runner_util.h"
 #include "base/threading/thread.h"
+#include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "components/url_formatter/url_formatter.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/download/download_item_impl.h"
 #include "content/browser/download/download_manager_impl.h"
 #include "content/browser/download/download_stats.h"
+#include "content/browser/download/download_task_runner.h"
 #include "content/browser/download/save_file.h"
 #include "content/browser/download/save_file_manager.h"
 #include "content/browser/download/save_item.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
@@ skipping 553 matching lines @@
   save_item->Update(size);
 
   // If we got disk error, cancel whole save page job.
   if (!write_success) {
     // Cancel job with reason of disk error.
     Cancel(false);
   }
   return true;
 }
 
-// Stop all page saving jobs that are in progress and instruct the FILE thread
-// to delete all saved  files.
+// Stop all page saving jobs that are in progress and instruct the download
+// sequence to delete all saved  files.

[Avi (use Gerrit), 2017/07/21 17:30:09]

may as well fix the double space between "saved" and "files" while you're here.

[Sigurður Ásgeirsson, 2017/07/21 17:38:20]

Done.

 void SavePackage::Stop(bool cancel_download_item) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // If we haven't moved out of the initial state, there's nothing to cancel and
   // there won't be valid pointers for |file_manager_| or |download_|.
   if (wait_state_ == INITIALIZE)
     return;
 
   // When stopping, if it still has some items in in_progress, cancel them.
   DCHECK(canceled());
   if (in_process_count()) {
@@ skipping 10 matching lines @@
   }
 
   // This vector contains the save ids of the save files which SaveFileManager
   // needs to remove from its save_file_map_.
   std::vector<SaveItemId> save_item_ids;
   for (const auto& it : saved_success_items_)
     save_item_ids.push_back(it.first);
   for (const auto& it : saved_failed_items_)
     save_item_ids.push_back(it.first);
 
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&SaveFileManager::RemoveSavedFileFromFileMap, file_manager_,
-                 save_item_ids));
+  GetDownloadTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&SaveFileManager::RemoveSavedFileFromFileMap,
+                            file_manager_, save_item_ids));
 
   finished_ = true;
   wait_state_ = FAILED;
 
   // Inform the DownloadItem we have canceled whole save page job.
   if (download_) {
     if (cancel_download_item)
       download_->Cancel(false);
     FinalizeDownloadEntry();
   }
 }
 
 void SavePackage::CheckFinish() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (in_process_count() || finished_)
     return;
 
   base::FilePath dir = (save_type_ == SAVE_PAGE_TYPE_AS_COMPLETE_HTML &&
                         saved_success_items_.size() > 1) ?
                         saved_main_directory_path_ : base::FilePath();
 
   FinalNamesMap final_names;
   for (const auto& it : saved_success_items_)
     final_names.insert(std::make_pair(it.first, it.second->full_path()));
 
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&SaveFileManager::RenameAllFiles,
-                 file_manager_,
-                 final_names,
-                 dir,
-                 web_contents()->GetRenderProcessHost()->GetID(),
-                 web_contents()->GetMainFrame()->GetRoutingID(),
-                 id()));
+  GetDownloadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&SaveFileManager::RenameAllFiles, file_manager_, final_names,
+                 dir, web_contents()->GetRenderProcessHost()->GetID(),
+                 web_contents()->GetMainFrame()->GetRoutingID(), id()));
 }
 
 // Successfully finished all items of this SavePackage.
 void SavePackage::Finish() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // User may cancel the job when we're moving files to the final directory.
   if (canceled())
     return;
 
   wait_state_ = SUCCESSFUL;
@@ skipping 11 matching lines @@
 
   // This vector contains the save ids of the save files which SaveFileManager
   // needs to remove from its |save_file_map_|.
   std::vector<SaveItemId> list_of_failed_save_item_ids;
   for (const auto& it : saved_failed_items_) {
     const SaveItem* save_item = it.second.get();
     DCHECK_EQ(it.first, save_item->id());
     list_of_failed_save_item_ids.push_back(save_item->id());
   }
 
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&SaveFileManager::RemoveSavedFileFromFileMap, file_manager_,
-                 list_of_failed_save_item_ids));
+  GetDownloadTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&SaveFileManager::RemoveSavedFileFromFileMap,
+                            file_manager_, list_of_failed_save_item_ids));
 
   if (download_) {
     if (save_type_ != SAVE_PAGE_TYPE_AS_MHTML) {
       CHECK_EQ(download_->GetState(), DownloadItem::IN_PROGRESS);
       download_->DestinationUpdate(
           all_save_items_count_, CurrentSpeed(),
           std::vector<DownloadItem::ReceivedSlice>());
       download_->OnAllDataSaved(all_save_items_count_,
                                 std::unique_ptr<crypto::SecureHash>());
     }
@@ skipping 43 matching lines @@
   // Continue processing the save page job.
   DoSavingProcess();
 
   // Check whether we can successfully finish whole job.
   CheckFinish();
 }
 
 void SavePackage::SaveCanceled(const SaveItem* save_item) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   file_manager_->RemoveSaveFile(save_item->id(), this);
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
+  GetDownloadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&SaveFileManager::CancelSave, file_manager_, save_item->id()));
 }
 
 void SavePackage::SaveNextFile(bool process_all_remaining_items) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(web_contents());
   DCHECK(!waiting_item_queue_.empty());
 
   do {
     // Pop SaveItem from waiting list.
@@ skipping 139 matching lines @@
     const SaveItem* save_item = item.second;
 
     FrameTreeNode* frame_tree_node = frame_tree->FindByID(frame_tree_node_id);
     if (frame_tree_node &&
         frame_tree_node->current_frame_host()->IsRenderFrameLive()) {
       // Ask the frame for HTML to be written to the associated SaveItem.
       GetSerializedHtmlWithLocalLinksForFrame(frame_tree_node);
       number_of_frames_pending_response_++;
     } else {
       // Notify SaveFileManager about the failure to save this SaveItem.
-      BrowserThread::PostTask(
-          BrowserThread::FILE, FROM_HERE,
-          base::Bind(&SaveFileManager::SaveFinished, file_manager_,
-                     save_item->id(), id(), false));
+      GetDownloadTaskRunner()->PostTask(
+          FROM_HERE, base::Bind(&SaveFileManager::SaveFinished, file_manager_,
+                                save_item->id(), id(), false));
     }
   }
   if (number_of_frames_pending_response_ == 0) {
     // All frames disappeared since gathering of savable resources?
     // Treat this as cancellation.
     Cancel(false);
   }
 }
 
 void SavePackage::GetSerializedHtmlWithLocalLinksForFrame(
@@ skipping 89 matching lines @@
       wrote_to_failed_file_ = true;
 
     return;
   }
 
   if (!data.empty()) {
     // Prepare buffer for saving HTML data.
     scoped_refptr<net::IOBuffer> new_data(new net::IOBuffer(data.size()));
     memcpy(new_data->data(), data.data(), data.size());
 
-    // Call write file functionality in FILE thread.
-    BrowserThread::PostTask(
-        BrowserThread::FILE, FROM_HERE,
+    // Call write file functionality in download sequence.
+    GetDownloadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&SaveFileManager::UpdateSaveProgress, file_manager_,
                    save_item->id(), base::RetainedRef(new_data),
                    static_cast<int>(data.size())));
   }
 
-  // Current frame is completed saving, call finish in FILE thread.
+  // Current frame is completed saving, call finish in download sequence.
   if (end_of_data) {
     DVLOG(20) << __func__ << "() save_item_id = " << save_item->id()
               << " url = \"" << save_item->url().spec() << "\"";
-    BrowserThread::PostTask(
-        BrowserThread::FILE, FROM_HERE,
-        base::Bind(&SaveFileManager::SaveFinished, file_manager_,
-                   save_item->id(), id(), true));
+    GetDownloadTaskRunner()->PostTask(
+        FROM_HERE, base::Bind(&SaveFileManager::SaveFinished, file_manager_,
+                              save_item->id(), id(), true));
     number_of_frames_pending_response_--;
     DCHECK_LE(0, number_of_frames_pending_response_);
   }
 }
 
 // Ask for all savable resource links from backend, include main frame and
 // sub-frame.
 void SavePackage::GetSavableResourceLinks() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (wait_state_ != START_PROCESS)
@@ skipping 211 matching lines @@
   if (can_save_as_complete)
     name_with_proper_ext = EnsureHtmlExtension(name_with_proper_ext);
 
   base::FilePath::StringType file_name = name_with_proper_ext.value();
   base::i18n::ReplaceIllegalCharactersInPath(&file_name, '_');
   return base::FilePath(file_name);
 }
 
 // static
 base::FilePath SavePackage::EnsureHtmlExtension(const base::FilePath& name) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   base::FilePath::StringType ext = name.Extension();
   if (!ext.empty())
     ext.erase(ext.begin());  // Erase preceding '.'.
   std::string mime_type;
   if (!net::GetMimeTypeFromExtension(ext, &mime_type) ||
       !CanSaveAsComplete(mime_type)) {
     return base::FilePath(name.value() + FILE_PATH_LITERAL(".") +
                           kDefaultHtmlExtension);
   }
   return name;
 }
 
 // static
 base::FilePath SavePackage::EnsureMimeExtension(const base::FilePath& name,
     const std::string& contents_mime_type) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   // Start extension at 1 to skip over period if non-empty.
   base::FilePath::StringType ext = name.Extension();
   if (!ext.empty())
     ext = ext.substr(1);
   base::FilePath::StringType suggested_extension =
       ExtensionForMimeType(contents_mime_type);
   std::string mime_type;
   if (!suggested_extension.empty() &&
       !net::GetMimeTypeFromExtension(ext, &mime_type)) {
@@ skipping 19 matching lines @@
   };
   for (const auto& extension : extensions) {
     if (contents_mime_type == extension.mime_type)
       return extension.suggested_extension;
   }
   return FILE_PATH_LITERAL("");
 }
 
 void SavePackage::GetSaveInfo() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  // Can't use |web_contents_| in the FILE thread, so get the data that we need
-  // before calling to it.
+  // Can't use |web_contents_| in the download sequence, so get the data that we
+  // need before calling to it.
   base::FilePath website_save_dir;
   base::FilePath download_save_dir;
   bool skip_dir_check = false;
   auto* delegate = download_manager_->GetDelegate();
   if (delegate) {
     delegate->GetSaveDir(
         web_contents()->GetBrowserContext(), &website_save_dir,
         &download_save_dir, &skip_dir_check);
   }
   std::string mime_type = web_contents()->GetContentsMimeType();
   bool can_save_as_complete = CanSaveAsComplete(mime_type);
-  BrowserThread::PostTaskAndReplyWithResult(
-      BrowserThread::FILE, FROM_HERE,
+  base::PostTaskAndReplyWithResult(
+      GetDownloadTaskRunner().get(), FROM_HERE,
       base::Bind(&SavePackage::CreateDirectoryOnFileThread, title_, page_url_,
                  can_save_as_complete, mime_type, website_save_dir,
                  download_save_dir, skip_dir_check),
       base::Bind(&SavePackage::ContinueGetSaveInfo, this,
                  can_save_as_complete));
 }
 
 // static
 base::FilePath SavePackage::CreateDirectoryOnFileThread(
     const base::string16& title,
     const GURL& page_url,
     bool can_save_as_complete,
     const std::string& mime_type,
     const base::FilePath& website_save_dir,
     const base::FilePath& download_save_dir,
     bool skip_dir_check) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(GetDownloadTaskRunner()->RunsTasksInCurrentSequence());
 
   base::FilePath suggested_filename = GetSuggestedNameForSaveAs(
       title, page_url, can_save_as_complete, mime_type);
 
   base::FilePath save_dir;
   // If the default html/websites save folder doesn't exist...
   // We skip the directory check for gdata directories on ChromeOS.
   if (!skip_dir_check && !base::DirectoryExists(website_save_dir)) {
     // If the default download dir doesn't exist, create it.
     if (!base::DirectoryExists(download_save_dir)) {
@@ skipping 22 matching lines @@
   // will fail because returning means no save as popup for the user, which
   // is even more confusing. This case should be rare though.
   return save_dir.Append(suggested_filename);
 }
 
 void SavePackage::ContinueGetSaveInfo(bool can_save_as_complete,
                                       const base::FilePath& suggested_path) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // The WebContents which owns this SavePackage may have disappeared during
-  // the UI->FILE->UI thread hop of
+  // the UI->download sequence->UI thread hop of
   // GetSaveInfo->CreateDirectoryOnFileThread->ContinueGetSaveInfo.
   if (!web_contents() || !download_manager_->GetDelegate())
     return;
 
   base::FilePath::StringType default_extension;
   if (can_save_as_complete)
     default_extension = kDefaultHtmlExtension;
 
   download_manager_->GetDelegate()->ChooseSavePath(
       web_contents(),
@@ skipping 31 matching lines @@
 }
 
 void SavePackage::FinalizeDownloadEntry() {
   DCHECK(download_);
   DCHECK(download_manager_);
   download_ = nullptr;
   download_manager_ = nullptr;
 }
 
 }  // namespace content