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

device/serial/serial_service_unittest.cc

 // Copyright 2014 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/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 68 matching lines @@
     if (!io_handler_.get())
       io_handler_ = new TestSerialIoHandler;
     mojo::InterfacePtr<serial::SerialService> service;
     mojo::MakeStrongBinding(
         base::MakeUnique<SerialServiceImpl>(
             new SerialConnectionFactory(
                 base::Bind(&SerialServiceTest::ReturnIoHandler,
                            base::Unretained(this)),
                 base::ThreadTaskRunnerHandle::Get()),
             base::MakeUnique<FakeSerialDeviceEnumerator>()),
-        mojo::GetProxy(&service));
+        mojo::MakeRequest(&service));
     mojo::InterfacePtr<serial::Connection> connection;
     mojo::InterfacePtr<serial::DataSink> sink;
     mojo::InterfacePtr<serial::DataSource> source;
     mojo::InterfacePtr<serial::DataSourceClient> source_client;
-    mojo::GetProxy(&source_client);
+    mojo::MakeRequest(&source_client);
     service->Connect(path, serial::ConnectionOptions::New(),
-                     mojo::GetProxy(&connection), mojo::GetProxy(&sink),
-                     mojo::GetProxy(&source), std::move(source_client));
+                     mojo::MakeRequest(&connection), mojo::MakeRequest(&sink),
+                     mojo::MakeRequest(&source), std::move(source_client));
     connection.set_connection_error_handler(base::Bind(
         &SerialServiceTest::OnConnectionError, base::Unretained(this)));
     expecting_error_ = !expecting_success;
     connection->GetInfo(
         base::Bind(&SerialServiceTest::OnGotInfo, base::Unretained(this)));
     RunMessageLoop();
     EXPECT_EQ(!expecting_success, connection.encountered_error());
     EXPECT_EQ(expecting_success, connected_);
     connection.reset();
   }
 
   base::MessageLoop message_loop_;
   std::unique_ptr<base::RunLoop> run_loop_;
   mojo::Array<serial::DeviceInfoPtr> devices_;
   scoped_refptr<TestSerialIoHandler> io_handler_;
   bool connected_;
   bool expecting_error_;
   serial::ConnectionInfoPtr info_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SerialServiceTest);
 };
 
 TEST_F(SerialServiceTest, GetDevices) {
   mojo::InterfacePtr<serial::SerialService> service;
-  SerialServiceImpl::Create(NULL, NULL, mojo::GetProxy(&service));
+  SerialServiceImpl::Create(NULL, NULL, mojo::MakeRequest(&service));
   service.set_connection_error_handler(base::Bind(
       &SerialServiceTest::OnConnectionError, base::Unretained(this)));
   mojo::Array<serial::DeviceInfoPtr> result;
   service->GetDevices(
       base::Bind(&SerialServiceTest::StoreDevices, base::Unretained(this)));
   RunMessageLoop();
 
   // Because we're running on unknown hardware, only check that we received a
   // non-null result.
   EXPECT_TRUE(devices_);
 }
 
 TEST_F(SerialServiceTest, Connect) {
   RunConnectTest("device", true);
 }
 
 TEST_F(SerialServiceTest, ConnectInvalidPath) {
   RunConnectTest("invalid_path", false);
 }
 
 TEST_F(SerialServiceTest, ConnectOpenFailed) {
   io_handler_ = new FailToOpenIoHandler;
   RunConnectTest("device", false);
 }
 
 }  // namespace device