Add methods to blink::InterfaceRegistry for Pending{Associated}Receiver<T>

Similarly to what has been done already for blink::InterfaceProvider[1] and
service_manager::InterfaceProvider[2], in order to help with the transition
to the new Mojo types, let's add three more templated methods to the class
blink::InterfaceRegistry that enable calling the AddInterface() and the
AddAssociatedInterface methods passing a Pending{Associated}Receiver<T> as
parameter.

This will be useful in cases relying on the InterfaceRegistry's API to add
interface factories using the new Mojo types, as it's the case for instance
for the FindInPage class (see [3]).

[1]https://cs.chromium.org/chromium/src/third_party/blink/public/platform/interface_provider.h?l=28
[2]https://cs.chromium.org/chromium/src/services/service_manager/public/cpp/interface_provider.h?l=98
[3]https://cs.chromium.org/chromium/src/third_party/blink/renderer/core/frame/find_in_page.cc?l=55

Bug: 980151
Change-Id: I994d0d28c884f5500ac4f82a5592f16c824f8bff
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1697486
Commit-Queue: Mario Sanchez Prada <mario@igalia.com>
Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Ken Rockot <rockot@google.com>
Cr-Commit-Position: refs/heads/master@{#677118}

third_party/blink/public/platform/interface_registry.h

@@ -5,6 +5,8 @@
 #ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_INTERFACE_REGISTRY_H_
 #define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_INTERFACE_REGISTRY_H_
 
+#include <utility>
+
 #include "base/callback_forward.h"
 #include "base/memory/scoped_refptr.h"
 #include "mojo/public/cpp/bindings/scoped_interface_endpoint_handle.h"
@@ -14,6 +16,8 @@
 #if INSIDE_BLINK
 #include "mojo/public/cpp/bindings/associated_interface_request.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/pending_associated_receiver.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "third_party/blink/renderer/platform/wtf/cross_thread_functional.h"  // nogncheck
 #include "third_party/blink/renderer/platform/wtf/functional.h"  // nogncheck
 #endif
@@ -47,22 +51,45 @@ class BLINK_PLATFORM_EXPORT InterfaceRegistry {
   void AddInterface(
       base::RepeatingCallback<void(mojo::InterfaceRequest<Interface>)>
           factory) {
-    AddInterface(Interface::Name_,
-                 WTF::BindRepeating(
-                     &InterfaceRegistry::ForwardToInterfaceFactory<Interface>,
-                     std::move(factory)));
+    AddInterface(
+        Interface::Name_,
+        WTF::BindRepeating(&InterfaceRegistry::ForwardToInterfaceFactory<
+                               mojo::InterfaceRequest<Interface>>,
+                           std::move(factory)));
+  }
+
+  template <typename Interface>
+  void AddInterface(
+      base::RepeatingCallback<void(mojo::PendingReceiver<Interface>)> factory) {
+    AddInterface(
+        Interface::Name_,
+        WTF::BindRepeating(&InterfaceRegistry::ForwardToInterfaceFactory<
+                               mojo::PendingReceiver<Interface>>,
+                           std::move(factory)));
   }
 
   template <typename Interface>
   void AddInterface(WTF::CrossThreadRepeatingFunction<
                         void(mojo::InterfaceRequest<Interface>)> factory,
                     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-    AddInterface(
-        Interface::Name_,
-        ConvertToBaseCallback(CrossThreadBind(
-            &InterfaceRegistry::ForwardToCrossThreadInterfaceFactory<Interface>,
-            std::move(factory))),
-        std::move(task_runner));
+    AddInterface(Interface::Name_,
+                 ConvertToBaseCallback(CrossThreadBind(
+                     &InterfaceRegistry::ForwardToCrossThreadInterfaceFactory<
+                         mojo::InterfaceRequest<Interface>>,
+                     std::move(factory))),
+                 std::move(task_runner));
+  }
+
+  template <typename Interface>
+  void AddInterface(WTF::CrossThreadRepeatingFunction<
+                        void(mojo::PendingReceiver<Interface>)> factory,
+                    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+    AddInterface(Interface::Name_,
+                 ConvertToBaseCallback(CrossThreadBind(
+                     &InterfaceRegistry::ForwardToCrossThreadInterfaceFactory<
+                         mojo::PendingReceiver<Interface>>,
+                     std::move(factory))),
+                 std::move(task_runner));
   }
 
   template <typename Interface>
@@ -72,36 +99,48 @@ class BLINK_PLATFORM_EXPORT InterfaceRegistry {
     AddAssociatedInterface(
         Interface::Name_,
         WTF::BindRepeating(
-            &InterfaceRegistry::ForwardToAssociatedInterfaceFactory<Interface>,
+            &InterfaceRegistry::ForwardToAssociatedInterfaceFactory<
+                mojo::AssociatedInterfaceRequest<Interface>>,
             std::move(factory)));
   }
 
- private:
   template <typename Interface>
+  void AddAssociatedInterface(
+      base::RepeatingCallback<void(mojo::PendingAssociatedReceiver<Interface>)>
+          factory) {
+    AddAssociatedInterface(
+        Interface::Name_,
+        WTF::BindRepeating(
+            &InterfaceRegistry::ForwardToAssociatedInterfaceFactory<
+                mojo::PendingAssociatedReceiver<Interface>>,
+            std::move(factory)));
+  }
+
+ private:
+  template <typename MojoType>
   static void ForwardToInterfaceFactory(
-      base::RepeatingCallback<void(mojo::InterfaceRequest<Interface>)> factory,
+      base::RepeatingCallback<void(MojoType)> factory,
       mojo::ScopedMessagePipeHandle handle) {
-    factory.Run(mojo::InterfaceRequest<Interface>(std::move(handle)));
+    factory.Run(MojoType(std::move(handle)));
   }
 
-  template <typename Interface>
+  template <typename MojoType>
   static void ForwardToCrossThreadInterfaceFactory(
-      const WTF::CrossThreadRepeatingFunction<
-          void(mojo::InterfaceRequest<Interface>)>& factory,
+      const WTF::CrossThreadRepeatingFunction<void(MojoType)>& factory,
       mojo::ScopedMessagePipeHandle handle) {
-    factory.Run(mojo::InterfaceRequest<Interface>(std::move(handle)));
+    factory.Run(MojoType(std::move(handle)));
   }
 
-  template <typename Interface>
+  template <typename MojoType>
   static void ForwardToAssociatedInterfaceFactory(
-      base::RepeatingCallback<void(mojo::AssociatedInterfaceRequest<Interface>)>
-          factory,
+      base::RepeatingCallback<void(MojoType)> factory,
       mojo::ScopedInterfaceEndpointHandle handle) {
-    factory.Run(mojo::AssociatedInterfaceRequest<Interface>(std::move(handle)));
+    factory.Run(MojoType(std::move(handle)));
   }
+
 #endif  // INSIDE_BLINK
 };
 
 }  // namespace blink
 
-#endif
+#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_INTERFACE_REGISTRY_H_