Migrate parser_interface.mojom to the new Mojo types

Convert the implementation and all users of the
chrome_cleaner::mojom::Parser interface.

Bug: 955171
Change-Id: I244eda469c157da15ea5015f3af5ac554ca48734
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1833463
Commit-Queue: Henrique Ferreiro <hferreiro@igalia.com>
Reviewed-by: Joe Mason <joenotcharles@chromium.org>
Reviewed-by: Ken Rockot <rockot@google.com>
Cr-Commit-Position: refs/heads/master@{#707349}

chrome/chrome_cleaner/engines/controllers/extension_removal_unittest.cc

@@ -254,10 +254,10 @@ class ExtensionCleanupTest : public base::MultiProcessTest {
     CHECK_EQ(RESULT_CODE_SUCCESS,
              StartSandboxTarget(MakeCmdLine("EngineSandboxMain"),
                                 &engine_setup_hooks, SandboxType::kTest));
-    json_parser_ptr_ = std::make_unique<chrome_cleaner::UniqueParserPtr>(
-        parser_setup_hooks.TakeParserPtr());
+    json_parser_ = std::make_unique<chrome_cleaner::RemoteParserPtr>(
+        parser_setup_hooks.TakeParserRemote());
     return std::make_unique<chrome_cleaner::SandboxedJsonParser>(
-        mojo_task_runner_.get(), json_parser_ptr_.get()->get());
+        mojo_task_runner_.get(), json_parser_.get()->get());
   }
 
  protected:
@@ -272,7 +272,7 @@ class ExtensionCleanupTest : public base::MultiProcessTest {
   testing::NiceMock<MockLoggingService> mock_logging_service_;
   base::FilePath fake_apps_dir_;
   base::FilePath chrome_dir_;
-  std::unique_ptr<chrome_cleaner::UniqueParserPtr> json_parser_ptr_;
+  std::unique_ptr<chrome_cleaner::RemoteParserPtr> json_parser_;
   scoped_refptr<chrome_cleaner::EngineClient> engine_client_;
   chrome_cleaner::TestPUPData test_pup_data_;
   std::unique_ptr<ScopedFile> uws_A_;

chrome/chrome_cleaner/executables/chrome_cleaner_main.cc

@@ -212,21 +212,20 @@ chrome_cleaner::ResultCode RunChromeCleaner(
   chrome_cleaner::SandboxConnectionErrorCallback connection_error_callback =
       main_controller.GetSandboxConnectionErrorCallback();
 
-  // Initialize a null UniqueParserPtr to be set by SpawnParserSandbox.
-  chrome_cleaner::UniqueParserPtr parser_ptr(
-      nullptr, base::OnTaskRunnerDeleter(nullptr));
+  // Initialize a null RemoteParserPtr to be set by SpawnParserSandbox.
+  chrome_cleaner::RemoteParserPtr parser(nullptr,
+                                         base::OnTaskRunnerDeleter(nullptr));
   chrome_cleaner::ResultCode init_result = chrome_cleaner::SpawnParserSandbox(
-      shutdown_sequence.mojo_task_runner, connection_error_callback,
-      &parser_ptr);
+      shutdown_sequence.mojo_task_runner, connection_error_callback, &parser);
   if (init_result != chrome_cleaner::RESULT_CODE_SUCCESS) {
     return init_result;
   }
   std::unique_ptr<chrome_cleaner::SandboxedJsonParser> json_parser =
       std::make_unique<chrome_cleaner::SandboxedJsonParser>(
-          shutdown_sequence.mojo_task_runner.get(), parser_ptr.get());
+          shutdown_sequence.mojo_task_runner.get(), parser.get());
   std::unique_ptr<chrome_cleaner::SandboxedShortcutParser> shortcut_parser =
       std::make_unique<chrome_cleaner::SandboxedShortcutParser>(
-          shutdown_sequence.mojo_task_runner.get(), parser_ptr.get());
+          shutdown_sequence.mojo_task_runner.get(), parser.get());
 
   chrome_cleaner::Settings* settings = chrome_cleaner::Settings::GetInstance();
   if (!chrome_cleaner::IsSupportedEngine(settings->engine())) {

chrome/chrome_cleaner/executables/chrome_reporter_main.cc

@@ -286,17 +286,17 @@ int APIENTRY wWinMain(HINSTANCE, HINSTANCE, wchar_t*, int) {
   DCHECK(succeeded) << "TaskScheduler::Initialize() failed";
 
   // Initialize the sandbox for the shortcut parser.
-  chrome_cleaner::UniqueParserPtr parser_ptr(
-      nullptr, base::OnTaskRunnerDeleter(nullptr));
+  chrome_cleaner::RemoteParserPtr parser(nullptr,
+                                         base::OnTaskRunnerDeleter(nullptr));
   chrome_cleaner::ResultCode parser_result_code =
       chrome_cleaner::SpawnParserSandbox(
           shutdown_sequence.mojo_task_runner.get(),
-          sandbox_connection_error_callback, &parser_ptr);
+          sandbox_connection_error_callback, &parser);
   if (parser_result_code != chrome_cleaner::RESULT_CODE_SUCCESS)
     return FinalizeWithResultCode(parser_result_code, &registry_logger);
   std::unique_ptr<chrome_cleaner::ShortcutParserAPI> shortcut_parser =
       std::make_unique<chrome_cleaner::SandboxedShortcutParser>(
-          shutdown_sequence.mojo_task_runner.get(), parser_ptr.get());
+          shutdown_sequence.mojo_task_runner.get(), parser.get());
 
   std::unique_ptr<chrome_cleaner::ScannerController> scanner_controller =
       std::make_unique<chrome_cleaner::ScannerControllerImpl>(

chrome/chrome_cleaner/parsers/broker/json_parser_sandbox_setup_unittest.cc

@@ -8,11 +8,11 @@
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/time.h"
-#include "chrome/chrome_cleaner/mojom/parser_interface.mojom.h"
 #include "chrome/chrome_cleaner/ipc/mojo_task_runner.h"
+#include "chrome/chrome_cleaner/mojom/parser_interface.mojom.h"
 #include "chrome/chrome_cleaner/parsers/broker/sandbox_setup_hooks.h"
 #include "chrome/chrome_cleaner/parsers/target/sandbox_setup.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "sandbox/win/src/sandbox_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
@@ -31,7 +31,7 @@ const char kInvalidText[] = "{ name: jason }";
 class JsonParserSandboxSetupTest : public base::MultiProcessTest {
  public:
   JsonParserSandboxSetupTest()
-      : parser_ptr_(nullptr, base::OnTaskRunnerDeleter(nullptr)) {}
+      : parser_(nullptr, base::OnTaskRunnerDeleter(nullptr)) {}
 
   void SetUp() override {
     mojo_task_runner_ = MojoTaskRunner::Create();
@@ -41,12 +41,12 @@ class JsonParserSandboxSetupTest : public base::MultiProcessTest {
     ASSERT_EQ(RESULT_CODE_SUCCESS,
               StartSandboxTarget(MakeCmdLine("JsonParserSandboxTargetMain"),
                                  &setup_hooks, SandboxType::kTest));
-    parser_ptr_ = setup_hooks.TakeParserPtr();
+    parser_ = setup_hooks.TakeParserRemote();
   }
 
  protected:
   scoped_refptr<MojoTaskRunner> mojo_task_runner_;
-  UniqueParserPtr parser_ptr_;
+  RemoteParserPtr parser_;
 };
 
 void ParseCallbackExpectedKeyValue(const std::string& expected_key,
@@ -93,15 +93,14 @@ TEST_F(JsonParserSandboxSetupTest, ParseValidJsonSandboxed) {
                      WaitableEvent::InitialState::NOT_SIGNALED);
 
   mojo_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(
-                     [](mojom::ParserPtr* parser_ptr, WaitableEvent* done) {
-                       (*parser_ptr)
-                           ->ParseJson(
-                               kTestText,
-                               base::BindOnce(&ParseCallbackExpectedKeyValue,
-                                              kTestKey, kTestValue, done));
-                     },
-                     parser_ptr_.get(), &done));
+      FROM_HERE,
+      base::BindOnce(
+          [](mojo::Remote<mojom::Parser>* parser, WaitableEvent* done) {
+            (*parser)->ParseJson(kTestText,
+                                 base::BindOnce(&ParseCallbackExpectedKeyValue,
+                                                kTestKey, kTestValue, done));
+          },
+          parser_.get(), &done));
   EXPECT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));
 }
 
@@ -112,12 +111,12 @@ TEST_F(JsonParserSandboxSetupTest, ParseInvalidJsonSandboxed) {
   mojo_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(
-          [](mojom::ParserPtr* parser_ptr, WaitableEvent* done) {
-            (*parser_ptr)
-                ->ParseJson(kInvalidText,
-                            base::BindOnce(&ParseCallbackExpectedError, done));
+          [](mojo::Remote<mojom::Parser>* parser, WaitableEvent* done) {
+            (*parser)->ParseJson(
+                kInvalidText,
+                base::BindOnce(&ParseCallbackExpectedError, done));
           },
-          parser_ptr_.get(), &done));
+          parser_.get(), &done));
   EXPECT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));
 }
 

chrome/chrome_cleaner/parsers/broker/lnk_parser_sandbox_setup_unittest.cc

@@ -28,7 +28,7 @@ namespace chrome_cleaner {
 class LnkParserSandboxSetupTest : public base::MultiProcessTest {
  public:
   LnkParserSandboxSetupTest()
-      : parser_ptr_(nullptr, base::OnTaskRunnerDeleter(nullptr)) {}
+      : parser_(nullptr, base::OnTaskRunnerDeleter(nullptr)) {}
 
   void SetUp() override {
     mojo_task_runner_ = MojoTaskRunner::Create();
@@ -38,9 +38,9 @@ class LnkParserSandboxSetupTest : public base::MultiProcessTest {
     ASSERT_EQ(RESULT_CODE_SUCCESS,
               StartSandboxTarget(MakeCmdLine("LnkParserSandboxTargetMain"),
                                  &setup_hooks, SandboxType::kTest));
-    parser_ptr_ = setup_hooks.TakeParserPtr();
+    parser_ = setup_hooks.TakeParserRemote();
     shortcut_parser_ = std::make_unique<SandboxedShortcutParser>(
-        mojo_task_runner_.get(), parser_ptr_.get());
+        mojo_task_runner_.get(), parser_.get());
 
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.GetPath(),
@@ -49,7 +49,7 @@ class LnkParserSandboxSetupTest : public base::MultiProcessTest {
 
  protected:
   scoped_refptr<MojoTaskRunner> mojo_task_runner_;
-  UniqueParserPtr parser_ptr_;
+  RemoteParserPtr parser_;
 
   std::unique_ptr<ShortcutParserAPI> shortcut_parser_;
   ParsedLnkFile test_parsed_shortcut_;

chrome/chrome_cleaner/parsers/broker/sandbox_setup_hooks.cc

@@ -8,7 +8,10 @@
 
 #include "base/bind.h"
 #include "chrome/chrome_cleaner/constants/chrome_cleaner_switches.h"
+#include "chrome/chrome_cleaner/mojom/parser_interface.mojom.h"
 #include "chrome/chrome_cleaner/settings/settings_types.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace chrome_cleaner {
 
@@ -17,47 +20,46 @@ ParserSandboxSetupHooks::ParserSandboxSetupHooks(
     base::OnceClosure connection_error_handler)
     : mojo_task_runner_(mojo_task_runner),
       connection_error_handler_(std::move(connection_error_handler)),
-      parser_ptr_(new mojom::ParserPtr(),
-                  base::OnTaskRunnerDeleter(mojo_task_runner_)) {}
+      parser_(new mojo::Remote<mojom::Parser>(),
+              base::OnTaskRunnerDeleter(mojo_task_runner_)) {}
 
 ParserSandboxSetupHooks::~ParserSandboxSetupHooks() = default;
 
 ResultCode ParserSandboxSetupHooks::UpdateSandboxPolicy(
     sandbox::TargetPolicy* policy,
     base::CommandLine* command_line) {
-  // Unretained reference is safe because the parser_ptr is taken by the
+  // Unretained reference is safe because the parser remote is taken by the
   // caller and is expected to retain it for the life of the sandboxed process.
   mojo_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&ParserSandboxSetupHooks::BindParserPtr,
+      FROM_HERE, base::BindOnce(&ParserSandboxSetupHooks::BindParserRemote,
                                 base::Unretained(this),
                                 SetupSandboxMessagePipe(policy, command_line),
-                                base::Unretained(parser_ptr_.get())));
+                                base::Unretained(parser_.get())));
 
   return RESULT_CODE_SUCCESS;
 }
 
-void ParserSandboxSetupHooks::BindParserPtr(
+void ParserSandboxSetupHooks::BindParserRemote(
     mojo::ScopedMessagePipeHandle pipe_handle,
-    mojom::ParserPtr* parser_ptr) {
-  parser_ptr->Bind(mojom::ParserPtrInfo(std::move(pipe_handle), 0));
-  parser_ptr->set_connection_error_handler(
-      std::move(connection_error_handler_));
+    mojo::Remote<mojom::Parser>* parser) {
+  parser->Bind(mojo::PendingRemote<mojom::Parser>(std::move(pipe_handle), 0));
+  parser->set_disconnect_handler(std::move(connection_error_handler_));
 }
 
-UniqueParserPtr ParserSandboxSetupHooks::TakeParserPtr() {
-  return std::move(parser_ptr_);
+RemoteParserPtr ParserSandboxSetupHooks::TakeParserRemote() {
+  return std::move(parser_);
 }
 
 ResultCode SpawnParserSandbox(
     scoped_refptr<MojoTaskRunner> mojo_task_runner,
     const SandboxConnectionErrorCallback& connection_error_callback,
-    UniqueParserPtr* parser_ptr) {
+    RemoteParserPtr* parser) {
   auto error_handler =
       base::BindOnce(connection_error_callback, SandboxType::kParser);
   ParserSandboxSetupHooks setup_hooks(mojo_task_runner,
                                       std::move(error_handler));
   ResultCode result_code = SpawnSandbox(&setup_hooks, SandboxType::kParser);
-  *parser_ptr = setup_hooks.TakeParserPtr();
+  *parser = setup_hooks.TakeParserRemote();
 
   return result_code;
 }

chrome/chrome_cleaner/parsers/broker/sandbox_setup_hooks.h

@@ -8,17 +8,18 @@
 #include <memory>
 
 #include "base/command_line.h"
-#include "chrome/chrome_cleaner/mojom/parser_interface.mojom.h"
 #include "chrome/chrome_cleaner/ipc/mojo_sandbox_hooks.h"
 #include "chrome/chrome_cleaner/ipc/mojo_task_runner.h"
 #include "chrome/chrome_cleaner/ipc/sandbox.h"
+#include "chrome/chrome_cleaner/mojom/parser_interface.mojom.h"
 #include "components/chrome_cleaner/public/constants/result_codes.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 
 namespace chrome_cleaner {
 
-using UniqueParserPtr =
-    std::unique_ptr<mojom::ParserPtr, base::OnTaskRunnerDeleter>;
+using RemoteParserPtr =
+    std::unique_ptr<mojo::Remote<mojom::Parser>, base::OnTaskRunnerDeleter>;
 
 // Hooks to spawn a new sandboxed Parser process and bind a Mojo interface
 // pointer to the sandboxed implementation.
@@ -28,31 +29,31 @@ class ParserSandboxSetupHooks : public MojoSandboxSetupHooks {
                           base::OnceClosure connection_error_handler);
   ~ParserSandboxSetupHooks() override;
 
-  // Transfers ownership of |parser_ptr_| to the caller.
-  UniqueParserPtr TakeParserPtr();
+  // Transfers ownership of |parser_| to the caller.
+  RemoteParserPtr TakeParserRemote();
 
   // SandboxSetupHooks
   ResultCode UpdateSandboxPolicy(sandbox::TargetPolicy* policy,
                                  base::CommandLine* command_line) override;
 
  private:
-  void BindParserPtr(mojo::ScopedMessagePipeHandle pipe_handle,
-                     mojom::ParserPtr* parser_ptr);
+  void BindParserRemote(mojo::ScopedMessagePipeHandle pipe_handle,
+                        mojo::Remote<mojom::Parser>* parser);
 
   scoped_refptr<MojoTaskRunner> mojo_task_runner_;
   base::OnceClosure connection_error_handler_;
 
-  UniqueParserPtr parser_ptr_;
+  RemoteParserPtr parser_;
 
   DISALLOW_COPY_AND_ASSIGN(ParserSandboxSetupHooks);
 };
 
 // Spawn a sandboxed process with type kParser, and return the bound
-// |parser_ptr|.
+// |parser|.
 ResultCode SpawnParserSandbox(
     scoped_refptr<MojoTaskRunner> mojo_task_runner,
     const SandboxConnectionErrorCallback& connection_error_callback,
-    UniqueParserPtr* parser_ptr);
+    RemoteParserPtr* parser);
 
 }  // namespace chrome_cleaner
 

chrome/chrome_cleaner/parsers/json_parser/json_splicer_unittest.cc

@@ -13,11 +13,11 @@
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/values.h"
-#include "chrome/chrome_cleaner/mojom/parser_interface.mojom.h"
 #include "chrome/chrome_cleaner/ipc/mojo_task_runner.h"
+#include "chrome/chrome_cleaner/mojom/parser_interface.mojom.h"
 #include "chrome/chrome_cleaner/parsers/json_parser/sandboxed_json_parser.h"
 #include "chrome/chrome_cleaner/parsers/target/parser_impl.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chrome_cleaner {
@@ -62,24 +62,25 @@ class JsonSplicerImplTest : public testing::Test {
  public:
   JsonSplicerImplTest()
       : task_runner_(MojoTaskRunner::Create()),
-        parser_ptr_(new mojom::ParserPtr(),
-                    base::OnTaskRunnerDeleter(task_runner_)),
+        parser_(new mojo::Remote<mojom::Parser>(),
+                base::OnTaskRunnerDeleter(task_runner_)),
         parser_impl_(nullptr, base::OnTaskRunnerDeleter(task_runner_)),
-        sandboxed_json_parser_(task_runner_.get(), parser_ptr_.get()) {
-    task_runner_->PostTask(
-        FROM_HERE, BindOnce(BindParser, parser_ptr_.get(), &parser_impl_));
+        sandboxed_json_parser_(task_runner_.get(), parser_.get()) {
+    task_runner_->PostTask(FROM_HERE,
+                           BindOnce(BindParser, parser_.get(), &parser_impl_));
   }
 
  protected:
   static void BindParser(
-      mojom::ParserPtr* json_parser,
+      mojo::Remote<mojom::Parser>* json_parser,
       std::unique_ptr<ParserImpl, base::OnTaskRunnerDeleter>* parser_impl) {
-    parser_impl->reset(
-        new ParserImpl(mojo::MakeRequest(json_parser), base::DoNothing()));
+    parser_impl->reset(new ParserImpl(json_parser->BindNewPipeAndPassReceiver(),
+                                      base::DoNothing()));
   }
 
   scoped_refptr<MojoTaskRunner> task_runner_;
-  std::unique_ptr<mojom::ParserPtr, base::OnTaskRunnerDeleter> parser_ptr_;
+  std::unique_ptr<mojo::Remote<mojom::Parser>, base::OnTaskRunnerDeleter>
+      parser_;
   std::unique_ptr<ParserImpl, base::OnTaskRunnerDeleter> parser_impl_;
   SandboxedJsonParser sandboxed_json_parser_;
 };

chrome/chrome_cleaner/parsers/json_parser/sandboxed_json_parser.cc

@@ -4,23 +4,25 @@
 
 #include "chrome/chrome_cleaner/parsers/json_parser/sandboxed_json_parser.h"
 
+#include <utility>
+
 #include "base/bind.h"
 
 namespace chrome_cleaner {
 
 SandboxedJsonParser::SandboxedJsonParser(MojoTaskRunner* mojo_task_runner,
-                                         mojom::ParserPtr* parser_ptr)
-    : mojo_task_runner_(mojo_task_runner), parser_ptr_(parser_ptr) {}
+                                         mojo::Remote<mojom::Parser>* parser)
+    : mojo_task_runner_(mojo_task_runner), parser_(parser) {}
 
 void SandboxedJsonParser::Parse(const std::string& json,
                                 ParseDoneCallback callback) {
   mojo_task_runner_->PostTask(
       FROM_HERE, base::BindOnce(
-                     [](mojom::ParserPtr* parser_ptr, const std::string& json,
-                        ParseDoneCallback callback) {
-                       (*parser_ptr)->ParseJson(json, std::move(callback));
+                     [](mojo::Remote<mojom::Parser>* parser,
+                        const std::string& json, ParseDoneCallback callback) {
+                       (*parser)->ParseJson(json, std::move(callback));
                      },
-                     parser_ptr_, json, std::move(callback)));
+                     parser_, json, std::move(callback)));
 }
 
 }  // namespace chrome_cleaner

chrome/chrome_cleaner/parsers/json_parser/sandboxed_json_parser.h

@@ -5,24 +5,25 @@
 #ifndef CHROME_CHROME_CLEANER_PARSERS_JSON_PARSER_SANDBOXED_JSON_PARSER_H_
 #define CHROME_CHROME_CLEANER_PARSERS_JSON_PARSER_SANDBOXED_JSON_PARSER_H_
 
-#include "chrome/chrome_cleaner/mojom/parser_interface.mojom.h"
 #include "chrome/chrome_cleaner/ipc/mojo_task_runner.h"
+#include "chrome/chrome_cleaner/mojom/parser_interface.mojom.h"
 #include "chrome/chrome_cleaner/parsers/json_parser/json_parser_api.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace chrome_cleaner {
 
 // An implementation of JsonParserAPI to wrap a MojoTaskRunner and
-// JsonParserPtr. Parses via |parser_ptr_| on the |mojo_task_runner_|.
+// JsonParserPtr. Parses via |parser_| on the |mojo_task_runner_|.
 // TODO(joenotcharles): Move this class to chrome_cleaner/parsers/broker.
 class SandboxedJsonParser : public JsonParserAPI {
  public:
   SandboxedJsonParser(MojoTaskRunner* mojo_task_runner,
-                      mojom::ParserPtr* parser_ptr);
+                      mojo::Remote<mojom::Parser>* parser);
   void Parse(const std::string& json, ParseDoneCallback callback) override;
 
  private:
   MojoTaskRunner* mojo_task_runner_;
