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

content/browser/dom_storage/dom_storage_context_wrapper.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 "content/browser/dom_storage/dom_storage_context_wrapper.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 153 matching lines @@
                    weak_ptr_factory_.GetWeakPtr()));
     file_service_connection_->SetConnectionLostClosure(
         base::Bind(&MojoState::OnUserServiceConnectionError,
                    weak_ptr_factory_.GetWeakPtr()));
 
     if (!subdirectory_.empty()) {
       // We were given a subdirectory to write to. Get it and use a disk backed
       // database.
       file_service_connection_->GetInterface(&file_system_);
       file_system_->GetSubDirectory(subdirectory_.AsUTF8Unsafe(),
-                                    GetProxy(&directory_),
+                                    MakeRequest(&directory_),
                                     base::Bind(&MojoState::OnDirectoryOpened,
                                                weak_ptr_factory_.GetWeakPtr()));
     } else {
       // We were not given a subdirectory. Use a memory backed database.
       file_service_connection_->GetInterface(&leveldb_service_);
       leveldb_service_->OpenInMemory(
-          GetProxy(&database_),
-          base::Bind(&MojoState::OnDatabaseOpened,
-                     weak_ptr_factory_.GetWeakPtr()));
+          MakeRequest(&database_), base::Bind(&MojoState::OnDatabaseOpened,
+                                              weak_ptr_factory_.GetWeakPtr()));
     }
   }
 
   if (connection_state_ == CONNECTION_IN_PROGRESS) {
     // Queue this OpenLocalStorage call for when we have a level db pointer.
     on_database_opened_callbacks_.push_back(
         base::Bind(&MojoState::BindLocalStorage, weak_ptr_factory_.GetWeakPtr(),
                    origin, base::Passed(&observer), base::Passed(&request)));
     return;
   }
 
   BindLocalStorage(origin, std::move(observer), std::move(request));
 }
 
 void DOMStorageContextWrapper::MojoState::OnDirectoryOpened(
     filesystem::mojom::FileError err) {
   if (err != filesystem::mojom::FileError::OK) {
     // We failed to open the directory; continue with startup so that we create
     // the |level_db_wrappers_|.
     OnDatabaseOpened(leveldb::mojom::DatabaseError::IO_ERROR);
     return;
   }
 
   // Now that we have a directory, connect to the LevelDB service and get our
   // database.
   file_service_connection_->GetInterface(&leveldb_service_);
 
   leveldb_service_->Open(
-      std::move(directory_), "leveldb", GetProxy(&database_),
+      std::move(directory_), "leveldb", MakeRequest(&database_),
       base::Bind(&MojoState::OnDatabaseOpened, weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DOMStorageContextWrapper::MojoState::OnDatabaseOpened(
     leveldb::mojom::DatabaseError status) {
   if (status != leveldb::mojom::DatabaseError::OK) {
     // If we failed to open the database, reset the service object so we pass
     // null pointers to our wrappers.
     database_.reset();
     leveldb_service_.reset();
@@ skipping 239 matching lines @@
 }
 
 void DOMStorageContextWrapper::PurgeMemory(DOMStorageContextImpl::PurgeOption
     purge_option) {
   context_->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&DOMStorageContextImpl::PurgeMemory, context_, purge_option));
 }
 
 }  // namespace content