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

mojo/public/cpp/bindings/tests/handle_passing_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/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/binding.h"
@@ skipping 182 matching lines @@
               std::string* got_text_reply,
               const base::Closure& closure,
               const std::string& text_reply) {
   *got_response = true;
   *got_text_reply = text_reply;
   closure.Run();
 }
 
 TEST_F(HandlePassingTest, Basic) {
   sample::FactoryPtr factory;
-  SampleFactoryImpl factory_impl(GetProxy(&factory));
+  SampleFactoryImpl factory_impl(MakeRequest(&factory));
 
   MessagePipe pipe0;
   EXPECT_TRUE(WriteTextMessage(pipe0.handle1.get(), kText1));
 
   MessagePipe pipe1;
   EXPECT_TRUE(WriteTextMessage(pipe1.handle1.get(), kText2));
 
   imported::ImportedInterfacePtr imported;
   base::RunLoop run_loop;
-  ImportedInterfaceImpl imported_impl(GetProxy(&imported),
+  ImportedInterfaceImpl imported_impl(MakeRequest(&imported),
                                       run_loop.QuitClosure());
 
   sample::RequestPtr request(sample::Request::New());
   request->x = 1;
   request->pipe = std::move(pipe1.handle0);
   request->obj = std::move(imported);
   bool got_response = false;
   std::string got_text_reply;
   base::RunLoop run_loop2;
   factory->DoStuff(std::move(request), std::move(pipe0.handle0),
                    base::Bind(&DoStuff, &got_response, &got_text_reply,
                               run_loop2.QuitClosure()));
 
   EXPECT_FALSE(got_response);
   int count_before = ImportedInterfaceImpl::do_something_count();
 
   run_loop.Run();
   run_loop2.Run();
 
   EXPECT_TRUE(got_response);
   EXPECT_EQ(kText1, got_text_reply);
   EXPECT_EQ(1, ImportedInterfaceImpl::do_something_count() - count_before);
 }
 
 TEST_F(HandlePassingTest, PassInvalid) {
   sample::FactoryPtr factory;
-  SampleFactoryImpl factory_impl(GetProxy(&factory));
+  SampleFactoryImpl factory_impl(MakeRequest(&factory));
 
   sample::RequestPtr request(sample::Request::New());
   request->x = 1;
   bool got_response = false;
   std::string got_text_reply;
   base::RunLoop run_loop;
   factory->DoStuff(std::move(request), ScopedMessagePipeHandle(),
                    base::Bind(&DoStuff, &got_response, &got_text_reply,
                               run_loop.QuitClosure()));
 
   EXPECT_FALSE(got_response);
 
   run_loop.Run();
 
   EXPECT_TRUE(got_response);
 }
 
 // Verifies DataPipeConsumer can be passed and read from.
 TEST_F(HandlePassingTest, DataPipe) {
   sample::FactoryPtr factory;
-  SampleFactoryImpl factory_impl(GetProxy(&factory));
+  SampleFactoryImpl factory_impl(MakeRequest(&factory));
 
   // Writes a string to a data pipe and passes the data pipe (consumer) to the
   // factory.
   ScopedDataPipeProducerHandle producer_handle;
   ScopedDataPipeConsumerHandle consumer_handle;
   MojoCreateDataPipeOptions options = {sizeof(MojoCreateDataPipeOptions),
                                        MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,
                                        1,
                                        1024};
   ASSERT_EQ(MOJO_RESULT_OK,
@@ skipping 17 matching lines @@
   EXPECT_FALSE(got_response);
 
   run_loop.Run();
 
   EXPECT_TRUE(got_response);
   EXPECT_EQ(expected_text_reply, got_text_reply);
 }
 
 TEST_F(HandlePassingTest, PipesAreClosed) {
   sample::FactoryPtr factory;
-  SampleFactoryImpl factory_impl(GetProxy(&factory));
+  SampleFactoryImpl factory_impl(MakeRequest(&factory));
 
   MessagePipe extra_pipe;
 
   MojoHandle handle0_value = extra_pipe.handle0.get().value();
   MojoHandle handle1_value = extra_pipe.handle1.get().value();
 
   {
     std::vector<ScopedMessagePipeHandle> pipes(2);
     pipes[0] = std::move(extra_pipe.handle0);
     pipes[1] = std::move(extra_pipe.handle1);
 
     sample::RequestPtr request(sample::Request::New());
     request->more_pipes = std::move(pipes);
 
     factory->DoStuff(std::move(request), ScopedMessagePipeHandle(),
                      sample::Factory::DoStuffCallback());
   }
 
   // We expect the pipes to have been closed.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(handle0_value));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(handle1_value));
 }
 
 TEST_F(HandlePassingTest, CreateNamedObject) {
   sample::FactoryPtr factory;
-  SampleFactoryImpl factory_impl(GetProxy(&factory));
+  SampleFactoryImpl factory_impl(MakeRequest(&factory));
 
   sample::NamedObjectPtr object1;
   EXPECT_FALSE(object1);
 
-  InterfaceRequest<sample::NamedObject> object1_request = GetProxy(&object1);
+  InterfaceRequest<sample::NamedObject> object1_request = MakeRequest(&object1);
   EXPECT_TRUE(object1_request.is_pending());
   factory->CreateNamedObject(std::move(object1_request));
   EXPECT_FALSE(object1_request.is_pending());  // We've passed the request.
 
   ASSERT_TRUE(object1);
   object1->SetName("object1");
 
   sample::NamedObjectPtr object2;
-  factory->CreateNamedObject(GetProxy(&object2));
+  factory->CreateNamedObject(MakeRequest(&object2));
   object2->SetName("object2");
 
   base::RunLoop run_loop, run_loop2;
   std::string name1;
   object1->GetName(MakeStringRecorder(&name1, run_loop.QuitClosure()));
 
   std::string name2;
   object2->GetName(MakeStringRecorder(&name2, run_loop2.QuitClosure()));
 
   run_loop.Run();
   run_loop2.Run();
 
   EXPECT_EQ(std::string("object1"), name1);
   EXPECT_EQ(std::string("object2"), name2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo