mojo:: Rename mojo::GetProxy() to mojo::MakeRequest()

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"
@@ skipping 534 matching lines @@
 
 void CaptureSenderPtrInfo(IntegerSenderAssociatedPtr* storage,
                           const base::Closure& closure,
                           IntegerSenderAssociatedPtrInfo info) {
   storage->Bind(std::move(info));
   closure.Run();
 }
 
 TEST_F(AssociatedInterfaceTest, PassAssociatedInterfaces) {
   IntegerSenderConnectionPtr connection_ptr;
-  IntegerSenderConnectionImpl connection(GetProxy(&connection_ptr));
+  IntegerSenderConnectionImpl connection(MakeRequest(&connection_ptr));
 
   IntegerSenderAssociatedPtr sender0;
   connection_ptr->GetSender(
-      GetProxy(&sender0, connection_ptr.associated_group()));
+      MakeRequest(&sender0, connection_ptr.associated_group()));
 
   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(GetProxy(&connection_ptr));
+  IntegerSenderConnectionImpl connection(MakeRequest(&connection_ptr));
 
   IntegerSenderAssociatedPtr sender0;
   connection_ptr->GetSender(
-      GetProxy(&sender0, connection_ptr.associated_group()));
+      MakeRequest(&sender0, connection_ptr.associated_group()));
 
   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 84 matching lines @@
 
  private:
   const base::Closure callback_;
 };
 
 // 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(GetProxy(&provider));
+  PingProviderImpl provider_impl(MakeRequest(&provider));
 
   PingServiceAssociatedPtr ping_a, ping_b;
-  provider->GetPing(GetProxy(&ping_a, provider.associated_group()));
-  provider->GetPing(GetProxy(&ping_b, provider.associated_group()));
+  provider->GetPing(MakeRequest(&ping_a, provider.associated_group()));
+  provider->GetPing(MakeRequest(&ping_b, provider.associated_group()));
   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 123 matching lines @@
   IntegerSenderImpl impl(std::move(request));
   bool called = false;
   impl.set_connection_error_handler(base::Bind(&SetBool, &called));
   impl.binding()->FlushForTesting();
   EXPECT_TRUE(called);
   impl.binding()->FlushForTesting();
 }
 
 TEST_F(AssociatedInterfaceTest, BindingFlushForTesting) {
   IntegerSenderConnectionPtr ptr;
-  IntegerSenderConnectionImpl impl(GetProxy(&ptr));
+  IntegerSenderConnectionImpl impl(MakeRequest(&ptr));
   bool called = false;
   ptr->AsyncGetSender(base::Bind(
       &SetBoolWithUnusedParameter<IntegerSenderAssociatedPtrInfo>, &called));
   EXPECT_FALSE(called);
   impl.binding()->set_connection_error_handler(base::Bind(&Fail));
   // 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.
   impl.binding()->FlushForTesting();
   impl.binding()->FlushForTesting();
   EXPECT_TRUE(called);
 }
 
 TEST_F(AssociatedInterfaceTest, BindingFlushForTestingWithClosedPeer) {
   IntegerSenderConnectionPtr ptr;
-  IntegerSenderConnectionImpl impl(GetProxy(&ptr));
+  IntegerSenderConnectionImpl impl(MakeRequest(&ptr));
   bool called = false;
   impl.binding()->set_connection_error_handler(base::Bind(&SetBool, &called));
   ptr.reset();
   EXPECT_FALSE(called);
   impl.binding()->FlushForTesting();
   EXPECT_TRUE(called);
   impl.binding()->FlushForTesting();
 }
 
 TEST_F(AssociatedInterfaceTest, StrongBindingFlushForTesting) {
   IntegerSenderConnectionPtr ptr;
   auto binding =
       MakeStrongBinding(base::MakeUnique<IntegerSenderConnectionImpl>(
                             IntegerSenderConnectionRequest{}),
-                        GetProxy(&ptr));
+                        MakeRequest(&ptr));
   bool called = false;
   IntegerSenderAssociatedPtr sender_ptr;
-  ptr->GetSender(GetProxy(&sender_ptr, ptr.associated_group()));
+  ptr->GetSender(MakeRequest(&sender_ptr, ptr.associated_group()));
   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);
 }
 
 TEST_F(AssociatedInterfaceTest, StrongBindingFlushForTestingWithClosedPeer) {
   IntegerSenderConnectionPtr ptr;
   bool called = false;
   auto binding =
       MakeStrongBinding(base::MakeUnique<IntegerSenderConnectionImpl>(
                             IntegerSenderConnectionRequest{}),
-                        GetProxy(&ptr));
+                        MakeRequest(&ptr));
   binding->set_connection_error_handler(base::Bind(&SetBool, &called));
   ptr.reset();
   EXPECT_FALSE(called);
   ASSERT_TRUE(binding);
   binding->FlushForTesting();
   EXPECT_TRUE(called);
   ASSERT_FALSE(binding);
 }
 
 TEST_F(AssociatedInterfaceTest, PtrFlushForTesting) {
   IntegerSenderConnectionPtr ptr;
-  IntegerSenderConnectionImpl impl(GetProxy(&ptr));
+  IntegerSenderConnectionImpl impl(MakeRequest(&ptr));
   bool called = false;
   ptr.set_connection_error_handler(base::Bind(&Fail));
   ptr->AsyncGetSender(base::Bind(
       &SetBoolWithUnusedParameter<IntegerSenderAssociatedPtrInfo>, &called));
   EXPECT_FALSE(called);
   ptr.FlushForTesting();
   EXPECT_TRUE(called);
 }
 
 TEST_F(AssociatedInterfaceTest, PtrFlushForTestingWithClosedPeer) {
   IntegerSenderConnectionPtr ptr;
-  GetProxy(&ptr);
+  MakeRequest(&ptr);
   bool called = false;
   ptr.set_connection_error_handler(base::Bind(&SetBool, &called));
   EXPECT_FALSE(called);
   ptr.FlushForTesting();
   EXPECT_TRUE(called);
   ptr.FlushForTesting();
 }
 
 TEST_F(AssociatedInterfaceTest, AssociatedBindingConnectionErrorWithReason) {
   AssociatedInterfaceRequest<IntegerSender> request;
@@ skipping 61 matching lines @@
       },
       run_loop.QuitClosure()));
 
   request.ResetWithReason(789u, "long time no see");
 
   run_loop.Run();
 }
 
 TEST_F(AssociatedInterfaceTest, ThreadSafeAssociatedInterfacePtr) {
   IntegerSenderConnectionPtr connection_ptr;
-  IntegerSenderConnectionImpl connection(GetProxy(&connection_ptr));
+  IntegerSenderConnectionImpl connection(MakeRequest(&connection_ptr));
 
   IntegerSenderAssociatedPtr sender;
   connection_ptr->GetSender(
-      GetProxy(&sender, connection_ptr.associated_group()));
+      MakeRequest(&sender, connection_ptr.associated_group()));
 
   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 55 matching lines @@
     base::RunLoop run_loop;
     auto run_method = base::Bind(
         [](const scoped_refptr<base::TaskRunner>& main_task_runner,
            const base::Closure& quit_closure,
            const scoped_refptr<ThreadSafeIntegerSenderAssociatedPtr>&
                thread_safe_ptr,
            ForwarderTestContext* context) {
           // We are on the background thread, create the interface ptr.
           context->interface_impl =
               base::MakeUnique<IntegerSenderConnectionImpl>(
-                  GetProxy(&(context->connection_ptr)));
+                  MakeRequest(&(context->connection_ptr)));
           IntegerSenderAssociatedPtr sender;
           context->connection_ptr->GetSender(
-              GetProxy(&sender, context->connection_ptr.associated_group()));
+              MakeRequest(&sender, context->connection_ptr.associated_group()));
           thread_safe_ptr->Bind(std::move(sender));
           main_task_runner->PostTask(FROM_HERE, quit_closure);
         },
         base::SequencedTaskRunnerHandle::Get(), run_loop.QuitClosure(),
         thread_safe_ptr, context);
 
     other_thread_task_runner->PostTask(FROM_HERE, run_method);
     // Block until the associated pointer is bound.
     run_loop.Run();
   }
@@ skipping 15 matching lines @@
   other_thread_task_runner->DeleteSoon(FROM_HERE, context);
 
   // Reset the pointer now so the InterfacePtr associated resources can be
   // deleted before the background thread's message loop is invalidated.
   thread_safe_ptr = nullptr;
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo