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

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

 // Copyright 2016 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 <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 249 matching lines @@
   ~SyncMethodCommonTest() override {}
 };
 
 class SyncMethodAssociatedTest : public SyncMethodTest {
  public:
   SyncMethodAssociatedTest() {}
   ~SyncMethodAssociatedTest() override {}
 
  protected:
   void SetUp() override {
-    master_impl_.reset(new TestSyncMasterImpl(GetProxy(&master_ptr_)));
+    master_impl_.reset(new TestSyncMasterImpl(MakeRequest(&master_ptr_)));
 
     master_ptr_.associated_group()->CreateAssociatedInterface(
         AssociatedGroup::WILL_PASS_REQUEST, &asso_ptr_info_, &asso_request_);
     master_ptr_.associated_group()->CreateAssociatedInterface(
         AssociatedGroup::WILL_PASS_PTR, &opposite_asso_ptr_info_,
         &opposite_asso_request_);
 
     master_impl_->set_send_interface_handler(
         [this](TestSyncAssociatedPtrInfo ptr) {
           opposite_asso_ptr_info_ = std::move(ptr);
@@ skipping 54 matching lines @@
   return base::Bind(&CallAsyncEchoCallback<Func>, func);
 }
 
 // TestSync and TestSyncMaster exercise Router and MultiplexRouter,
 // respectively.
 using InterfaceTypes = testing::Types<TestSync, TestSyncMaster>;
 TYPED_TEST_CASE(SyncMethodCommonTest, InterfaceTypes);
 
 TYPED_TEST(SyncMethodCommonTest, CallSyncMethodAsynchronously) {
   InterfacePtr<TypeParam> ptr;
-  typename ImplTraits<TypeParam>::Type impl(GetProxy(&ptr));
+  typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
 
   base::RunLoop run_loop;
   ptr->Echo(123, base::Bind(&ExpectValueAndRunClosure, 123,
                             run_loop.QuitClosure()));
   run_loop.Run();
 }
 
 TYPED_TEST(SyncMethodCommonTest, BasicSyncCalls) {
   InterfacePtr<TypeParam> ptr;
 
   TestSyncServiceThread<TypeParam> service_thread;
   service_thread.thread()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&TestSyncServiceThread<TypeParam>::SetUp,
                             base::Unretained(&service_thread),
-                            base::Passed(GetProxy(&ptr))));
+                            base::Passed(MakeRequest(&ptr))));
   ASSERT_TRUE(ptr->Ping());
   ASSERT_TRUE(service_thread.ping_called());
 
   int32_t output_value = -1;
   ASSERT_TRUE(ptr->Echo(42, &output_value));
   ASSERT_EQ(42, output_value);
 
   base::RunLoop run_loop;
   service_thread.thread()->task_runner()->PostTaskAndReply(
       FROM_HERE, base::Bind(&TestSyncServiceThread<TypeParam>::TearDown,
                             base::Unretained(&service_thread)),
       run_loop.QuitClosure());
   run_loop.Run();
 }
 
 TYPED_TEST(SyncMethodCommonTest, ReenteredBySyncMethodBinding) {
   // Test that an interface pointer waiting for a sync call response can be
   // reentered by a binding serving sync methods on the same thread.
 
   InterfacePtr<TypeParam> ptr;
   // The binding lives on the same thread as the interface pointer.
-  typename ImplTraits<TypeParam>::Type impl(GetProxy(&ptr));
+  typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
   int32_t output_value = -1;
   ASSERT_TRUE(ptr->Echo(42, &output_value));
   EXPECT_EQ(42, output_value);
 }
 
 TYPED_TEST(SyncMethodCommonTest, InterfacePtrDestroyedDuringSyncCall) {
   // Test that it won't result in crash or hang if an interface pointer is
   // destroyed while it is waiting for a sync call response.
 
   InterfacePtr<TypeParam> ptr;
-  typename ImplTraits<TypeParam>::Type impl(GetProxy(&ptr));
+  typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
   impl.set_ping_handler([&ptr](const TestSync::PingCallback& callback) {
     ptr.reset();
     callback.Run();
   });
   ASSERT_FALSE(ptr->Ping());
 }
 
 TYPED_TEST(SyncMethodCommonTest, BindingDestroyedDuringSyncCall) {
   // Test that it won't result in crash or hang if a binding is
   // closed (and therefore the message pipe handle is closed) while the
   // corresponding interface pointer is waiting for a sync call response.
 
   InterfacePtr<TypeParam> ptr;
-  typename ImplTraits<TypeParam>::Type impl(GetProxy(&ptr));
+  typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
   impl.set_ping_handler([&impl](const TestSync::PingCallback& callback) {
     impl.binding()->Close();
     callback.Run();
   });
   ASSERT_FALSE(ptr->Ping());
 }
 
 TYPED_TEST(SyncMethodCommonTest, NestedSyncCallsWithInOrderResponses) {
   // Test that we can call a sync method on an interface ptr, while there is
   // already a sync call ongoing. The responses arrive in order.
 
   InterfacePtr<TypeParam> ptr;
-  typename ImplTraits<TypeParam>::Type impl(GetProxy(&ptr));
+  typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
 
   // The same variable is used to store the output of the two sync calls, in
   // order to test that responses are handled in the correct order.
   int32_t result_value = -1;
 
   bool first_call = true;
   impl.set_echo_handler([&first_call, &ptr, &result_value](
       int32_t value, const TestSync::EchoCallback& callback) {
     if (first_call) {
       first_call = false;
       ASSERT_TRUE(ptr->Echo(456, &result_value));
       EXPECT_EQ(456, result_value);
     }
     callback.Run(value);
   });
 
   ASSERT_TRUE(ptr->Echo(123, &result_value));
   EXPECT_EQ(123, result_value);
 }
 
 TYPED_TEST(SyncMethodCommonTest, NestedSyncCallsWithOutOfOrderResponses) {
   // Test that we can call a sync method on an interface ptr, while there is
   // already a sync call ongoing. The responses arrive out of order.
 
   InterfacePtr<TypeParam> ptr;
-  typename ImplTraits<TypeParam>::Type impl(GetProxy(&ptr));
+  typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
 
   // The same variable is used to store the output of the two sync calls, in
   // order to test that responses are handled in the correct order.
   int32_t result_value = -1;
 
   bool first_call = true;
   impl.set_echo_handler([&first_call, &ptr, &result_value](
       int32_t value, const TestSync::EchoCallback& callback) {
     callback.Run(value);
     if (first_call) {
       first_call = false;
       ASSERT_TRUE(ptr->Echo(456, &result_value));
       EXPECT_EQ(456, result_value);
     }
   });
 
   ASSERT_TRUE(ptr->Echo(123, &result_value));
   EXPECT_EQ(123, result_value);
 }
 
 TYPED_TEST(SyncMethodCommonTest, AsyncResponseQueuedDuringSyncCall) {
   // Test that while an interface pointer is waiting for the response to a sync
   // call, async responses are queued until the sync call completes.
 
   InterfacePtr<TypeParam> ptr;
-  typename ImplTraits<TypeParam>::Type impl(GetProxy(&ptr));
+  typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
 
   int32_t async_echo_request_value = -1;
   TestSync::AsyncEchoCallback async_echo_request_callback;
   base::RunLoop run_loop1;
   impl.set_async_echo_handler(
       [&async_echo_request_value, &async_echo_request_callback, &run_loop1](
           int32_t value, const TestSync::AsyncEchoCallback& callback) {
         async_echo_request_value = value;
         async_echo_request_callback = callback;
         run_loop1.Quit();
@@ skipping 35 matching lines @@
 
   EXPECT_TRUE(async_echo_response_dispatched);
 }
 
 TYPED_TEST(SyncMethodCommonTest, AsyncRequestQueuedDuringSyncCall) {
   // Test that while an interface pointer is waiting for the response to a sync
   // call, async requests for a binding running on the same thread are queued
   // until the sync call completes.
 
   InterfacePtr<TypeParam> ptr;
-  typename ImplTraits<TypeParam>::Type impl(GetProxy(&ptr));
+  typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
 
   bool async_echo_request_dispatched = false;
   impl.set_async_echo_handler([&async_echo_request_dispatched](
       int32_t value, const TestSync::AsyncEchoCallback& callback) {
     async_echo_request_dispatched = true;
     callback.Run(value);
   });
 
   bool async_echo_response_dispatched = false;
   base::RunLoop run_loop;
@@ skipping 30 matching lines @@
 }
 
 TYPED_TEST(SyncMethodCommonTest,
            QueuedMessagesProcessedBeforeErrorNotification) {
   // Test that while an interface pointer is waiting for the response to a sync
   // call, async responses are queued. If the message pipe is disconnected
   // before the queued messages are processed, the connection error
   // notification is delayed until all the queued messages are processed.
 
   InterfacePtr<TypeParam> ptr;
-  typename ImplTraits<TypeParam>::Type impl(GetProxy(&ptr));
+  typename ImplTraits<TypeParam>::Type impl(MakeRequest(&ptr));
 
   int32_t async_echo_request_value = -1;
   TestSync::AsyncEchoCallback async_echo_request_callback;
   base::RunLoop run_loop1;
   impl.set_async_echo_handler(
       [&async_echo_request_value, &async_echo_request_callback, &run_loop1](
           int32_t value, const TestSync::AsyncEchoCallback& callback) {
         async_echo_request_value = value;
         async_echo_request_callback = callback;
         run_loop1.Quit();
@@ skipping 143 matching lines @@
   int32_t result_value = -1;
   ASSERT_TRUE(master_ptr_->Echo(456, &result_value));
   EXPECT_EQ(456, result_value);
 }
 
 // TODO(yzshen): Add more tests related to associated interfaces.
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo