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

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

 // Copyright 2013 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 <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 203 matching lines @@
 void ExpectValueAndRunClosure(uint32_t expected_value,
                               const base::Closure& closure,
                               uint32_t value) {
   EXPECT_EQ(expected_value, value);
   closure.Run();
 }
 
 TEST_F(InterfacePtrTest, IsBound) {
   math::CalculatorPtr calc;
   EXPECT_FALSE(calc.is_bound());
-  MathCalculatorImpl calc_impl(GetProxy(&calc));
+  MathCalculatorImpl calc_impl(MakeRequest(&calc));
   EXPECT_TRUE(calc.is_bound());
 }
 
 TEST_F(InterfacePtrTest, EndToEnd) {
   math::CalculatorPtr calc;
-  MathCalculatorImpl calc_impl(GetProxy(&calc));
+  MathCalculatorImpl calc_impl(MakeRequest(&calc));
 
   // Suppose this is instantiated in a process that has pipe1_.
   MathCalculatorUI calculator_ui(std::move(calc));
 
   base::RunLoop run_loop, run_loop2;
   calculator_ui.Add(2.0, run_loop.QuitClosure());
   calculator_ui.Multiply(5.0, run_loop2.QuitClosure());
   run_loop.Run();
   run_loop2.Run();
 
   EXPECT_EQ(10.0, calculator_ui.GetOutput());
 }
 
 TEST_F(InterfacePtrTest, EndToEnd_Synchronous) {
   math::CalculatorPtr calc;
-  MathCalculatorImpl calc_impl(GetProxy(&calc));
+  MathCalculatorImpl calc_impl(MakeRequest(&calc));
 
   // Suppose this is instantiated in a process that has pipe1_.
   MathCalculatorUI calculator_ui(std::move(calc));
 
   EXPECT_EQ(0.0, calculator_ui.GetOutput());
 
   base::RunLoop run_loop;
   calculator_ui.Add(2.0, run_loop.QuitClosure());
   EXPECT_EQ(0.0, calculator_ui.GetOutput());
   calc_impl.binding()->WaitForIncomingMethodCall();
   run_loop.Run();
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
 
   base::RunLoop run_loop2;
   calculator_ui.Multiply(5.0, run_loop2.QuitClosure());
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
   calc_impl.binding()->WaitForIncomingMethodCall();
   run_loop2.Run();
   EXPECT_EQ(10.0, calculator_ui.GetOutput());
 }
 
 TEST_F(InterfacePtrTest, Movable) {
   math::CalculatorPtr a;
   math::CalculatorPtr b;
-  MathCalculatorImpl calc_impl(GetProxy(&b));
+  MathCalculatorImpl calc_impl(MakeRequest(&b));
 
   EXPECT_TRUE(!a);
   EXPECT_FALSE(!b);
 
   a = std::move(b);
 
   EXPECT_FALSE(!a);
   EXPECT_TRUE(!b);
 }
 
@@ skipping 26 matching lines @@
   EXPECT_FALSE(ptr.get());
   EXPECT_FALSE(ptr);
 
   ptr.Bind(InterfacePtrInfo<math::Calculator>());
   EXPECT_FALSE(ptr.get());
   EXPECT_FALSE(ptr);
 }
 
 TEST_F(InterfacePtrTest, EncounteredError) {
   math::CalculatorPtr proxy;
-  MathCalculatorImpl calc_impl(GetProxy(&proxy));
+  MathCalculatorImpl calc_impl(MakeRequest(&proxy));
 
   MathCalculatorUI calculator_ui(std::move(proxy));
 
   base::RunLoop run_loop;
   calculator_ui.Add(2.0, run_loop.QuitClosure());
   run_loop.Run();
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   calculator_ui.Multiply(5.0, base::Closure());
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   // Close the server.
   calc_impl.binding()->Close();
 
   // The state change isn't picked up locally yet.
   base::RunLoop run_loop2;
   calculator_ui.set_connection_error_handler(run_loop2.QuitClosure());
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   run_loop2.Run();
 
   // OK, now we see the error.
   EXPECT_TRUE(calculator_ui.encountered_error());
 }
 
 TEST_F(InterfacePtrTest, EncounteredErrorCallback) {
   math::CalculatorPtr proxy;
-  MathCalculatorImpl calc_impl(GetProxy(&proxy));
+  MathCalculatorImpl calc_impl(MakeRequest(&proxy));
 
   bool encountered_error = false;
   base::RunLoop run_loop;
   proxy.set_connection_error_handler(
       base::Bind(&SetFlagAndRunClosure, &encountered_error,
                  run_loop.QuitClosure()));
 
   MathCalculatorUI calculator_ui(std::move(proxy));
 
   base::RunLoop run_loop2;
@@ skipping 16 matching lines @@
   // OK, now we see the error.
   EXPECT_TRUE(calculator_ui.encountered_error());
 
   // We should have also been able to observe the error through the error
   // handler.
   EXPECT_TRUE(encountered_error);
 }
 
 TEST_F(InterfacePtrTest, DestroyInterfacePtrOnMethodResponse) {
   math::CalculatorPtr proxy;
-  MathCalculatorImpl calc_impl(GetProxy(&proxy));
+  MathCalculatorImpl calc_impl(MakeRequest(&proxy));
 
   EXPECT_EQ(0, SelfDestructingMathCalculatorUI::num_instances());
 
   SelfDestructingMathCalculatorUI* impl =
       new SelfDestructingMathCalculatorUI(std::move(proxy));
   base::RunLoop run_loop;
   impl->BeginTest(false, run_loop.QuitClosure());
   run_loop.Run();
 
   EXPECT_EQ(0, SelfDestructingMathCalculatorUI::num_instances());
 }
 
 TEST_F(InterfacePtrTest, NestedDestroyInterfacePtrOnMethodResponse) {
   math::CalculatorPtr proxy;
-  MathCalculatorImpl calc_impl(GetProxy(&proxy));
+  MathCalculatorImpl calc_impl(MakeRequest(&proxy));
 
   EXPECT_EQ(0, SelfDestructingMathCalculatorUI::num_instances());
 
   SelfDestructingMathCalculatorUI* impl =
       new SelfDestructingMathCalculatorUI(std::move(proxy));
   base::RunLoop run_loop;
   impl->BeginTest(true, run_loop.QuitClosure());
   run_loop.Run();
 
   EXPECT_EQ(0, SelfDestructingMathCalculatorUI::num_instances());
 }
 
 TEST_F(InterfacePtrTest, ReentrantWaitForIncomingMethodCall) {
   sample::ServicePtr proxy;
-  ReentrantServiceImpl impl(GetProxy(&proxy));
+  ReentrantServiceImpl impl(MakeRequest(&proxy));
 
   base::RunLoop run_loop, run_loop2;
   proxy->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                    base::Bind(&IgnoreValueAndRunClosure,
                               run_loop.QuitClosure()));
   proxy->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
                    base::Bind(&IgnoreValueAndRunClosure,
                               run_loop2.QuitClosure()));
 
   run_loop.Run();
   run_loop2.Run();
 
   EXPECT_EQ(2, impl.max_call_depth());
 }
 
 TEST_F(InterfacePtrTest, QueryVersion) {
   IntegerAccessorImpl impl;
   sample::IntegerAccessorPtr ptr;
-  Binding<sample::IntegerAccessor> binding(&impl, GetProxy(&ptr));
+  Binding<sample::IntegerAccessor> binding(&impl, MakeRequest(&ptr));
 
   EXPECT_EQ(0u, ptr.version());
 
   base::RunLoop run_loop;
   ptr.QueryVersion(base::Bind(&ExpectValueAndRunClosure, 3u,
                               run_loop.QuitClosure()));
   run_loop.Run();
 
   EXPECT_EQ(3u, ptr.version());
 }
 
 TEST_F(InterfacePtrTest, RequireVersion) {
   IntegerAccessorImpl impl;
   sample::IntegerAccessorPtr ptr;
-  Binding<sample::IntegerAccessor> binding(&impl, GetProxy(&ptr));
+  Binding<sample::IntegerAccessor> binding(&impl, MakeRequest(&ptr));
 
   EXPECT_EQ(0u, ptr.version());
 
   ptr.RequireVersion(1u);
   EXPECT_EQ(1u, ptr.version());
   base::RunLoop run_loop;
   impl.set_closure(run_loop.QuitClosure());
   ptr->SetInteger(123, sample::Enum::VALUE);
   run_loop.Run();
   EXPECT_FALSE(ptr.encountered_error());
@@ skipping 45 matching lines @@
 };
 
 TEST(StrongConnectorTest, Math) {
   base::MessageLoop loop;
 
   bool error_received = false;
   bool destroyed = false;
   math::CalculatorPtr calc;
   base::RunLoop run_loop;
 
-  auto binding = MakeStrongBinding(
-      base::MakeUnique<StrongMathCalculatorImpl>(&destroyed), GetProxy(&calc));
+  auto binding =
+      MakeStrongBinding(base::MakeUnique<StrongMathCalculatorImpl>(&destroyed),
+                        MakeRequest(&calc));
   binding->set_connection_error_handler(base::Bind(
       &SetFlagAndRunClosure, &error_received, run_loop.QuitClosure()));
 
   {
     // Suppose this is instantiated in a process that has the other end of the
     // message pipe.
     MathCalculatorUI calculator_ui(std::move(calc));
 
     base::RunLoop run_loop, run_loop2;
     calculator_ui.Add(2.0, run_loop.QuitClosure());
@@ skipping 135 matching lines @@
   }
 
   bool d_called_;
   Binding<A> binding_;
   base::Closure closure_;
 };
 
 TEST_F(InterfacePtrTest, Scoping) {
   APtr a;
   base::RunLoop run_loop;
-  AImpl a_impl(GetProxy(&a), run_loop.QuitClosure());
+  AImpl a_impl(MakeRequest(&a), run_loop.QuitClosure());
 
   EXPECT_FALSE(a_impl.d_called());
 
   {
     BPtr b;
-    a->GetB(GetProxy(&b));
+    a->GetB(MakeRequest(&b));
     CPtr c;
-    b->GetC(GetProxy(&c));
+    b->GetC(MakeRequest(&c));
     c->D();
   }
 
   // While B & C have fallen out of scope, the pipes will remain until they are
   // flushed.
   EXPECT_FALSE(a_impl.d_called());
   run_loop.Run();
   EXPECT_TRUE(a_impl.d_called());
 }
 
 class PingTestImpl : public sample::PingTest {
  public:
   explicit PingTestImpl(InterfaceRequest<sample::PingTest> request)
       : binding_(this, std::move(request)) {}
   ~PingTestImpl() override {}
 
  private:
   // sample::PingTest:
   void Ping(const PingCallback& callback) override { callback.Run(); }
 
   Binding<sample::PingTest> binding_;
 };
 
 // Tests that FuseProxy does what it's supposed to do.
 TEST_F(InterfacePtrTest, Fusion) {
   sample::PingTestPtr proxy;
-  PingTestImpl impl(GetProxy(&proxy));
+  PingTestImpl impl(MakeRequest(&proxy));
 
   // Create another PingTest pipe.
   sample::PingTestPtr ptr;
-  sample::PingTestRequest request = GetProxy(&ptr);
+  sample::PingTestRequest request = MakeRequest(&ptr);
 
   // Fuse the new pipe to the one hanging off |impl|.
   EXPECT_TRUE(FuseInterface(std::move(request), proxy.PassInterface()));
 
   // Ping!
   bool called = false;
   base::RunLoop loop;
   ptr->Ping(base::Bind(&SetFlagAndRunClosure, &called, loop.QuitClosure()));
   loop.Run();
   EXPECT_TRUE(called);
 }
 
 void Fail() {
   FAIL() << "Unexpected connection error";
 }
 
 TEST_F(InterfacePtrTest, FlushForTesting) {
   math::CalculatorPtr calc;
-  MathCalculatorImpl calc_impl(GetProxy(&calc));
+  MathCalculatorImpl calc_impl(MakeRequest(&calc));
   calc.set_connection_error_handler(base::Bind(&Fail));
 
   MathCalculatorUI calculator_ui(std::move(calc));
 
   calculator_ui.Add(2.0, base::Bind(&base::DoNothing));
   calculator_ui.GetInterfacePtr().FlushForTesting();
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
 
   calculator_ui.Multiply(5.0, base::Bind(&base::DoNothing));
   calculator_ui.GetInterfacePtr().FlushForTesting();
 
   EXPECT_EQ(10.0, calculator_ui.GetOutput());
 }
 
 void SetBool(bool* value) {
   *value = true;
 }
 
 TEST_F(InterfacePtrTest, FlushForTestingWithClosedPeer) {
   math::CalculatorPtr calc;
-  GetProxy(&calc);
+  MakeRequest(&calc);
   bool called = false;
   calc.set_connection_error_handler(base::Bind(&SetBool, &called));
   calc.FlushForTesting();
   EXPECT_TRUE(called);
   calc.FlushForTesting();
 }
 
 TEST_F(InterfacePtrTest, ConnectionErrorWithReason) {
   math::CalculatorPtr calc;
-  MathCalculatorImpl calc_impl(GetProxy(&calc));
+  MathCalculatorImpl calc_impl(MakeRequest(&calc));
 
   base::RunLoop run_loop;
   calc.set_connection_error_with_reason_handler(base::Bind(
       [](const base::Closure& quit_closure, uint32_t custom_reason,
          const std::string& description) {
         EXPECT_EQ(42u, custom_reason);
         EXPECT_EQ("hey", description);
         quit_closure.Run();
       },
       run_loop.QuitClosure()));
 
   calc_impl.binding()->CloseWithReason(42u, "hey");
 
   run_loop.Run();
 }
 
 TEST_F(InterfacePtrTest, InterfaceRequestResetWithReason) {
   math::CalculatorPtr calc;
-  auto request = GetProxy(&calc);
+  auto request = MakeRequest(&calc);
 
   base::RunLoop run_loop;
   calc.set_connection_error_with_reason_handler(base::Bind(
       [](const base::Closure& quit_closure, uint32_t custom_reason,
          const std::string& description) {
         EXPECT_EQ(88u, custom_reason);
         EXPECT_EQ("greetings", description);
         quit_closure.Run();
       },
       run_loop.QuitClosure()));
 
   request.ResetWithReason(88u, "greetings");
 
   run_loop.Run();
 }
 
 TEST_F(InterfacePtrTest, CallbackOwnsInterfacePtr) {
   sample::PingTestPtr ptr;
-  sample::PingTestRequest request = GetProxy(&ptr);
+  sample::PingTestRequest request = MakeRequest(&ptr);
 
   base::RunLoop run_loop;
 
   // Make a call with the proxy's lifetime bound to the response callback.
   sample::PingTest* raw_proxy = ptr.get();
   ptr.set_connection_error_handler(run_loop.QuitClosure());
   raw_proxy->Ping(
       base::Bind([](sample::PingTestPtr ptr) {}, base::Passed(&ptr)));
 
   // Trigger an error on |ptr|. This will ultimately lead to the proxy's
   // response callbacks being destroyed, which will in turn lead to the proxy
   // being destroyed. This should not crash.
   request.PassMessagePipe();
   run_loop.Run();
 }
 
 TEST_F(InterfacePtrTest, ThreadSafeInterfacePointer) {
   math::CalculatorPtr ptr;
-  MathCalculatorImpl calc_impl(GetProxy(&ptr));
+  MathCalculatorImpl calc_impl(MakeRequest(&ptr));
   scoped_refptr<math::ThreadSafeCalculatorPtr> thread_safe_ptr =
       math::ThreadSafeCalculatorPtr::Create(std::move(ptr));
 
   base::RunLoop run_loop;
 
   // Create and start the thread from where we'll call the interface pointer.
   base::Thread other_thread("service test thread");
   other_thread.Start();
 
   auto run_method = base::Bind(
@@ skipping 37 matching lines @@
   MathCalculatorImpl* math_calc_impl = nullptr;
   {
     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<math::ThreadSafeCalculatorPtr>& thread_safe_ptr,
            MathCalculatorImpl** math_calc_impl) {
           math::CalculatorPtr ptr;
           // In real life, the implementation would have a legitimate owner.
-          *math_calc_impl = new MathCalculatorImpl(GetProxy(&ptr));
+          *math_calc_impl = new MathCalculatorImpl(MakeRequest(&ptr));
           thread_safe_ptr->Bind(std::move(ptr));
           main_task_runner->PostTask(FROM_HERE, quit_closure);
         },
         base::SequencedTaskRunnerHandle::Get(), run_loop.QuitClosure(),
         thread_safe_ptr, &math_calc_impl);
     other_thread.message_loop()->task_runner()->PostTask(FROM_HERE, run_method);
     run_loop.Run();
   }
 
   {
@@ skipping 13 matching lines @@
   other_thread_task_runner->DeleteSoon(FROM_HERE, math_calc_impl);
 
   // 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