Mojo C++ bindings: support passing associated interface pointers/requests in method parameter lists…

mojo/public/cpp/bindings/tests/associated_interface_unittest.cc

 // Copyright 2015 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.
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread.h"
@@ skipping 38 matching lines @@
 
   void set_connection_error_handler(const Closure& handler) {
     binding_.set_connection_error_handler(handler);
   }
 
  private:
   AssociatedBinding<IntegerSender> binding_;
   base::Callback<void(int32_t)> notify_send_method_called_;
 };
 
+class IntegerSenderConnectionImpl : public IntegerSenderConnection {
+ public:
+  explicit IntegerSenderConnectionImpl(
+      InterfaceRequest<IntegerSenderConnection> request)
+      : binding_(this, request.Pass()) {}
+
+  ~IntegerSenderConnectionImpl() override {}
+
+  void GetSender(AssociatedInterfaceRequest<IntegerSender> sender) override {
+    IntegerSenderImpl* sender_impl = new IntegerSenderImpl(sender.Pass());
+    sender_impl->set_connection_error_handler(
+        [sender_impl]() { delete sender_impl; });
+  }
+
+  void AsyncGetSender(const AsyncGetSenderCallback& callback) override {
+    AssociatedInterfaceRequest<IntegerSender> request;
+    AssociatedInterfacePtrInfo<IntegerSender> ptr_info;
+    binding_.associated_group()->CreateAssociatedInterface(
+        AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
+    GetSender(request.Pass());
+    callback.Run(ptr_info.Pass());
+  }
+
+ private:
+  Binding<IntegerSenderConnection> binding_;
+};
+
 class AssociatedInterfaceTest : public testing::Test {
  public:
   AssociatedInterfaceTest() : loop_(common::MessagePumpMojo::Create()) {}
   ~AssociatedInterfaceTest() override { loop_.RunUntilIdle(); }
 
   void PumpMessages() { loop_.RunUntilIdle(); }
 
   template <typename T>
   AssociatedInterfacePtrInfo<T> EmulatePassingAssociatedPtrInfo(
       AssociatedInterfacePtrInfo<T> ptr_info,
@@ skipping 370 matching lines @@
 
   EXPECT_EQ(static_cast<size_t>(kMaxValue / 2), receivers[0].values().size());
   EXPECT_EQ(static_cast<size_t>(kMaxValue / 2), receivers[1].values().size());
 
   for (size_t i = 0; i < 2; ++i) {
     for (size_t j = 1; j < receivers[i].values().size(); ++j)
       EXPECT_LT(receivers[i].values()[j - 1], receivers[i].values()[j]);
   }
 }
 
+TEST_F(AssociatedInterfaceTest, PassAssociatedInterfaces) {
+  IntegerSenderConnectionPtr connection_ptr;
+  IntegerSenderConnectionImpl connection(GetProxy(&connection_ptr));
+
+  AssociatedInterfacePtr<IntegerSender> sender0;
+  connection_ptr->GetSender(
+      GetProxy(&sender0, connection_ptr.associated_group()));
+
+  int32_t echoed_value = 0;
+  sender0->Echo(123, [&echoed_value](int32_t value) { echoed_value = value; });
+  PumpMessages();
+  EXPECT_EQ(123, echoed_value);
+
+  AssociatedInterfacePtr<IntegerSender> sender1;
+  connection_ptr->AsyncGetSender(
+      [&sender1](AssociatedInterfacePtrInfo<IntegerSender> ptr_info) {
+        sender1.Bind(ptr_info.Pass());
+      });
+  PumpMessages();
+  EXPECT_TRUE(sender1);
+
+  sender1->Echo(456, [&echoed_value](int32_t value) { echoed_value = value; });
+  PumpMessages();
+  EXPECT_EQ(456, echoed_value);
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace mojo