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

services/service_manager/public/cpp/lib/connector_impl.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 "services/service_manager/public/cpp/lib/connector_impl.h"
 
 #include "base/memory/ptr_util.h"
 #include "services/service_manager/public/cpp/identity.h"
 #include "services/service_manager/public/cpp/lib/connection_impl.h"
 
@@ skipping 31 matching lines @@
 }
 
 std::unique_ptr<Connection> ConnectorImpl::Connect(ConnectParams* params) {
   if (!BindIfNecessary())
     return nullptr;
 
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(params);
 
   mojom::InterfaceProviderPtr remote_interfaces;
-  mojom::InterfaceProviderRequest remote_request = GetProxy(&remote_interfaces);
+  mojom::InterfaceProviderRequest remote_request =
+      MakeRequest(&remote_interfaces);
   std::unique_ptr<internal::ConnectionImpl> connection(
       new internal::ConnectionImpl(params->target(),
                                    Connection::State::PENDING));
   if (params->remote_interfaces()) {
     params->remote_interfaces()->Bind(std::move(remote_interfaces));
     connection->set_remote_interfaces(params->remote_interfaces());
   } else {
     std::unique_ptr<InterfaceProvider> remote_interface_provider(
         new InterfaceProvider);
     remote_interface_provider->Bind(std::move(remote_interfaces));
@@ skipping 19 matching lines @@
                       std::move(client_process_connection),
                       connection->GetConnectCallback());
   return std::move(connection);
 }
 
 std::unique_ptr<Connector> ConnectorImpl::Clone() {
   if (!BindIfNecessary())
     return nullptr;
 
   mojom::ConnectorPtr connector;
-  mojom::ConnectorRequest request = GetProxy(&connector);
+  mojom::ConnectorRequest request = MakeRequest(&connector);
   connector_->Clone(std::move(request));
   return base::MakeUnique<ConnectorImpl>(connector.PassInterface());
 }
 
 void ConnectorImpl::BindRequest(mojom::ConnectorRequest request) {
   if (!BindIfNecessary())
     return;
   connector_->Clone(std::move(request));
 }
 
@@ skipping 15 matching lines @@
     connector_.Bind(std::move(unbound_state_));
     connector_.set_connection_error_handler(
         base::Bind(&ConnectorImpl::OnConnectionError, base::Unretained(this)));
   }
 
   return true;
 }
 
 std::unique_ptr<Connector> Connector::Create(mojom::ConnectorRequest* request) {
   mojom::ConnectorPtr proxy;
-  *request = mojo::GetProxy(&proxy);
+  *request = mojo::MakeRequest(&proxy);
   return base::MakeUnique<ConnectorImpl>(proxy.PassInterface());
 }
 
 }  // namespace service_manager