Convert ProxyConfigPollerClient and ProxyErrorClient to new Mojo types

This CL converts ProxyConfigPollerClient and ProxyErrorClient
from proxy_config_with_annotation.mojom to new Mojo types
using PendingRemote, PendingReceiver, and Receiver.

Bug: 955171
Change-Id: I3a877c85a6b0f7ec64beee91d56062e6de42bad8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1851985
Commit-Queue: Julie Kim <jkim@igalia.com>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Reviewed-by: Oksana Zhuravlova <oksamyt@chromium.org>
Reviewed-by: Maksim Orlovich <morlovich@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Luke Halliwell <halliwell@chromium.org>
Cr-Commit-Position: refs/heads/master@{#706327}

chrome/browser/net/proxy_config_monitor.cc

@@ -85,13 +85,13 @@ void ProxyConfigMonitor::AddToNetworkContextParams(
       proxy_config_client.InitWithNewPipeAndPassReceiver();
   proxy_config_client_set_.Add(std::move(proxy_config_client));
 
-  poller_binding_set_.AddBinding(
-      this,
-      mojo::MakeRequest(&network_context_params->proxy_config_poller_client));
+  poller_receiver_set_.Add(this,
+                           network_context_params->proxy_config_poller_client
+                               .InitWithNewPipeAndPassReceiver());
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
-  error_binding_set_.AddBinding(
-      this, mojo::MakeRequest(&network_context_params->proxy_error_client));
+  error_receiver_set_.Add(this, network_context_params->proxy_error_client
+                                    .InitWithNewPipeAndPassReceiver());
 #endif
 
   net::ProxyConfigWithAnnotation proxy_config;

chrome/browser/net/proxy_config_monitor.h

@@ -11,7 +11,7 @@
 #include "base/macros.h"
 #include "build/buildflag.h"
 #include "extensions/buildflags/buildflags.h"
-#include "mojo/public/cpp/bindings/binding_set.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
 #include "mojo/public/cpp/bindings/remote_set.h"
 #include "net/proxy_resolution/proxy_config_service.h"
 #include "services/network/public/mojom/network_context.mojom-forward.h"
@@ -84,12 +84,13 @@ class ProxyConfigMonitor : public net::ProxyConfigService::Observer,
   // Monitors global and Profile prefs related to proxy configuration.
   std::unique_ptr<PrefProxyConfigTracker> pref_proxy_config_tracker_;
 
-  mojo::BindingSet<network::mojom::ProxyConfigPollerClient> poller_binding_set_;
+  mojo::ReceiverSet<network::mojom::ProxyConfigPollerClient>
+      poller_receiver_set_;
 
   mojo::RemoteSet<network::mojom::ProxyConfigClient> proxy_config_client_set_;
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
-  mojo::BindingSet<network::mojom::ProxyErrorClient> error_binding_set_;
+  mojo::ReceiverSet<network::mojom::ProxyErrorClient> error_receiver_set_;
   Profile* profile_ = nullptr;
 #endif
 

chromecast/browser/cast_network_contexts.cc

@@ -250,9 +250,9 @@ void CastNetworkContexts::AddProxyToNetworkContextParams(
       proxy_config_client.InitWithNewPipeAndPassReceiver();
   proxy_config_client_set_.Add(std::move(proxy_config_client));
 
-  poller_binding_set_.AddBinding(
-      this,
-      mojo::MakeRequest(&network_context_params->proxy_config_poller_client));
+  poller_receiver_set_.Add(this,
+                           network_context_params->proxy_config_poller_client
+                               .InitWithNewPipeAndPassReceiver());
 
   net::ProxyConfigWithAnnotation proxy_config;
   net::ProxyConfigService::ConfigAvailability availability =

chromecast/browser/cast_network_contexts.h

@@ -11,7 +11,7 @@
 
 #include "base/memory/scoped_refptr.h"
 #include "content/public/browser/browser_thread.h"
-#include "mojo/public/cpp/bindings/binding_set.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/bindings/remote_set.h"
 #include "net/proxy_resolution/proxy_config_service.h"
@@ -122,7 +122,8 @@ class CastNetworkContexts : public net::ProxyConfigService::Observer,
   // Monitors prefs related to proxy configuration.
   std::unique_ptr<PrefProxyConfigTracker> pref_proxy_config_tracker_impl_;
 
-  mojo::BindingSet<network::mojom::ProxyConfigPollerClient> poller_binding_set_;
+  mojo::ReceiverSet<network::mojom::ProxyConfigPollerClient>
+      poller_receiver_set_;
   mojo::RemoteSet<network::mojom::ProxyConfigClient> proxy_config_client_set_;
 
   DISALLOW_COPY_AND_ASSIGN(CastNetworkContexts);

headless/lib/browser/headless_request_context_manager.cc

@@ -15,6 +15,7 @@
 #include "content/public/browser/resource_context.h"
 #include "headless/app/headless_shell_switches.h"
 #include "headless/lib/browser/headless_browser_context_options.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "net/http/http_auth_preferences.h"
 #include "services/network/network_service.h"
 #include "services/network/public/cpp/features.h"
@@ -87,7 +88,7 @@ class HeadlessProxyConfigMonitor
 
   explicit HeadlessProxyConfigMonitor(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-      : task_runner_(task_runner), poller_binding_(this) {
+      : task_runner_(task_runner) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     // We must create the proxy config service on the UI loop on Linux because
     // it must synchronously run on the glib message loop.
@@ -115,8 +116,8 @@ class HeadlessProxyConfigMonitor
     DCHECK(!proxy_config_client_);
     network_context_params->proxy_config_client_receiver =
         proxy_config_client_.BindNewPipeAndPassReceiver();
-    poller_binding_.Bind(
-        mojo::MakeRequest(&network_context_params->proxy_config_poller_client));
+    poller_receiver_.Bind(network_context_params->proxy_config_poller_client
+                              .InitWithNewPipeAndPassReceiver());
     net::ProxyConfigWithAnnotation proxy_config;
     net::ProxyConfigService::ConfigAvailability availability =
         proxy_config_service_->GetLatestProxyConfig(&proxy_config);
@@ -150,7 +151,8 @@ class HeadlessProxyConfigMonitor
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   std::unique_ptr<net::ProxyConfigService> proxy_config_service_;
-  mojo::Binding<::network::mojom::ProxyConfigPollerClient> poller_binding_;
+  mojo::Receiver<::network::mojom::ProxyConfigPollerClient> poller_receiver_{
+      this};
   mojo::Remote<::network::mojom::ProxyConfigClient> proxy_config_client_;
 
   DISALLOW_COPY_AND_ASSIGN(HeadlessProxyConfigMonitor);

services/network/network_context_unittest.cc

@@ -47,9 +47,6 @@
 #include "components/network_session_configurator/common/network_switches.h"
 #include "components/prefs/testing_pref_service.h"
 #include "crypto/sha2.h"
-#include "mojo/public/cpp/bindings/pending_remote.h"
-#include "mojo/public/cpp/bindings/receiver.h"
-#include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "mojo/public/cpp/system/data_pipe_utils.h"
 #include "net/base/cache_type.h"
@@ -4104,7 +4101,7 @@ class TestProxyErrorClient final : public mojom::ProxyErrorClient {
     std::string details;
   };
 
-  TestProxyErrorClient() : binding_(this) {}
+  TestProxyErrorClient() = default;
 
   ~TestProxyErrorClient() override {}
 
@@ -4125,14 +4122,13 @@ class TestProxyErrorClient final : public mojom::ProxyErrorClient {
     return on_pac_script_error_calls_;
   }
 
-  // Creates an InterfacePtrInfo, binds it to |*this| and returns it.
-  mojom::ProxyErrorClientPtrInfo CreateInterfacePtrInfo() {
-    mojom::ProxyErrorClientPtrInfo client_ptr_info;
-
-    binding_.Bind(mojo::MakeRequest(&client_ptr_info));
-    binding_.set_connection_error_handler(base::BindOnce(
+  // Creates an mojo::PendingRemote, binds it to |*this| and returns it.
+  mojo::PendingRemote<mojom::ProxyErrorClient> CreateRemote() {
+    mojo::PendingRemote<mojom::ProxyErrorClient> client_remote =
+        receiver_.BindNewPipeAndPassRemote();
+    receiver_.set_disconnect_handler(base::BindOnce(
         &TestProxyErrorClient::OnMojoPipeError, base::Unretained(this)));
-    return client_ptr_info;
+    return client_remote;
   }
 
   // Runs until the message pipe is closed due to an error.
@@ -4153,7 +4149,7 @@ class TestProxyErrorClient final : public mojom::ProxyErrorClient {
       std::move(quit_closure_for_on_mojo_pipe_error_).Run();
   }
 
-  mojo::Binding<mojom::ProxyErrorClient> binding_;
+  mojo::Receiver<mojom::ProxyErrorClient> receiver_{this};
 
   base::OnceClosure quit_closure_for_on_mojo_pipe_error_;
   bool has_received_mojo_pipe_error_ = false;
@@ -4191,8 +4187,7 @@ TEST_F(NetworkContextTest, ProxyErrorClientNotifiedOfProxyConnection) {
   TestProxyErrorClient proxy_error_client;
   mojom::NetworkContextParamsPtr context_params =
       mojom::NetworkContextParams::New();
-  context_params->proxy_error_client =
-      proxy_error_client.CreateInterfacePtrInfo();
+  context_params->proxy_error_client = proxy_error_client.CreateRemote();
   net::ProxyConfig proxy_config;
   // Set the proxy to an unreachable address (host resolution fails).
   proxy_config.proxy_rules().ParseFromString("proxy.bad.dns");
@@ -4253,8 +4248,7 @@ TEST_F(NetworkContextTest, ProxyErrorClientNotNotifiedOfUnreachableError) {
   // configuration.
   TestProxyErrorClient proxy_error_client;
   mojom::NetworkContextParamsPtr context_params = CreateContextParams();
-  context_params->proxy_error_client =
-      proxy_error_client.CreateInterfacePtrInfo();
+  context_params->proxy_error_client = proxy_error_client.CreateRemote();
   std::unique_ptr<NetworkContext> network_context =
       CreateContextWithParams(std::move(context_params));
 
@@ -4373,8 +4367,7 @@ TEST_F(NetworkContextTest, ProxyErrorClientNotifiedOfPacError) {
   TestProxyErrorClient proxy_error_client;
   mojom::NetworkContextParamsPtr context_params =
       mojom::NetworkContextParams::New();
-  context_params->proxy_error_client =
-      proxy_error_client.CreateInterfacePtrInfo();
+  context_params->proxy_error_client = proxy_error_client.CreateRemote();
 
 #if defined(OS_CHROMEOS)
   context_params->dhcp_wpad_url_client =

services/network/network_service_network_delegate.cc

@@ -38,14 +38,14 @@ const char kClearSiteDataHeader[] = "Clear-Site-Data";
 NetworkServiceNetworkDelegate::NetworkServiceNetworkDelegate(
     bool enable_referrers,
     bool validate_referrer_policy_on_initial_request,
-    mojom::ProxyErrorClientPtrInfo proxy_error_client_info,
+    mojo::PendingRemote<mojom::ProxyErrorClient> proxy_error_client_remote,
     NetworkContext* network_context)
     : enable_referrers_(enable_referrers),
       validate_referrer_policy_on_initial_request_(
           validate_referrer_policy_on_initial_request),
       network_context_(network_context) {
-  if (proxy_error_client_info)
-    proxy_error_client_.Bind(std::move(proxy_error_client_info));
+  if (proxy_error_client_remote)
+    proxy_error_client_.Bind(std::move(proxy_error_client_remote));
 }
 
 NetworkServiceNetworkDelegate::~NetworkServiceNetworkDelegate() = default;

services/network/network_service_network_delegate.h

@@ -7,6 +7,8 @@
 
 #include "base/component_export.h"
 #include "base/macros.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "net/base/completion_once_callback.h"
 #include "net/base/network_delegate_impl.h"
 #include "services/network/network_context.h"
@@ -22,7 +24,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) NetworkServiceNetworkDelegate
   NetworkServiceNetworkDelegate(
       bool enable_referrers,
       bool validate_referrer_policy_on_initial_request,
-      mojom::ProxyErrorClientPtrInfo proxy_error_client_info,
+      mojo::PendingRemote<mojom::ProxyErrorClient> proxy_error_client_remote,
       NetworkContext* network_context);
   ~NetworkServiceNetworkDelegate() override;
 
@@ -100,7 +102,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) NetworkServiceNetworkDelegate
 
   bool enable_referrers_;
   bool validate_referrer_policy_on_initial_request_;
-  mojom::ProxyErrorClientPtr proxy_error_client_;
+  mojo::Remote<mojom::ProxyErrorClient> proxy_error_client_;
   NetworkContext* network_context_;
 
   mutable base::WeakPtrFactory<NetworkServiceNetworkDelegate> weak_ptr_factory_{

services/network/proxy_config_service_mojo.cc

@@ -12,7 +12,7 @@ ProxyConfigServiceMojo::ProxyConfigServiceMojo(
     mojo::PendingReceiver<mojom::ProxyConfigClient>
         proxy_config_client_receiver,
     base::Optional<net::ProxyConfigWithAnnotation> initial_proxy_config,
-    mojom::ProxyConfigPollerClientPtrInfo proxy_poller_client) {
+    mojo::PendingRemote<mojom::ProxyConfigPollerClient> proxy_poller_client) {
   DCHECK(initial_proxy_config || proxy_config_client_receiver.is_valid());
 
   if (initial_proxy_config)
@@ -22,6 +22,11 @@ ProxyConfigServiceMojo::ProxyConfigServiceMojo(
     receiver_.Bind(std::move(proxy_config_client_receiver));
     // Only use the |proxy_poller_client| if there's a
     // |proxy_config_client_receiver|.
+    if (!proxy_poller_client) {
+      // NullRemote() could be passed in unit tests. In that case, it can't be
+      // bound.
+      return;
+    }
     proxy_poller_client_.Bind(std::move(proxy_poller_client));
   }
 }

services/network/proxy_config_service_mojo.h

@@ -10,7 +10,9 @@
 #include "base/observer_list.h"
 #include "base/optional.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 "net/proxy_resolution/proxy_config.h"
 #include "net/proxy_resolution/proxy_config_service.h"
 #include "net/proxy_resolution/proxy_config_with_annotation.h"
@@ -39,7 +41,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) ProxyConfigServiceMojo
       mojo::PendingReceiver<mojom::ProxyConfigClient>
           proxy_config_client_receiver,
       base::Optional<net::ProxyConfigWithAnnotation> initial_proxy_config,
-      mojom::ProxyConfigPollerClientPtrInfo proxy_poller_client);
+      mojo::PendingRemote<mojom::ProxyConfigPollerClient> proxy_poller_client);
   ~ProxyConfigServiceMojo() override;
 
   // net::ProxyConfigService implementation:
@@ -55,7 +57,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) ProxyConfigServiceMojo
       const net::ProxyConfigWithAnnotation& proxy_config) override;
   void FlushProxyConfig(FlushProxyConfigCallback callback) override;
 
-  mojom::ProxyConfigPollerClientPtr proxy_poller_client_;
+  mojo::Remote<mojom::ProxyConfigPollerClient> proxy_poller_client_;
 
   net::ProxyConfigWithAnnotation config_;
   bool config_pending_ = true;

services/network/proxy_config_service_mojo_unittest.cc

@@ -6,7 +6,6 @@
 
 #include "base/macros.h"
 #include "base/test/task_environment.h"
-#include "mojo/public/cpp/bindings/remote.h"
 #include "net/proxy_resolution/proxy_config.h"
 #include "net/proxy_resolution/proxy_config_service.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
@@ -72,7 +71,7 @@ class ProxyConfigServiceMojoTest : public testing::Test {
       : task_environment_(base::test::TaskEnvironment::MainThreadType::IO),
         proxy_config_service_(config_client_.BindNewPipeAndPassReceiver(),
                               base::Optional<net::ProxyConfigWithAnnotation>(),
-                              nullptr),
+                              mojo::NullRemote()),
         observer_(&proxy_config_service_) {
     proxy_config_service_.AddObserver(&observer_);
   }

services/network/public/mojom/network_context.mojom

@@ -291,11 +291,11 @@ struct NetworkContextParams {
   // TODO(mmenke): Can the consumer piggy back on other network events through
   // other channels (navigation, issuing requests, etc)? Or can
   // ProxyConfigServices be modified not to need this notification?
-  ProxyConfigPollerClient? proxy_config_poller_client;
+  pending_remote<ProxyConfigPollerClient>? proxy_config_poller_client;
 
   // Optional client that will be notified of errors related to the proxy
   // settings.
-  ProxyErrorClient? proxy_error_client;
+  pending_remote<ProxyErrorClient>? proxy_error_client;
 
   // When PAC quick checking is enabled, DNS lookups for PAC script's host are
   // timed out aggressively. This prevents hanging all network request on DNS