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

mojo/public/cpp/bindings/tests/binding_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.
 
 // Note: This file tests both binding.h (mojo::Binding) and strong_binding.h
 // (mojo::StrongBinding).
 
 #include "mojo/public/cpp/bindings/binding.h"
 
 #include <stdint.h>
@@ skipping 65 matching lines @@
   return base::Bind(&DoSetFlagAndRunClosure<Args...>, flag, callback);
 }
 
 // BindingTest -----------------------------------------------------------------
 
 using BindingTest = BindingTestBase;
 
 TEST_F(BindingTest, Close) {
   bool called = false;
   sample::ServicePtr ptr;
-  auto request = GetProxy(&ptr);
+  auto request = MakeRequest(&ptr);
   base::RunLoop run_loop;
   ptr.set_connection_error_handler(
       SetFlagAndRunClosure(&called, run_loop.QuitClosure()));
   ServiceImpl impl;
   Binding<sample::Service> binding(&impl, std::move(request));
 
   binding.Close();
   EXPECT_FALSE(called);
   run_loop.Run();
   EXPECT_TRUE(called);
 }
 
 // Tests that destroying a mojo::Binding closes the bound message pipe handle.
 TEST_F(BindingTest, DestroyClosesMessagePipe) {
   bool encountered_error = false;
   ServiceImpl impl;
   sample::ServicePtr ptr;
-  auto request = GetProxy(&ptr);
+  auto request = MakeRequest(&ptr);
   base::RunLoop run_loop;
   ptr.set_connection_error_handler(
       SetFlagAndRunClosure(&encountered_error, run_loop.QuitClosure()));
   bool called = false;
   base::RunLoop run_loop2;
   {
     Binding<sample::Service> binding(&impl, std::move(request));
     ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                    SetFlagAndRunClosure<int32_t>(&called,
                                                  run_loop2.QuitClosure()));
@@ skipping 15 matching lines @@
   EXPECT_FALSE(called);
 }
 
 // Tests that the binding's connection error handler gets called when the other
 // end is closed.
 TEST_F(BindingTest, ConnectionError) {
   bool called = false;
   {
     ServiceImpl impl;
     sample::ServicePtr ptr;
-    Binding<sample::Service> binding(&impl, GetProxy(&ptr));
+    Binding<sample::Service> binding(&impl, MakeRequest(&ptr));
     base::RunLoop run_loop;
     binding.set_connection_error_handler(
         SetFlagAndRunClosure(&called, run_loop.QuitClosure()));
     ptr.reset();
     EXPECT_FALSE(called);
     run_loop.Run();
     EXPECT_TRUE(called);
     // We want to make sure that it isn't called again during destruction.
     called = false;
   }
   EXPECT_FALSE(called);
 }
 
 // Tests that calling Close doesn't result in the connection error handler being
 // called.
 TEST_F(BindingTest, CloseDoesntCallConnectionErrorHandler) {
   ServiceImpl impl;
   sample::ServicePtr ptr;
-  Binding<sample::Service> binding(&impl, GetProxy(&ptr));
+  Binding<sample::Service> binding(&impl, MakeRequest(&ptr));
   bool called = false;
   binding.set_connection_error_handler(SetFlagAndRunClosure(&called));
   binding.Close();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(called);
 
   // We can also close the other end, and the error handler still won't be
   // called.
   ptr.reset();
   base::RunLoop().RunUntilIdle();
@@ skipping 26 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ServiceImplWithBinding);
 };
 
 // Tests that the binding may be deleted in the connection error handler.
 TEST_F(BindingTest, SelfDeleteOnConnectionError) {
   bool was_deleted = false;
   sample::ServicePtr ptr;
   // This should delete itself on connection error.
   base::RunLoop run_loop;
   new ServiceImplWithBinding(&was_deleted, run_loop.QuitClosure(),
-                             GetProxy(&ptr));
+                             MakeRequest(&ptr));
   ptr.reset();
   EXPECT_FALSE(was_deleted);
   run_loop.Run();
   EXPECT_TRUE(was_deleted);
 }
 
 // Tests that explicitly calling Unbind followed by rebinding works.
 TEST_F(BindingTest, Unbind) {
   ServiceImpl impl;
   sample::ServicePtr ptr;
-  Binding<sample::Service> binding(&impl, GetProxy(&ptr));
+  Binding<sample::Service> binding(&impl, MakeRequest(&ptr));
 
   bool called = false;
   base::RunLoop run_loop;
   ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                  SetFlagAndRunClosure<int32_t>(&called,
                                                run_loop.QuitClosure()));
   run_loop.Run();
   EXPECT_TRUE(called);
 
   called = false;
@@ skipping 37 matching lines @@
   IntegerAccessorImpl impl;
   sample::IntegerAccessorPtr ptr;
   Binding<sample::IntegerAccessor> binding(&impl, &ptr);
   EXPECT_EQ(3u, ptr.version());
 }
 
 TEST_F(BindingTest, PauseResume) {
   bool called = false;
   base::RunLoop run_loop;
   sample::ServicePtr ptr;
-  auto request = GetProxy(&ptr);
+  auto request = MakeRequest(&ptr);
   ServiceImpl impl;
   Binding<sample::Service> binding(&impl, std::move(request));
   binding.PauseIncomingMethodCallProcessing();
   ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                  SetFlagAndRunClosure<int32_t>(&called,
                                                run_loop.QuitClosure()));
   EXPECT_FALSE(called);
   base::RunLoop().RunUntilIdle();
   // Frobinate() should not be called as the binding is paused.
   EXPECT_FALSE(called);
 
   // Resume the binding, which should trigger processing.
   binding.ResumeIncomingMethodCallProcessing();
   run_loop.Run();
   EXPECT_TRUE(called);
 }
 
 // Verifies the connection error handler is not run while a binding is paused.
 TEST_F(BindingTest, ErrorHandleNotRunWhilePaused) {
   bool called = false;
   base::RunLoop run_loop;
   sample::ServicePtr ptr;
-  auto request = GetProxy(&ptr);
+  auto request = MakeRequest(&ptr);
   ServiceImpl impl;
   Binding<sample::Service> binding(&impl, std::move(request));
   binding.set_connection_error_handler(
       SetFlagAndRunClosure(&called, run_loop.QuitClosure()));
   binding.PauseIncomingMethodCallProcessing();
 
   ptr.reset();
   base::RunLoop().RunUntilIdle();
   // The connection error handle should not be called as the binding is paused.
   EXPECT_FALSE(called);
@@ skipping 44 matching lines @@
 
  private:
   const base::Closure callback_;
 };
 
 // Verifies that message filters are notified in the order they were added and
 // are always notified before a message is dispatched.
 TEST_F(BindingTest, MessageFilter) {
   test::PingServicePtr ptr;
   PingServiceImpl impl;
-  mojo::Binding<test::PingService> binding(&impl, GetProxy(&ptr));
+  mojo::Binding<test::PingService> binding(&impl, MakeRequest(&ptr));
 
   int status = 0;
   auto handler_helper = [] (int* status, int expected_status, int new_status) {
     EXPECT_EQ(expected_status, *status);
     *status = new_status;
   };
   auto create_handler = [&] (int expected_status, int new_status) {
     return base::Bind(handler_helper, &status, expected_status, new_status);
   };
 
@@ skipping 10 matching lines @@
   }
 }
 
 void Fail() {
   FAIL() << "Unexpected connection error";
 }
 
 TEST_F(BindingTest, FlushForTesting) {
   bool called = false;
   sample::ServicePtr ptr;
-  auto request = GetProxy(&ptr);
+  auto request = MakeRequest(&ptr);
   ServiceImpl impl;
   Binding<sample::Service> binding(&impl, std::move(request));
   binding.set_connection_error_handler(base::Bind(&Fail));
 
   ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                  SetFlagAndRunClosure<int32_t>(&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.
   binding.FlushForTesting();
   binding.FlushForTesting();
   EXPECT_TRUE(called);
 }
 
 TEST_F(BindingTest, FlushForTestingWithClosedPeer) {
   bool called = false;
   sample::ServicePtr ptr;
-  auto request = GetProxy(&ptr);
+  auto request = MakeRequest(&ptr);
   ServiceImpl impl;
   Binding<sample::Service> binding(&impl, std::move(request));
   binding.set_connection_error_handler(SetFlagAndRunClosure(&called));
   ptr.reset();
 
   EXPECT_FALSE(called);
   binding.FlushForTesting();
   EXPECT_TRUE(called);
   binding.FlushForTesting();
 }
 
 TEST_F(BindingTest, ConnectionErrorWithReason) {
   sample::ServicePtr ptr;
-  auto request = GetProxy(&ptr);
+  auto request = MakeRequest(&ptr);
   ServiceImpl impl;
   Binding<sample::Service> binding(&impl, std::move(request));
 
   base::RunLoop run_loop;
   binding.set_connection_error_with_reason_handler(base::Bind(
       [](const base::Closure& quit_closure, uint32_t custom_reason,
          const std::string& description) {
         EXPECT_EQ(1234u, custom_reason);
         EXPECT_EQ("hello", description);
         quit_closure.Run();
@@ skipping 15 matching lines @@
 
 template <typename T>
 using WeakBinding = Binding<T, WeakPtrImplRefTraits<T>>;
 
 TEST_F(BindingTest, CustomImplPointerType) {
   PingServiceImpl impl;
   base::WeakPtrFactory<test::PingService> weak_factory(&impl);
 
   test::PingServicePtr proxy;
   WeakBinding<test::PingService> binding(weak_factory.GetWeakPtr(),
-                                         GetProxy(&proxy));
+                                         MakeRequest(&proxy));
 
   {
     // Ensure the binding is functioning.
     base::RunLoop run_loop;
     proxy->Ping(run_loop.QuitClosure());
     run_loop.Run();
   }
 
   {
     // Attempt to dispatch another message after the WeakPtr is invalidated.
@@ skipping 14 matching lines @@
 
 using StrongBindingTest = BindingTestBase;
 
 // Tests that destroying a mojo::StrongBinding closes the bound message pipe
 // handle but does *not* destroy the implementation object.
 TEST_F(StrongBindingTest, DestroyClosesMessagePipe) {
   base::RunLoop run_loop;
   bool encountered_error = false;
   bool was_deleted = false;
   sample::ServicePtr ptr;
-  auto request = GetProxy(&ptr);
+  auto request = MakeRequest(&ptr);
   ptr.set_connection_error_handler(
       SetFlagAndRunClosure(&encountered_error, run_loop.QuitClosure()));
   bool called = false;
   base::RunLoop run_loop2;
 
   auto binding = MakeStrongBinding(base::MakeUnique<ServiceImpl>(&was_deleted),
                                    std::move(request));
   ptr->Frobinate(
       nullptr, sample::Service::BazOptions::REGULAR, nullptr,
       SetFlagAndRunClosure<int32_t>(&called, run_loop2.QuitClosure()));
@@ skipping 12 matching lines @@
 }
 
 // Tests the typical case, where the implementation object owns the
 // StrongBinding (and should be destroyed on connection error).
 TEST_F(StrongBindingTest, ConnectionErrorDestroysImpl) {
   sample::ServicePtr ptr;
   bool was_deleted = false;
   // Will delete itself.
   base::RunLoop run_loop;
   new ServiceImplWithBinding(&was_deleted, run_loop.QuitClosure(),
-                             GetProxy(&ptr));
+                             MakeRequest(&ptr));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(was_deleted);
 
   ptr.reset();
   EXPECT_FALSE(was_deleted);
   run_loop.Run();
   EXPECT_TRUE(was_deleted);
 }
 
 TEST_F(StrongBindingTest, FlushForTesting) {
   bool called = false;
   bool was_deleted = false;
   sample::ServicePtr ptr;
-  auto request = GetProxy(&ptr);
+  auto request = MakeRequest(&ptr);
   auto binding = MakeStrongBinding(base::MakeUnique<ServiceImpl>(&was_deleted),
                                    std::move(request));
   binding->set_connection_error_handler(base::Bind(&Fail));
 
   ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                  SetFlagAndRunClosure<int32_t>(&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);
   EXPECT_FALSE(was_deleted);
   ptr.reset();
   ASSERT_TRUE(binding);
   binding->set_connection_error_handler(base::Closure());
   binding->FlushForTesting();
   EXPECT_TRUE(was_deleted);
 }
 
 TEST_F(StrongBindingTest, FlushForTestingWithClosedPeer) {
   bool called = false;
   bool was_deleted = false;
   sample::ServicePtr ptr;
-  auto request = GetProxy(&ptr);
+  auto request = MakeRequest(&ptr);
   auto binding = MakeStrongBinding(base::MakeUnique<ServiceImpl>(&was_deleted),
                                    std::move(request));
   binding->set_connection_error_handler(SetFlagAndRunClosure(&called));
   ptr.reset();
 
   EXPECT_FALSE(called);
   EXPECT_FALSE(was_deleted);
   ASSERT_TRUE(binding);
   binding->FlushForTesting();
   EXPECT_TRUE(called);
   EXPECT_TRUE(was_deleted);
   ASSERT_FALSE(binding);
 }
 
 TEST_F(StrongBindingTest, ConnectionErrorWithReason) {
   sample::ServicePtr ptr;
-  auto request = GetProxy(&ptr);
+  auto request = MakeRequest(&ptr);
   auto binding =
       MakeStrongBinding(base::MakeUnique<ServiceImpl>(), std::move(request));
   base::RunLoop run_loop;
   binding->set_connection_error_with_reason_handler(base::Bind(
       [](const base::Closure& quit_closure, uint32_t custom_reason,
          const std::string& description) {
         EXPECT_EQ(5678u, custom_reason);
         EXPECT_EQ("hello", description);
         quit_closure.Run();
       },
       run_loop.QuitClosure()));
 
   ptr.ResetWithReason(5678u, "hello");
 
   run_loop.Run();
 }
 
 }  // namespace
 }  // mojo