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

mojo/public/cpp/bindings/tests/binding_set_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 <memory>
 #include <utility>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/associated_binding_set.h"
@@ skipping 61 matching lines @@
 };
 
 TEST_F(BindingSetTest, BindingSetContext) {
   PingImpl impl;
 
   void* context_a = reinterpret_cast<void*>(1);
   void* context_b = reinterpret_cast<void*>(2);
 
   BindingSet<PingService> bindings_(BindingSetDispatchMode::WITH_CONTEXT);
   PingServicePtr ping_a, ping_b;
-  bindings_.AddBinding(&impl, GetProxy(&ping_a), context_a);
-  bindings_.AddBinding(&impl, GetProxy(&ping_b), context_b);
+  bindings_.AddBinding(&impl, MakeRequest(&ping_a), context_a);
+  bindings_.AddBinding(&impl, MakeRequest(&ping_b), context_b);
 
   {
     impl.set_ping_handler(ExpectContext(&bindings_, context_a));
     base::RunLoop loop;
     ping_a->Ping(loop.QuitClosure());
     loop.Run();
   }
 
   {
     impl.set_ping_handler(ExpectContext(&bindings_, context_b));
@@ skipping 18 matching lines @@
     loop.Run();
   }
 
   EXPECT_TRUE(bindings_.empty());
 }
 
 TEST_F(BindingSetTest, BindingSetConnectionErrorWithReason) {
   PingImpl impl;
   PingServicePtr ptr;
   BindingSet<PingService> bindings;
-  bindings.AddBinding(&impl, GetProxy(&ptr));
+  bindings.AddBinding(&impl, MakeRequest(&ptr));
 
   base::RunLoop run_loop;
   bindings.set_connection_error_with_reason_handler(base::Bind(
       [](const base::Closure& quit_closure, uint32_t custom_reason,
          const std::string& description) {
         EXPECT_EQ(1024u, custom_reason);
         EXPECT_EQ("bye", description);
         quit_closure.Run();
       },
       run_loop.QuitClosure()));
@@ skipping 35 matching lines @@
 
   AssociatedBindingSet<PingService> ping_bindings_;
   void* new_ping_context_ = nullptr;
   base::Closure ping_handler_;
   base::Closure new_ping_handler_;
 };
 
 TEST_F(BindingSetTest, AssociatedBindingSetContext) {
   AssociatedPingProviderPtr provider;
   PingProviderImpl impl;
-  Binding<AssociatedPingProvider> binding(&impl, GetProxy(&provider));
+  Binding<AssociatedPingProvider> binding(&impl, MakeRequest(&provider));
 
   void* context_a = reinterpret_cast<void*>(1);
   void* context_b = reinterpret_cast<void*>(2);
 
   PingServiceAssociatedPtr ping_a;
   {
     base::RunLoop loop;
     impl.set_new_ping_context(context_a);
     impl.set_new_ping_handler(loop.QuitClosure());
-    provider->GetPing(GetProxy(&ping_a, provider.associated_group()));
+    provider->GetPing(MakeRequest(&ping_a, provider.associated_group()));
     loop.Run();
   }
 
   PingServiceAssociatedPtr ping_b;
   {
     base::RunLoop loop;
     impl.set_new_ping_context(context_b);
     impl.set_new_ping_handler(loop.QuitClosure());
-    provider->GetPing(GetProxy(&ping_b, provider.associated_group()));
+    provider->GetPing(MakeRequest(&ping_b, provider.associated_group()));
     loop.Run();
   }
 
   {
     impl.set_ping_handler(ExpectContext(&impl.ping_bindings(), context_a));
     base::RunLoop loop;
     ping_a->Ping(loop.QuitClosure());
     loop.Run();
   }
 
@@ skipping 27 matching lines @@
 
 TEST_F(BindingSetTest, MasterInterfaceBindingSetContext) {
   AssociatedPingProviderPtr provider_a, provider_b;
   PingProviderImpl impl;
   BindingSet<AssociatedPingProvider> bindings(
       BindingSetDispatchMode::WITH_CONTEXT);
 
   void* context_a = reinterpret_cast<void*>(1);
   void* context_b = reinterpret_cast<void*>(2);
 
-  bindings.AddBinding(&impl, GetProxy(&provider_a), context_a);
-  bindings.AddBinding(&impl, GetProxy(&provider_b), context_b);
+  bindings.AddBinding(&impl, MakeRequest(&provider_a), context_a);
+  bindings.AddBinding(&impl, MakeRequest(&provider_b), context_b);
 
   {
     PingServiceAssociatedPtr ping;
     base::RunLoop loop;
     impl.set_new_ping_handler(
         Sequence(ExpectContext(&bindings, context_a), loop.QuitClosure()));
-    provider_a->GetPing(GetProxy(&ping, provider_a.associated_group()));
+    provider_a->GetPing(MakeRequest(&ping, provider_a.associated_group()));
     loop.Run();
   }
 
   {
     PingServiceAssociatedPtr ping;
     base::RunLoop loop;
     impl.set_new_ping_handler(
         Sequence(ExpectContext(&bindings, context_b), loop.QuitClosure()));
-    provider_b->GetPing(GetProxy(&ping, provider_b.associated_group()));
+    provider_b->GetPing(MakeRequest(&ping, provider_b.associated_group()));
     loop.Run();
   }
 
   {
     base::RunLoop loop;
     bindings.set_connection_error_handler(
         Sequence(ExpectContext(&bindings, context_a), loop.QuitClosure()));
     provider_a.reset();
     loop.Run();
   }
@@ skipping 19 matching lines @@
       base::Bind(
           [](const base::Closure& quit_closure, uint32_t custom_reason,
              const std::string& description) {
             EXPECT_EQ(2048u, custom_reason);
             EXPECT_EQ("bye", description);
             quit_closure.Run();
           },
           run_loop.QuitClosure()));
 
   PingServiceAssociatedPtr ptr;
-  master_ptr->GetPing(GetProxy(&ptr, master_ptr.associated_group()));
+  master_ptr->GetPing(MakeRequest(&ptr, master_ptr.associated_group()));
 
   ptr.ResetWithReason(2048u, "bye");
 
   run_loop.Run();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo