Mojo C++ bindings: remove some usage of AssociatedGroup from user code.

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 <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
-#include "mojo/public/cpp/bindings/associated_group.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
 #include "mojo/public/cpp/bindings/associated_interface_request.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/lib/multiplex_router.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h"
 #include "mojo/public/interfaces/bindings/tests/ping_service.mojom.h"
 #include "mojo/public/interfaces/bindings/tests/test_associated_interfaces.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 40 matching lines @@
 
   ~IntegerSenderConnectionImpl() override {}
 
   void GetSender(AssociatedInterfaceRequest<IntegerSender> sender) override {
     IntegerSenderImpl* sender_impl = new IntegerSenderImpl(std::move(sender));
     sender_impl->set_connection_error_handler(
         base::Bind(&DeleteSender, sender_impl));
   }
 
   void AsyncGetSender(const AsyncGetSenderCallback& callback) override {
-    AssociatedInterfaceRequest<IntegerSender> request;
     IntegerSenderAssociatedPtrInfo ptr_info;
-    binding_.associated_group()->CreateAssociatedInterface(
-        AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
+    auto request = MakeRequest(&ptr_info);
     GetSender(std::move(request));
     callback.Run(std::move(ptr_info));
   }
 
   Binding<IntegerSenderConnection>* binding() { return &binding_; }
 
  private:
   static void DeleteSender(IntegerSenderImpl* sender) { delete sender; }
 
   Binding<IntegerSenderConnection> binding_;
@@ skipping 27 matching lines @@
     *router1 = new MultiplexRouter(std::move(pipe.handle1),
                                    MultiplexRouter::MULTI_INTERFACE, false,
                                    base::ThreadTaskRunnerHandle::Get());
   }
 
   void CreateIntegerSenderWithExistingRouters(
       scoped_refptr<MultiplexRouter> router0,
       IntegerSenderAssociatedPtrInfo* ptr_info0,
       scoped_refptr<MultiplexRouter> router1,
       IntegerSenderAssociatedRequest* request1) {
-    AssociatedGroup dummy_group;
-    dummy_group.CreateAssociatedInterface(AssociatedGroup::WILL_PASS_PTR,
-                                          ptr_info0, request1);
+    *request1 = MakeRequest(ptr_info0);
     *ptr_info0 = EmulatePassingAssociatedPtrInfo(std::move(*ptr_info0), router1,
                                                  router0);
   }
 
   void CreateIntegerSender(IntegerSenderAssociatedPtrInfo* ptr_info,
                            IntegerSenderAssociatedRequest* request) {
     scoped_refptr<MultiplexRouter> router0;
     scoped_refptr<MultiplexRouter> router1;
     CreateRouterPair(&router0, &router1);
     CreateIntegerSenderWithExistingRouters(router1, ptr_info, router0, request);
@@ skipping 405 matching lines @@
                           IntegerSenderAssociatedPtrInfo info) {
   storage->Bind(std::move(info));
   closure.Run();
 }
 
 TEST_F(AssociatedInterfaceTest, PassAssociatedInterfaces) {
   IntegerSenderConnectionPtr connection_ptr;
   IntegerSenderConnectionImpl connection(MakeRequest(&connection_ptr));
 
   IntegerSenderAssociatedPtr sender0;
-  connection_ptr->GetSender(
-      MakeRequest(&sender0, connection_ptr.associated_group()));
+  connection_ptr->GetSender(MakeRequest(&sender0));
 
   int32_t echoed_value = 0;
   base::RunLoop run_loop;
   sender0->Echo(123, base::Bind(&CaptureInt32, &echoed_value,
                                 run_loop.QuitClosure()));
   run_loop.Run();
   EXPECT_EQ(123, echoed_value);
 
   IntegerSenderAssociatedPtr sender1;
   base::RunLoop run_loop2;
   connection_ptr->AsyncGetSender(
       base::Bind(&CaptureSenderPtrInfo, &sender1, run_loop2.QuitClosure()));
   run_loop2.Run();
   EXPECT_TRUE(sender1);
 
   base::RunLoop run_loop3;
   sender1->Echo(456, base::Bind(&CaptureInt32, &echoed_value,
                                 run_loop3.QuitClosure()));
   run_loop3.Run();
   EXPECT_EQ(456, echoed_value);
 }
 
 TEST_F(AssociatedInterfaceTest, BindingWaitAndPauseWhenNoAssociatedInterfaces) {
   IntegerSenderConnectionPtr connection_ptr;
   IntegerSenderConnectionImpl connection(MakeRequest(&connection_ptr));
 
   IntegerSenderAssociatedPtr sender0;
-  connection_ptr->GetSender(
-      MakeRequest(&sender0, connection_ptr.associated_group()));
+  connection_ptr->GetSender(MakeRequest(&sender0));
 
   EXPECT_FALSE(connection.binding()->HasAssociatedInterfaces());
   // There are no associated interfaces running on the pipe yet. It is okay to
   // pause.
   connection.binding()->PauseIncomingMethodCallProcessing();
   connection.binding()->ResumeIncomingMethodCallProcessing();
 
   // There are no associated interfaces running on the pipe yet. It is okay to
   // wait.
   EXPECT_TRUE(connection.binding()->WaitForIncomingMethodCall());
@@ skipping 87 matching lines @@
 };
 
 // Verifies that filters work as expected on associated bindings, i.e. that
 // they're notified in order, before dispatch; and that each associated
 // binding in a group operates with its own set of filters.
 TEST_F(AssociatedInterfaceTest, BindingWithFilters) {
   AssociatedPingProviderPtr provider;
   PingProviderImpl provider_impl(MakeRequest(&provider));
 
   PingServiceAssociatedPtr ping_a, ping_b;
-  provider->GetPing(MakeRequest(&ping_a, provider.associated_group()));
-  provider->GetPing(MakeRequest(&ping_b, provider.associated_group()));
+  provider->GetPing(MakeRequest(&ping_a));
+  provider->GetPing(MakeRequest(&ping_b));
   provider_impl.WaitForBindings(2);
 
   ASSERT_EQ(2u, provider_impl.ping_services().size());
   PingServiceImpl& ping_a_impl = *provider_impl.ping_services()[0];
   PingServiceImpl& ping_b_impl = *provider_impl.ping_services()[1];
 
   int a_status, b_status;
   auto handler_helper = [] (int* a_status, int* b_status, int expected_a_status,
                             int new_a_status, int expected_b_status,
                             int new_b_status) {
@@ skipping 157 matching lines @@
 }
 
 TEST_F(AssociatedInterfaceTest, StrongBindingFlushForTesting) {
   IntegerSenderConnectionPtr ptr;
   auto binding =
       MakeStrongBinding(base::MakeUnique<IntegerSenderConnectionImpl>(
                             IntegerSenderConnectionRequest{}),
                         MakeRequest(&ptr));
   bool called = false;
   IntegerSenderAssociatedPtr sender_ptr;
-  ptr->GetSender(MakeRequest(&sender_ptr, ptr.associated_group()));
+  ptr->GetSender(MakeRequest(&sender_ptr));
   sender_ptr->Echo(1, base::Bind(&SetBoolWithUnusedParameter<int>, &called));
   EXPECT_FALSE(called);
   // Because the flush is sent from the binding, it only guarantees that the
   // request has been received, not the response. The second flush waits for the
   // response to be received.
   ASSERT_TRUE(binding);
   binding->FlushForTesting();
   ASSERT_TRUE(binding);
   binding->FlushForTesting();
   EXPECT_TRUE(called);
@@ skipping 60 matching lines @@
   ptr.ResetWithReason(123u, "farewell");
 
   run_loop.Run();
 }
 
 TEST_F(AssociatedInterfaceTest,
        PendingAssociatedBindingConnectionErrorWithReason) {
   // Test that AssociatedBinding is notified with connection error when the
   // interface hasn't associated with a message pipe and the peer is closed.
 
-  AssociatedGroup dummy_group;
   IntegerSenderAssociatedPtr ptr;
-  IntegerSenderImpl impl(MakeRequest(&ptr, &dummy_group));
+  IntegerSenderImpl impl(MakeRequest(&ptr));
 
   base::RunLoop run_loop;
   impl.binding()->set_connection_error_with_reason_handler(base::Bind(
       [](const base::Closure& quit_closure, uint32_t custom_reason,
          const std::string& description) {
         EXPECT_EQ(123u, custom_reason);
         EXPECT_EQ("farewell", description);
         quit_closure.Run();
       },
       run_loop.QuitClosure()));
@@ skipping 24 matching lines @@
 
   impl.binding()->CloseWithReason(456u, "farewell");
 
   run_loop.Run();
 }
 
 TEST_F(AssociatedInterfaceTest, PendingAssociatedPtrConnectionErrorWithReason) {
   // Test that AssociatedInterfacePtr is notified with connection error when the
   // interface hasn't associated with a message pipe and the peer is closed.
 
-  AssociatedGroup dummy_group;
   IntegerSenderAssociatedPtr ptr;
-  auto request = MakeRequest(&ptr, &dummy_group);
+  auto request = MakeRequest(&ptr);
 
   base::RunLoop run_loop;
   ptr.set_connection_error_with_reason_handler(base::Bind(
       [](const base::Closure& quit_closure, uint32_t custom_reason,
          const std::string& description) {
         EXPECT_EQ(456u, custom_reason);
         EXPECT_EQ("farewell", description);
         quit_closure.Run();
       },
       run_loop.QuitClosure()));
@@ skipping 24 matching lines @@
   request.ResetWithReason(789u, "long time no see");
 
   run_loop.Run();
 }
 
 TEST_F(AssociatedInterfaceTest, ThreadSafeAssociatedInterfacePtr) {
   IntegerSenderConnectionPtr connection_ptr;
   IntegerSenderConnectionImpl connection(MakeRequest(&connection_ptr));
 
   IntegerSenderAssociatedPtr sender;
-  connection_ptr->GetSender(
-      MakeRequest(&sender, connection_ptr.associated_group()));
+  connection_ptr->GetSender(MakeRequest(&sender));
 
   scoped_refptr<ThreadSafeIntegerSenderAssociatedPtr> thread_safe_sender =
       ThreadSafeIntegerSenderAssociatedPtr::Create(std::move(sender));
 
   {
     // Test the thread safe pointer can be used from the interface ptr thread.
     int32_t echoed_value = 0;
     base::RunLoop run_loop;
     (*thread_safe_sender)
         ->Echo(123, base::Bind(&CaptureInt32, &echoed_value,
@@ skipping 53 matching lines @@
   IntegerSenderAssociatedPtrInfo sender_info;
   base::WaitableEvent sender_info_bound_event(
       base::WaitableEvent::ResetPolicy::MANUAL,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   auto setup = [](base::WaitableEvent* sender_info_bound_event,
                   IntegerSenderAssociatedPtrInfo* sender_info,
                   ForwarderTestContext* context) {
     context->interface_impl = base::MakeUnique<IntegerSenderConnectionImpl>(
         MakeRequest(&context->connection_ptr));
 
-    IntegerSenderAssociatedPtr sender;
-    IntegerSenderAssociatedRequest sender_request =
-        MakeRequest(&sender, context->connection_ptr.associated_group());
-    *sender_info = sender.PassInterface();
-
+    auto sender_request = MakeRequest(sender_info);
     context->connection_ptr->GetSender(std::move(sender_request));
 
     // Unblock the main thread as soon as |sender_info| is set.
     sender_info_bound_event->Signal();
   };
   other_thread_task_runner->PostTask(
       FROM_HERE,
       base::Bind(setup, &sender_info_bound_event, &sender_info, context));
   sender_info_bound_event.Wait();
 
@@ skipping 33 matching lines @@
   void GetPingProvider(
       AssociatedPingProviderAssociatedRequest request) override {}
 };
 
 TEST_F(AssociatedInterfaceTest, CloseWithoutBindingAssociatedRequest) {
   DiscardingAssociatedPingProviderProvider ping_provider_provider;
   mojo::Binding<AssociatedPingProviderProvider> binding(
       &ping_provider_provider);
   auto provider_provider = binding.CreateInterfacePtrAndBind();
   AssociatedPingProviderAssociatedPtr provider;
-  provider_provider->GetPingProvider(
-      mojo::MakeRequest(&provider, provider_provider.associated_group()));
+  provider_provider->GetPingProvider(mojo::MakeRequest(&provider));
   PingServiceAssociatedPtr ping;
-  provider->GetPing(
-      mojo::MakeRequest(&ping, provider.associated_group()));
+  provider->GetPing(mojo::MakeRequest(&ping));
   base::RunLoop run_loop;
   ping.set_connection_error_handler(run_loop.QuitClosure());
   run_loop.Run();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo