Convert interfaces from pdf_to_emf_converter.mojom to new Mojo types

This CL converts PdfToEmfConverterClient, PdfToEmfConverter,
and PdfToEmfConverterFactory to new mojo types using
PendingRemote, Remote. Receiver, and PendingReceiver.

Bug: 955171
Change-Id: I9e76d7b9360856e7f415ec24d408fd9d6a21e227
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1827276Reviewed-by: Lei Zhang <thestig@chromium.org>
Reviewed-by: Sam McNally <sammc@chromium.org>
Reviewed-by: Ken Rockot <rockot@google.com>
Commit-Queue: Julie Kim <jkim@igalia.com>
Cr-Commit-Position: refs/heads/master@{#704010}

chrome/browser/printing/pdf_to_emf_converter.cc

@@ -28,7 +28,10 @@
 #include "chrome/services/printing/public/mojom/pdf_to_emf_converter.mojom.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/receiver.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "printing/emf_win.h"
 #include "printing/pdf_render_settings.h"
 
@@ -41,8 +44,8 @@ namespace {
 class PdfToEmfConverterClientImpl : public mojom::PdfToEmfConverterClient {
  public:
   explicit PdfToEmfConverterClientImpl(
-      mojom::PdfToEmfConverterClientRequest request)
-      : binding_(this, std::move(request)) {}
+      mojo::PendingReceiver<mojom::PdfToEmfConverterClient> receiver)
+      : receiver_(this, std::move(receiver)) {}
 
  private:
   // mojom::PdfToEmfConverterClient implementation.
@@ -84,7 +87,7 @@ class PdfToEmfConverterClientImpl : public mojom::PdfToEmfConverterClient {
     std::move(callback).Run();
   }
 
-  mojo::Binding<mojom::PdfToEmfConverterClient> binding_;
+  mojo::Receiver<mojom::PdfToEmfConverterClient> receiver_;
 };
 
 // Emf subclass that knows how to play back PostScript data embedded as EMF
@@ -164,7 +167,8 @@ class PdfConverterImpl : public PdfConverter {
   std::unique_ptr<MetafilePlayer> GetMetaFileFromMapping(
       base::ReadOnlySharedMemoryMapping mapping);
 
-  void OnPageCount(mojom::PdfToEmfConverterPtr converter, uint32_t page_count);
+  void OnPageCount(mojo::PendingRemote<mojom::PdfToEmfConverter> converter,
+                   uint32_t page_count);
   void OnPageDone(base::ReadOnlySharedMemoryRegion emf_region,
                   float scale_factor);
 
@@ -191,9 +195,9 @@ class PdfConverterImpl : public PdfConverter {
   std::unique_ptr<PdfToEmfConverterClientImpl>
       pdf_to_emf_converter_client_impl_;
 
-  mojom::PdfToEmfConverterPtr pdf_to_emf_converter_;
+  mojo::Remote<mojom::PdfToEmfConverter> pdf_to_emf_converter_;
 
-  mojom::PdfToEmfConverterFactoryPtr pdf_to_emf_converter_factory_;
+  mojo::Remote<mojom::PdfToEmfConverterFactory> pdf_to_emf_converter_factory_;
 
   base::WeakPtrFactory<PdfConverterImpl> weak_ptr_factory_{this};
 
@@ -269,29 +273,31 @@ void PdfConverterImpl::Initialize(scoped_refptr<base::RefCountedMemory> data) {
   memcpy(memory.mapping.memory(), data->front(), data->size());
 
   GetPrintingService()->BindPdfToEmfConverterFactory(
-      mojo::MakeRequest(&pdf_to_emf_converter_factory_));
-  pdf_to_emf_converter_factory_.set_connection_error_handler(base::BindOnce(
+      pdf_to_emf_converter_factory_.BindNewPipeAndPassReceiver());
+  pdf_to_emf_converter_factory_.set_disconnect_handler(base::BindOnce(
       &PdfConverterImpl::OnFailed, weak_ptr_factory_.GetWeakPtr(),
       std::string("Connection to PdfToEmfConverterFactory error.")));
 
-  mojom::PdfToEmfConverterClientPtr pdf_to_emf_converter_client_ptr;
+  mojo::PendingRemote<mojom::PdfToEmfConverterClient>
+      pdf_to_emf_converter_client_remote;
   pdf_to_emf_converter_client_impl_ =
       std::make_unique<PdfToEmfConverterClientImpl>(
-          mojo::MakeRequest(&pdf_to_emf_converter_client_ptr));
+          pdf_to_emf_converter_client_remote.InitWithNewPipeAndPassReceiver());
 
   pdf_to_emf_converter_factory_->CreateConverter(
       std::move(memory.region), settings_,
-      std::move(pdf_to_emf_converter_client_ptr),
+      std::move(pdf_to_emf_converter_client_remote),
       base::BindOnce(&PdfConverterImpl::OnPageCount,
                      weak_ptr_factory_.GetWeakPtr()));
 }
 
-void PdfConverterImpl::OnPageCount(mojom::PdfToEmfConverterPtr converter,
-                                   uint32_t page_count) {
+void PdfConverterImpl::OnPageCount(
+    mojo::PendingRemote<mojom::PdfToEmfConverter> converter,
+    uint32_t page_count) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!pdf_to_emf_converter_.is_bound());
-  pdf_to_emf_converter_ = std::move(converter);
-  pdf_to_emf_converter_.set_connection_error_handler(base::BindOnce(
+  pdf_to_emf_converter_.Bind(std::move(converter));
+  pdf_to_emf_converter_.set_disconnect_handler(base::BindOnce(
       &PdfConverterImpl::OnFailed, weak_ptr_factory_.GetWeakPtr(),
       std::string("Connection to PdfToEmfConverter error.")));
   std::move(start_callback_).Run(page_count);

chrome/service/service_utility_process_host.cc

@@ -41,7 +41,8 @@
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
 #include "content/public/common/service_manager_connection.h"
 #include "content/public/common/service_names.mojom.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/platform/named_platform_channel.h"
 #include "mojo/public/cpp/platform/platform_channel.h"
@@ -117,8 +118,8 @@ class ServicePdfToEmfConverterClientImpl
     : public printing::mojom::PdfToEmfConverterClient {
  public:
   explicit ServicePdfToEmfConverterClientImpl(
-      printing::mojom::PdfToEmfConverterClientRequest request)
-      : binding_(this, std::move(request)) {}
+      mojo::PendingReceiver<printing::mojom::PdfToEmfConverterClient> receiver)
+      : receiver_(this, std::move(receiver)) {}
 
  private:
   // mojom::PdfToEmfConverterClient:
@@ -129,7 +130,7 @@ class ServicePdfToEmfConverterClientImpl
     std::move(callback).Run();
   }
 
-  mojo::Binding<printing::mojom::PdfToEmfConverterClient> binding_;
+  mojo::Receiver<printing::mojom::PdfToEmfConverterClient> receiver_;
 };
 
 }  // namespace
@@ -145,31 +146,34 @@ class ServiceUtilityProcessHost::PdfToEmfState {
              const printing::PdfRenderSettings& conversion_settings) {
     weak_host_->BindInterface(
         printing::mojom::PdfToEmfConverterFactory::Name_,
-        mojo::MakeRequest(&pdf_to_emf_converter_factory_).PassMessagePipe());
+        pdf_to_emf_converter_factory_.BindNewPipeAndPassReceiver().PassPipe());
 
-    pdf_to_emf_converter_factory_.set_connection_error_handler(base::BindOnce(
+    pdf_to_emf_converter_factory_.set_disconnect_handler(base::BindOnce(
         &PdfToEmfState::OnFailed, weak_host_,
         std::string("Connection to PdfToEmfConverterFactory error.")));
 
-    printing::mojom::PdfToEmfConverterClientPtr pdf_to_emf_converter_client_ptr;
+    mojo::PendingRemote<printing::mojom::PdfToEmfConverterClient>
+        pdf_to_emf_converter_client_remote;
     pdf_to_emf_converter_client_impl_ =
         std::make_unique<ServicePdfToEmfConverterClientImpl>(
-            mojo::MakeRequest(&pdf_to_emf_converter_client_ptr));
+            pdf_to_emf_converter_client_remote
+                .InitWithNewPipeAndPassReceiver());
 
     pdf_to_emf_converter_factory_->CreateConverter(
         std::move(pdf_region), conversion_settings,
-        std::move(pdf_to_emf_converter_client_ptr),
+        std::move(pdf_to_emf_converter_client_remote),
         base::BindOnce(
             &ServiceUtilityProcessHost::OnRenderPDFPagesToMetafilesPageCount,
             weak_host_));
     return true;
   }
 
-  void GotPageCount(printing::mojom::PdfToEmfConverterPtr converter,
-                    uint32_t page_count) {
+  void GotPageCount(
+      mojo::PendingRemote<printing::mojom::PdfToEmfConverter> converter,
+      uint32_t page_count) {
     DCHECK(!pdf_to_emf_converter_.is_bound());
-    pdf_to_emf_converter_ = std::move(converter);
-    pdf_to_emf_converter_.set_connection_error_handler(
+    pdf_to_emf_converter_.Bind(std::move(converter));
+    pdf_to_emf_converter_.set_disconnect_handler(
         base::BindOnce(&PdfToEmfState::OnFailed, weak_host_,
                        std::string("Connection to PdfToEmfConverter error.")));
     page_count_ = page_count;
@@ -223,9 +227,10 @@ class ServiceUtilityProcessHost::PdfToEmfState {
   std::unique_ptr<ServicePdfToEmfConverterClientImpl>
       pdf_to_emf_converter_client_impl_;
 
-  printing::mojom::PdfToEmfConverterPtr pdf_to_emf_converter_;
+  mojo::Remote<printing::mojom::PdfToEmfConverter> pdf_to_emf_converter_;
 
-  printing::mojom::PdfToEmfConverterFactoryPtr pdf_to_emf_converter_factory_;
+  mojo::Remote<printing::mojom::PdfToEmfConverterFactory>
+      pdf_to_emf_converter_factory_;
 };
 
 ServiceUtilityProcessHost::ServiceUtilityProcessHost(
@@ -492,7 +497,7 @@ void ServiceUtilityProcessHost::OnMetafileSpooled(bool success) {
 }
 
 void ServiceUtilityProcessHost::OnRenderPDFPagesToMetafilesPageCount(
-    printing::mojom::PdfToEmfConverterPtr converter,
+    mojo::PendingRemote<printing::mojom::PdfToEmfConverter> converter,
     uint32_t page_count) {
   DCHECK(waiting_for_reply_);
   if (page_count == 0 || pdf_to_emf_state_->has_page_count())

chrome/service/service_utility_process_host.h

@@ -14,6 +14,7 @@
 #include "chrome/services/printing/public/mojom/pdf_to_emf_converter.mojom.h"
 #include "content/public/common/child_process_host_delegate.h"
 #include "ipc/ipc_platform_file.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/system/invitation.h"
 #include "services/service_manager/public/cpp/identity.h"
 
@@ -143,7 +144,7 @@ class ServiceUtilityProcessHost : public content::ChildProcessHostDelegate {
 
   // PdfToEmfState callbacks:
   void OnRenderPDFPagesToMetafilesPageCount(
-      printing::mojom::PdfToEmfConverterPtr converter,
+      mojo::PendingRemote<printing::mojom::PdfToEmfConverter> converter,
       uint32_t page_count);
   void OnRenderPDFPagesToMetafilesPageDone(
       base::ReadOnlySharedMemoryRegion emf_region,

chrome/services/printing/pdf_to_emf_converter.cc

@@ -13,6 +13,7 @@
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
 #include "mojo/public/cpp/base/shared_memory_utils.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "pdf/pdf.h"
 #include "printing/emf_win.h"
 #include "ui/gfx/gdi_util.h"
@@ -21,8 +22,8 @@ namespace printing {
 
 namespace {
 
-base::LazyInstance<std::vector<mojom::PdfToEmfConverterClientPtr>>::Leaky
-    g_converter_clients = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<std::vector<mojo::Remote<mojom::PdfToEmfConverterClient>>>::
+    Leaky g_converter_clients = LAZY_INSTANCE_INITIALIZER;
 
 void PreCacheFontCharacters(const LOGFONT* logfont,
                             const wchar_t* text,
@@ -43,23 +44,25 @@ void PreCacheFontCharacters(const LOGFONT* logfont,
 }
 
 void OnConvertedClientDisconnected() {
-  // We have no direct way of tracking which PdfToEmfConverterClientPtr got
-  // disconnected as it is a movable type, short of using a wrapper.
-  // Just traverse the list of clients and remove the ones that are not bound.
+  // We have no direct way of tracking which
+  // mojo::Remote<PdfToEmfConverterClient> got disconnected as it is a movable
+  // type, short of using a wrapper. Just traverse the list of clients and
+  // remove the ones that are not bound.
   base::EraseIf(g_converter_clients.Get(),
-                [](const mojom::PdfToEmfConverterClientPtr& client) {
+                [](const mojo::Remote<mojom::PdfToEmfConverterClient>& client) {
                   return !client.is_bound();
                 });
 }
 
-void RegisterConverterClient(mojom::PdfToEmfConverterClientPtr client) {
+void RegisterConverterClient(
+    mojo::PendingRemote<mojom::PdfToEmfConverterClient> client_remote) {
   if (!g_converter_clients.IsCreated()) {
     // First time this method is called.
     chrome_pdf::SetPDFEnsureTypefaceCharactersAccessible(
         PreCacheFontCharacters);
   }
-  client.set_connection_error_handler(
-      base::BindOnce(&OnConvertedClientDisconnected));
+  mojo::Remote<mojom::PdfToEmfConverterClient> client(std::move(client_remote));
+  client.set_disconnect_handler(base::BindOnce(&OnConvertedClientDisconnected));
   g_converter_clients.Get().push_back(std::move(client));
 }
 
@@ -68,7 +71,7 @@ void RegisterConverterClient(mojom::PdfToEmfConverterClientPtr client) {
 PdfToEmfConverter::PdfToEmfConverter(
     base::ReadOnlySharedMemoryRegion pdf_region,
     const PdfRenderSettings& pdf_render_settings,
-    mojom::PdfToEmfConverterClientPtr client)
+    mojo::PendingRemote<mojom::PdfToEmfConverterClient> client)
     : pdf_render_settings_(pdf_render_settings) {
   RegisterConverterClient(std::move(client));
   SetPrintMode();

chrome/services/printing/pdf_to_emf_converter.h

@@ -10,6 +10,7 @@
 #include "base/macros.h"
 #include "base/memory/read_only_shared_memory_region.h"
 #include "chrome/services/printing/public/mojom/pdf_to_emf_converter.mojom.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "printing/pdf_render_settings.h"
 
 namespace printing {
@@ -18,7 +19,7 @@ class PdfToEmfConverter : public mojom::PdfToEmfConverter {
  public:
   PdfToEmfConverter(base::ReadOnlySharedMemoryRegion pdf_region,
                     const PdfRenderSettings& render_settings,
-                    mojom::PdfToEmfConverterClientPtr client);
+                    mojo::PendingRemote<mojom::PdfToEmfConverterClient> client);
   ~PdfToEmfConverter() override;
 
   int total_page_count() const { return total_page_count_; }

chrome/services/printing/pdf_to_emf_converter_factory.cc

@@ -7,7 +7,7 @@
 #include <utility>
 
 #include "chrome/services/printing/pdf_to_emf_converter.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 
 namespace printing {
@@ -19,22 +19,22 @@ PdfToEmfConverterFactory::~PdfToEmfConverterFactory() = default;
 void PdfToEmfConverterFactory::CreateConverter(
     base::ReadOnlySharedMemoryRegion pdf_region,
     const PdfRenderSettings& render_settings,
-    mojom::PdfToEmfConverterClientPtr client,
+    mojo::PendingRemote<mojom::PdfToEmfConverterClient> client,
     CreateConverterCallback callback) {
   auto converter = std::make_unique<PdfToEmfConverter>(
       std::move(pdf_region), render_settings, std::move(client));
   uint32_t page_count = converter->total_page_count();
-  mojom::PdfToEmfConverterPtr converter_ptr;
-  mojo::MakeStrongBinding(std::move(converter),
-                          mojo::MakeRequest(&converter_ptr));
+  mojo::PendingRemote<mojom::PdfToEmfConverter> converter_remote;
+  mojo::MakeSelfOwnedReceiver(
+      std::move(converter), converter_remote.InitWithNewPipeAndPassReceiver());
 
-  std::move(callback).Run(std::move(converter_ptr), page_count);
+  std::move(callback).Run(std::move(converter_remote), page_count);
 }
 
 // static
 void PdfToEmfConverterFactory::Create(
-    mojom::PdfToEmfConverterFactoryRequest request) {
-  mojo::MakeStrongBinding(std::make_unique<PdfToEmfConverterFactory>(),
-                          std::move(request));
+    mojo::PendingReceiver<mojom::PdfToEmfConverterFactory> receiver) {
+  mojo::MakeSelfOwnedReceiver(std::make_unique<PdfToEmfConverterFactory>(),
+                              std::move(receiver));
 }
 }  // namespace printing

chrome/services/printing/pdf_to_emf_converter_factory.h

@@ -9,6 +9,8 @@
 
 #include "base/macros.h"
 #include "chrome/services/printing/public/mojom/pdf_to_emf_converter.mojom.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 
 namespace printing {
 
@@ -17,14 +19,16 @@ class PdfToEmfConverterFactory : public mojom::PdfToEmfConverterFactory {
   PdfToEmfConverterFactory();
   ~PdfToEmfConverterFactory() override;
 
-  static void Create(mojom::PdfToEmfConverterFactoryRequest request);
+  static void Create(
+      mojo::PendingReceiver<mojom::PdfToEmfConverterFactory> receiver);
 
  private:
   // mojom::PdfToEmfConverterFactory implementation.
-  void CreateConverter(base::ReadOnlySharedMemoryRegion pdf_region,
-                       const PdfRenderSettings& render_settings,
-                       mojom::PdfToEmfConverterClientPtr client,
-                       CreateConverterCallback callback) override;
+  void CreateConverter(
+      base::ReadOnlySharedMemoryRegion pdf_region,
+      const PdfRenderSettings& render_settings,
+      mojo::PendingRemote<mojom::PdfToEmfConverterClient> client,
+      CreateConverterCallback callback) override;
 
   DISALLOW_COPY_AND_ASSIGN(PdfToEmfConverterFactory);
 };

chrome/services/printing/public/mojom/pdf_to_emf_converter.mojom

@@ -31,6 +31,6 @@ interface PdfToEmfConverter {
 interface PdfToEmfConverterFactory {
   CreateConverter(mojo_base.mojom.ReadOnlySharedMemoryRegion pdf_region,
                   PdfRenderSettings render_settings,
-                  PdfToEmfConverterClient client) =>
-      (PdfToEmfConverter converter, uint32 page_count);
+                  pending_remote<PdfToEmfConverterClient> client)
+      => (pending_remote<PdfToEmfConverter> converter, uint32 page_count);
 };