-  mojom::ParserPtr* parser_ptr_;
+  mojo::Remote<mojom::Parser>* parser_;
 };
 
 }  // namespace chrome_cleaner

chrome/chrome_cleaner/parsers/shortcut_parser/broker/sandboxed_shortcut_parser.cc

@@ -17,14 +17,15 @@
 #include "base/win/scoped_handle.h"
 #include "chrome/chrome_cleaner/mojom/parser_interface.mojom.h"
 #include "chrome/chrome_cleaner/parsers/parser_utils/parse_tasks_remaining_counter.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 
 namespace chrome_cleaner {
 
 SandboxedShortcutParser::SandboxedShortcutParser(
     MojoTaskRunner* mojo_task_runner,
-    mojom::ParserPtr* parser_ptr)
-    : mojo_task_runner_(mojo_task_runner), parser_ptr_(parser_ptr) {}
+    mojo::Remote<mojom::Parser>* parser)
+    : mojo_task_runner_(mojo_task_runner), parser_(parser) {}
 
 void SandboxedShortcutParser::ParseShortcut(
     base::win::ScopedHandle shortcut_handle,
@@ -32,12 +33,11 @@ void SandboxedShortcutParser::ParseShortcut(
   mojo_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(
-          [](mojom::ParserPtr* parser_ptr, mojo::ScopedHandle handle,
+          [](mojo::Remote<mojom::Parser>* parser, mojo::ScopedHandle handle,
              mojom::Parser::ParseShortcutCallback callback) {
-            (*parser_ptr)
-                ->ParseShortcut(std::move(handle), std::move(callback));
+            (*parser)->ParseShortcut(std::move(handle), std::move(callback));
           },
-          parser_ptr_, mojo::WrapPlatformFile(shortcut_handle.Take()),
+          parser_, mojo::WrapPlatformFile(shortcut_handle.Take()),
           std::move(callback)));
 }
 

chrome/chrome_cleaner/parsers/shortcut_parser/broker/sandboxed_shortcut_parser.h

@@ -8,18 +8,19 @@
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/win/scoped_handle.h"
-#include "chrome/chrome_cleaner/mojom/parser_interface.mojom.h"
 #include "chrome/chrome_cleaner/ipc/mojo_task_runner.h"
+#include "chrome/chrome_cleaner/mojom/parser_interface.mojom.h"
 #include "chrome/chrome_cleaner/os/file_path_set.h"
 #include "chrome/chrome_cleaner/parsers/parser_utils/parse_tasks_remaining_counter.h"
 #include "chrome/chrome_cleaner/parsers/shortcut_parser/broker/shortcut_parser_api.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace chrome_cleaner {
 
 class SandboxedShortcutParser : public ShortcutParserAPI {
  public:
   SandboxedShortcutParser(MojoTaskRunner* mojo_task_runner,
-                          mojom::ParserPtr* parser_ptr);
+                          mojo::Remote<mojom::Parser>* parser);
 
   // ShortcutParserAPI
   void FindAndParseChromeShortcutsInFoldersAsync(
@@ -48,7 +49,7 @@ class SandboxedShortcutParser : public ShortcutParserAPI {
 
   base::Lock lock_;
   MojoTaskRunner* mojo_task_runner_;
-  mojom::ParserPtr* parser_ptr_;
+  mojo::Remote<mojom::Parser>* parser_;
 };
 
 }  // namespace chrome_cleaner

chrome/chrome_cleaner/parsers/shortcut_parser/broker/sandboxed_shortcut_parser_unittest.cc

@@ -36,7 +36,7 @@ const base::string16 kLnkArguments = L"-a -b -c -d GenericExample";
 class SandboxedShortcutParserTest : public base::MultiProcessTest {
  public:
   SandboxedShortcutParserTest()
-      : parser_ptr_(nullptr, base::OnTaskRunnerDeleter(nullptr)),
+      : parser_(nullptr, base::OnTaskRunnerDeleter(nullptr)),
         temp_dirs_with_chrome_lnk_(kDirQuantity) {}
 
   void SetUp() override {
@@ -48,9 +48,9 @@ class SandboxedShortcutParserTest : public base::MultiProcessTest {
         RESULT_CODE_SUCCESS,
         StartSandboxTarget(MakeCmdLine("SandboxedShortcutParserTargetMain"),
                            &setup_hooks, SandboxType::kTest));
-    parser_ptr_ = setup_hooks.TakeParserPtr();
+    parser_ = setup_hooks.TakeParserRemote();
     shortcut_parser_ = std::make_unique<SandboxedShortcutParser>(
-        mojo_task_runner_.get(), parser_ptr_.get());
+        mojo_task_runner_.get(), parser_.get());
 
     ASSERT_TRUE(temp_dir_without_chrome_lnk_.CreateUniqueTempDir());
     ASSERT_TRUE(base::CreateTemporaryFileInDir(
@@ -87,7 +87,7 @@ class SandboxedShortcutParserTest : public base::MultiProcessTest {
   size_t shortcut_quantity_ = 0;
 
   scoped_refptr<MojoTaskRunner> mojo_task_runner_;
-  UniqueParserPtr parser_ptr_;
+  RemoteParserPtr parser_;
   std::unique_ptr<SandboxedShortcutParser> shortcut_parser_;
 
   FilePathSet fake_chrome_exe_file_path_set_;

chrome/chrome_cleaner/parsers/target/parser_impl.cc

@@ -4,6 +4,8 @@
 
 #include "chrome/chrome_cleaner/parsers/target/parser_impl.h"
 
+#include <utility>
+
 #include "base/json/json_reader.h"
 #include "base/values.h"
 #include "base/win/scoped_handle.h"
@@ -12,10 +14,10 @@
 
 namespace chrome_cleaner {
 
-ParserImpl::ParserImpl(mojom::ParserRequest request,
+ParserImpl::ParserImpl(mojo::PendingReceiver<mojom::Parser> receiver,
                        base::OnceClosure connection_error_handler)
-    : binding_(this, std::move(request)) {
-  binding_.set_connection_error_handler(std::move(connection_error_handler));
+    : receiver_(this, std::move(receiver)) {
+  receiver_.set_disconnect_handler(std::move(connection_error_handler));
 }
 
 ParserImpl::~ParserImpl() = default;

chrome/chrome_cleaner/parsers/target/parser_impl.h

@@ -6,13 +6,14 @@
 #define CHROME_CHROME_CLEANER_PARSERS_TARGET_PARSER_IMPL_H_
 
 #include "chrome/chrome_cleaner/mojom/parser_interface.mojom.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 
 namespace chrome_cleaner {
 
 class ParserImpl : public mojom::Parser {
  public:
-  explicit ParserImpl(mojom::ParserRequest request,
+  explicit ParserImpl(mojo::PendingReceiver<mojom::Parser> receiver,
                       base::OnceClosure connection_error_handler);
   ~ParserImpl() override;
 
@@ -25,7 +26,7 @@ class ParserImpl : public mojom::Parser {
                      ParserImpl::ParseShortcutCallback callback) override;
 
  private:
-  mojo::Binding<mojom::Parser> binding_;
+  mojo::Receiver<mojom::Parser> receiver_;
 };
 
 }  // namespace chrome_cleaner

chrome/chrome_cleaner/parsers/target/parser_impl_unittest.cc

@@ -22,7 +22,7 @@
 #include "chrome/chrome_cleaner/parsers/shortcut_parser/broker/sandboxed_shortcut_parser.h"
 #include "chrome/chrome_cleaner/parsers/shortcut_parser/sandboxed_lnk_parser_test_util.h"
 #include "chrome/chrome_cleaner/parsers/shortcut_parser/target/lnk_parser.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -41,11 +41,11 @@ class ParserImplTest : public testing::Test {
  public:
   ParserImplTest()
       : task_runner_(MojoTaskRunner::Create()),
-        parser_ptr_(new mojom::ParserPtr(),
-                    base::OnTaskRunnerDeleter(task_runner_)),
+        parser_(new mojo::Remote<mojom::Parser>(),
+                base::OnTaskRunnerDeleter(task_runner_)),
         parser_impl_(nullptr, base::OnTaskRunnerDeleter(task_runner_)),
-        sandboxed_json_parser_(task_runner_.get(), parser_ptr_.get()),
-        shortcut_parser_(task_runner_.get(), parser_ptr_.get()) {}
+        sandboxed_json_parser_(task_runner_.get(), parser_.get()),
+        shortcut_parser_(task_runner_.get(), parser_.get()) {}
 
   void SetUp() override {
     BindParser();
@@ -59,17 +59,18 @@ class ParserImplTest : public testing::Test {
     task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(
-            [](mojom::ParserPtr* parser,
+            [](mojo::Remote<mojom::Parser>* parser,
                std::unique_ptr<ParserImpl, base::OnTaskRunnerDeleter>*
                    parser_impl) {
-              parser_impl->reset(
-                  new ParserImpl(mojo::MakeRequest(parser), base::DoNothing()));
+              parser_impl->reset(new ParserImpl(
+                  parser->BindNewPipeAndPassReceiver(), base::DoNothing()));
             },
-            parser_ptr_.get(), &parser_impl_));
+            parser_.get(), &parser_impl_));
   }
 
   scoped_refptr<MojoTaskRunner> task_runner_;
-  std::unique_ptr<mojom::ParserPtr, base::OnTaskRunnerDeleter> parser_ptr_;
+  std::unique_ptr<mojo::Remote<mojom::Parser>, base::OnTaskRunnerDeleter>
+      parser_;
   std::unique_ptr<ParserImpl, base::OnTaskRunnerDeleter> parser_impl_;
   SandboxedJsonParser sandboxed_json_parser_;
 

chrome/chrome_cleaner/parsers/target/sandbox_setup.cc

@@ -14,6 +14,7 @@
 #include "chrome/chrome_cleaner/os/early_exit.h"
 #include "chrome/chrome_cleaner/parsers/target/parser_impl.h"
 #include "components/chrome_cleaner/public/constants/result_codes.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 
 namespace chrome_cleaner {
 
@@ -37,7 +38,8 @@ class ParserSandboxTargetHooks : public MojoSandboxTargetHooks {
   // SandboxTargetHooks
   ResultCode TargetDroppedPrivileges(
       const base::CommandLine& command_line) override {
-    mojom::ParserRequest request(ExtractSandboxMessagePipe(command_line));
+    mojo::PendingReceiver<mojom::Parser> receiver(
+        ExtractSandboxMessagePipe(command_line));
 
     // This loop will run forever. Once the communication channel with the
     // broker process is broken, mojo error handler will abort this process.
@@ -45,14 +47,14 @@ class ParserSandboxTargetHooks : public MojoSandboxTargetHooks {
     mojo_task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&ParserSandboxTargetHooks::CreateParserImpl,
-                       base::Unretained(this), base::Passed(&request)));
+                       base::Unretained(this), base::Passed(&receiver)));
     run_loop.Run();
     return RESULT_CODE_SUCCESS;
   }
 
  private:
-  void CreateParserImpl(mojom::ParserRequest request) {
-    parser_impl_ = std::make_unique<ParserImpl>(std::move(request),
+  void CreateParserImpl(mojo::PendingReceiver<mojom::Parser> receiver) {
+    parser_impl_ = std::make_unique<ParserImpl>(std::move(receiver),
                                                 base::BindOnce(&EarlyExit, 1));
   }