Convert profile import IPCs to Mojo

chrome/utility/importer/external_process_importer_bridge.h

 // 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.
 
 #ifndef CHROME_UTILITY_IMPORTER_EXTERNAL_PROCESS_IMPORTER_BRIDGE_H_
 #define CHROME_UTILITY_IMPORTER_EXTERNAL_PROCESS_IMPORTER_BRIDGE_H_
 
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 13 matching lines @@
 }
 
 namespace importer {
 #if defined(OS_WIN)
 struct ImporterIE7PasswordInfo;
 #endif
 struct ImporterURLRow;
 struct SearchEngineInfo;
 }
 
-namespace IPC {
-class Message;
-class Sender;
-}
+namespace chrome {
+namespace mojom {
+class ProfileImportObserver;
+}  // namespace mojom
+}  // namespace chrome
+
+// TODO(tibell): Now that profile import is a Mojo service perhaps ImportBridge,
+// ProfileWriter or something in between should be the actual Mojo interface,
+// instead of having the current split.
 
 // When the importer is run in an external process, the bridge is effectively
 // split in half by the IPC infrastructure.  The external bridge receives data
 // and notifications from the importer, and sends it across IPC.  The
 // internal bridge gathers the data from the IPC host and writes it to the
 // profile.
 class ExternalProcessImporterBridge : public ImporterBridge {
  public:
-  ExternalProcessImporterBridge(
-      const base::DictionaryValue& localized_strings,
-      IPC::Sender* sender,
-      base::TaskRunner* task_runner);
+  // |observer| must outlive this object.
+  ExternalProcessImporterBridge(const base::DictionaryValue& localized_strings,
+                                scoped_refptr<base::TaskRunner> task_runner,
+                                chrome::mojom::ProfileImportObserver* observer);
 
   // Begin ImporterBridge implementation:
   void AddBookmarks(const std::vector<ImportedBookmarkEntry>& bookmarks,
                     const base::string16& first_folder_name) override;
 
   void AddHomePage(const GURL& home_page) override;
 
 #if defined(OS_WIN)
   void AddIE7PasswordInfo(
       const importer::ImporterIE7PasswordInfo& password_info) override;
@@ skipping 20 matching lines @@
   void NotifyItemStarted(importer::ImportItem item) override;
   void NotifyItemEnded(importer::ImportItem item) override;
   void NotifyEnded() override;
 
   base::string16 GetLocalizedString(int message_id) override;
   // End ImporterBridge implementation.
 
  private:
   ~ExternalProcessImporterBridge() override;
 
-  void Send(IPC::Message* message);
-  void SendInternal(IPC::Message* message);
+  // Helper to send messages through |observer_| on the right thread. First
+  // argument should be a method on chrome::mojom::ProfileImportObserver and the
+  // remaining arguments should be the arguments to pass to that method.
+  template <typename Functor, typename... Args>
+  void Send(Functor&& functor, Args&&... args);

[dcheng, 2016/11/11 08:46:50]

I'm not a fan of these sorts of helpers.

Dumb question: why can't we just rebind the interface on the right thread so it
Just Works?

[tibell, 2016/11/14 05:35:31]

I discussed this with Sam earlier in the review. Messages are sent from two
different threads so one of them has to post. Someone could rethink how this
works, but that's better done by the owners of this code.

 
   // Holds strings needed by the external importer because the resource
   // bundle isn't available to the external process.
   std::unique_ptr<base::DictionaryValue> localized_strings_;
 
-  IPC::Sender* sender_;
+  // The task runner that |observer_| methods must be called on.
   scoped_refptr<base::TaskRunner> task_runner_;
 
+  chrome::mojom::ProfileImportObserver* observer_;
+
   DISALLOW_COPY_AND_ASSIGN(ExternalProcessImporterBridge);
 };
 
 #endif  // CHROME_UTILITY_IMPORTER_EXTERNAL_PROCESS_IMPORTER_BRIDGE_H_