Convert profile import IPCs to Mojo

chrome/browser/importer/in_process_importer_bridge.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 "chrome/browser/importer/in_process_importer_bridge.h"
 
 #include <stddef.h>
 
-#include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/importer/external_process_importer_host.h"
 #include "chrome/browser/search_engines/ui_thread_search_terms_data.h"
 #include "chrome/common/importer/imported_bookmark_entry.h"
 #include "chrome/common/importer/importer_autofill_form_data_entry.h"
 #include "components/autofill/core/browser/webdata/autofill_entry.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/favicon_base/favicon_usage_data.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_parser.h"
 #include "components/search_engines/template_url_prepopulate_data.h"
-#include "content/public/browser/browser_thread.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_WIN)
 #include "components/os_crypt/ie7_password_win.h"
 #endif
 
 #include <iterator>
 
 namespace {
 
@@ skipping 25 matching lines @@
       return history::SOURCE_IE_IMPORTED;
     case importer::VISIT_SOURCE_SAFARI_IMPORTED:
       return history::SOURCE_SAFARI_IMPORTED;
   }
   NOTREACHED();
   return history::SOURCE_SYNCED;
 }
 
 }  // namespace
 
-using content::BrowserThread;
-
 namespace {
 
 // FirefoxURLParameterFilter is used to remove parameter mentioning Firefox from
 // the search URL when importing search engines.
 class FirefoxURLParameterFilter : public TemplateURLParser::ParameterFilter {
  public:
   FirefoxURLParameterFilter() {}
   ~FirefoxURLParameterFilter() override {}
 
   // TemplateURLParser::ParameterFilter method.
@@ skipping 79 matching lines @@
 
 InProcessImporterBridge::InProcessImporterBridge(
     ProfileWriter* writer,
     base::WeakPtr<ExternalProcessImporterHost> host) : writer_(writer),
                                                        host_(host) {
 }
 
 void InProcessImporterBridge::AddBookmarks(
     const std::vector<ImportedBookmarkEntry>& bookmarks,
     const base::string16& first_folder_name) {
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&ProfileWriter::AddBookmarks, writer_, bookmarks,
-                 first_folder_name));
+  writer_->AddBookmarks(bookmarks, first_folder_name);
 }
 
 void InProcessImporterBridge::AddHomePage(const GURL& home_page) {
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&ProfileWriter::AddHomepage, writer_, home_page));
+  writer_->AddHomepage(home_page);
 }
 
 #if defined(OS_WIN)
 void InProcessImporterBridge::AddIE7PasswordInfo(
     const importer::ImporterIE7PasswordInfo& password_info) {
   IE7PasswordInfo ie7_password_info;
   ie7_password_info.url_hash = password_info.url_hash;
   ie7_password_info.encrypted_data = password_info.encrypted_data;
   ie7_password_info.date_created = password_info.date_created;
 
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&ProfileWriter::AddIE7PasswordInfo, writer_,
-                 ie7_password_info));
+  writer_->AddIE7PasswordInfo(ie7_password_info);
 }
 #endif  // OS_WIN
 
 void InProcessImporterBridge::SetFavicons(
     const favicon_base::FaviconUsageDataList& favicons) {
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&ProfileWriter::AddFavicons, writer_, favicons));
+  writer_->AddFavicons(favicons);
 }
 
 void InProcessImporterBridge::SetHistoryItems(
     const std::vector<ImporterURLRow>& rows,
     importer::VisitSource visit_source) {
   history::URLRows converted_rows =
       ConvertImporterURLRowsToHistoryURLRows(rows);
   history::VisitSource converted_visit_source =
       ConvertImporterVisitSourceToHistoryVisitSource(visit_source);
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&ProfileWriter::AddHistoryPage,
-                                     writer_,
-                                     converted_rows,
-                                     converted_visit_source));
+  writer_->AddHistoryPage(converted_rows, converted_visit_source);
 }
 
 void InProcessImporterBridge::SetKeywords(
     const std::vector<importer::SearchEngineInfo>& search_engines,
     bool unique_on_host_and_path) {
   TemplateURLService::OwnedTemplateURLVector owned_template_urls;
   for (const auto& search_engine : search_engines) {
     std::unique_ptr<TemplateURL> owned_template_url = CreateTemplateURL(
         search_engine.url, search_engine.keyword, search_engine.display_name);
     if (owned_template_url)
       owned_template_urls.push_back(std::move(owned_template_url));
   }
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-      base::Bind(&ProfileWriter::AddKeywords, writer_,
-                 base::Passed(&owned_template_urls), unique_on_host_and_path));
+  writer_->AddKeywords(std::move(owned_template_urls), unique_on_host_and_path);
 }
 
 void InProcessImporterBridge::SetFirefoxSearchEnginesXMLData(
     const std::vector<std::string>& search_engine_data) {
   TemplateURLService::OwnedTemplateURLVector search_engines;
   ParseSearchEnginesFromFirefoxXMLData(search_engine_data, &search_engines);
 
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::Bind(&ProfileWriter::AddKeywords, writer_,
-                                     base::Passed(&search_engines), true));
+  writer_->AddKeywords(std::move(search_engines), true);
 }
 
 void InProcessImporterBridge::SetPasswordForm(
     const autofill::PasswordForm& form) {
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&ProfileWriter::AddPasswordForm, writer_, form));
+  writer_->AddPasswordForm(form);
 }
 
 void InProcessImporterBridge::SetAutofillFormData(
     const std::vector<ImporterAutofillFormDataEntry>& entries) {
   std::vector<autofill::AutofillEntry> autofill_entries;
   for (size_t i = 0; i < entries.size(); ++i) {
     autofill_entries.push_back(autofill::AutofillEntry(
         autofill::AutofillKey(entries[i].name, entries[i].value),
         entries[i].first_used,
         entries[i].last_used));
   }
 
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&ProfileWriter::AddAutofillFormDataEntries,
-                                     writer_,
-                                     autofill_entries));
+  writer_->AddAutofillFormDataEntries(autofill_entries);
 }
 
 void InProcessImporterBridge::NotifyStarted() {
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&ExternalProcessImporterHost::NotifyImportStarted, host_));
+  host_->NotifyImportStarted();
 }
 
 void InProcessImporterBridge::NotifyItemStarted(importer::ImportItem item) {
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&ExternalProcessImporterHost::NotifyImportItemStarted,
-                 host_, item));
+  host_->NotifyImportItemStarted(item);
 }
 
 void InProcessImporterBridge::NotifyItemEnded(importer::ImportItem item) {
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&ExternalProcessImporterHost::NotifyImportItemEnded,
-                 host_, item));
+  host_->NotifyImportItemEnded(item);
 }
 
 void InProcessImporterBridge::NotifyEnded() {
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&ExternalProcessImporterHost::NotifyImportEnded, host_));
+  host_->NotifyImportEnded();
 }
 
 base::string16 InProcessImporterBridge::GetLocalizedString(int message_id) {
   return l10n_util::GetStringUTF16(message_id);
 }
 
 InProcessImporterBridge::~InProcessImporterBridge() {}