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

components/leveldb/leveldb_service_unittest.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 "base/bind.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "components/filesystem/public/interfaces/directory.mojom.h"
 #include "components/filesystem/public/interfaces/file_system.mojom.h"
 #include "components/filesystem/public/interfaces/types.mojom.h"
@@ skipping 108 matching lines @@
   void TearDown() override {
     leveldb_.reset();
     files_.reset();
     ServiceTest::TearDown();
   }
 
   // Note: This has an out parameter rather than returning the |DirectoryPtr|,
   // since |ASSERT_...()| doesn't work with return values.
   void GetTempDirectory(filesystem::mojom::DirectoryPtr* directory) {
     FileError error = FileError::FAILED;
-    bool handled = files()->OpenTempDirectory(GetProxy(directory), &error);
+    bool handled = files()->OpenTempDirectory(MakeRequest(directory), &error);
     ASSERT_TRUE(handled);
     ASSERT_EQ(FileError::OK, error);
   }
 
   filesystem::mojom::FileSystemPtr& files() { return files_; }
   mojom::LevelDBServicePtr& leveldb() { return leveldb_; }
 
  private:
   filesystem::mojom::FileSystemPtr files_;
   mojom::LevelDBServicePtr leveldb_;
 
   DISALLOW_COPY_AND_ASSIGN(LevelDBServiceTest);
 };
 
 TEST_F(LevelDBServiceTest, Basic) {
   mojom::DatabaseError error;
   mojom::LevelDBDatabasePtr database;
-  LevelDBSyncOpenInMemory(leveldb().get(), GetProxy(&database), &error);
+  LevelDBSyncOpenInMemory(leveldb().get(), MakeRequest(&database), &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Write a key to the database.
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   DatabaseSyncPut(database.get(), "key", "value", &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Read the key back from the database.
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   std::vector<uint8_t> value;
@@ skipping 13 matching lines @@
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   value.clear();
   DatabaseSyncGet(database.get(), "key", &error, &value);
   EXPECT_EQ(mojom::DatabaseError::NOT_FOUND, error);
   EXPECT_EQ("", Uint8VectorToStdString(value));
 }
 
 TEST_F(LevelDBServiceTest, WriteBatch) {
   mojom::DatabaseError error;
   mojom::LevelDBDatabasePtr database;
-  LevelDBSyncOpenInMemory(leveldb().get(), GetProxy(&database), &error);
+  LevelDBSyncOpenInMemory(leveldb().get(), MakeRequest(&database), &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Write a key to the database.
   DatabaseSyncPut(database.get(), "key", "value", &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Create a batched operation which both deletes "key" and adds another write.
   std::vector<mojom::BatchedOperationPtr> operations;
   mojom::BatchedOperationPtr item = mojom::BatchedOperation::New();
   item->type = mojom::BatchOperationType::DELETE_KEY;
@@ skipping 58 matching lines @@
 }
 
 TEST_F(LevelDBServiceTest, Reconnect) {
   mojom::DatabaseError error;
 
   filesystem::mojom::DirectoryPtr temp_directory;
   GetTempDirectory(&temp_directory);
 
   {
     filesystem::mojom::DirectoryPtr directory;
-    temp_directory->Clone(GetProxy(&directory));
+    temp_directory->Clone(MakeRequest(&directory));
 
     mojom::LevelDBDatabasePtr database;
     leveldb::mojom::OpenOptionsPtr options = leveldb::mojom::OpenOptions::New();
     options->error_if_exists = true;
     options->create_if_missing = true;
     base::RunLoop run_loop;
     leveldb()->OpenWithOptions(std::move(options), std::move(directory), "test",
-                               GetProxy(&database),
+                               MakeRequest(&database),
                                Capture(&error, run_loop.QuitClosure()));
     run_loop.Run();
     EXPECT_EQ(mojom::DatabaseError::OK, error);
 
     // Write a key to the database.
     error = mojom::DatabaseError::INVALID_ARGUMENT;
     DatabaseSyncPut(database.get(), "key", "value", &error);
     EXPECT_EQ(mojom::DatabaseError::OK, error);
 
     // The database should go out of scope here.
   }
 
   {
     filesystem::mojom::DirectoryPtr directory;
-    temp_directory->Clone(GetProxy(&directory));
+    temp_directory->Clone(MakeRequest(&directory));
 
     // Reconnect to the database.
     mojom::LevelDBDatabasePtr database;
     base::RunLoop run_loop;
-    leveldb()->Open(std::move(directory), "test", GetProxy(&database),
+    leveldb()->Open(std::move(directory), "test", MakeRequest(&database),
                     Capture(&error, run_loop.QuitClosure()));
     run_loop.Run();
     EXPECT_EQ(mojom::DatabaseError::OK, error);
 
     // We should still be able to read the key back from the database.
     error = mojom::DatabaseError::INVALID_ARGUMENT;
     std::vector<uint8_t> value;
     DatabaseSyncGet(database.get(), "key", &error, &value);
     EXPECT_EQ(mojom::DatabaseError::OK, error);
     EXPECT_EQ("value", Uint8VectorToStdString(value));
   }
 }
 
 TEST_F(LevelDBServiceTest, GetSnapshotSimple) {
   mojom::DatabaseError error;
   mojom::LevelDBDatabasePtr database;
-  LevelDBSyncOpenInMemory(leveldb().get(), GetProxy(&database), &error);
+  LevelDBSyncOpenInMemory(leveldb().get(), MakeRequest(&database), &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   base::UnguessableToken snapshot;
   base::RunLoop run_loop;
   database->GetSnapshot(CaptureConstRef(&snapshot, run_loop.QuitClosure()));
   run_loop.Run();
   EXPECT_FALSE(snapshot.is_empty());
 }
 
 TEST_F(LevelDBServiceTest, GetFromSnapshots) {
   mojom::DatabaseError error;
   mojom::LevelDBDatabasePtr database;
-  LevelDBSyncOpenInMemory(leveldb().get(), GetProxy(&database), &error);
+  LevelDBSyncOpenInMemory(leveldb().get(), MakeRequest(&database), &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Write a key to the database.
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   DatabaseSyncPut(database.get(), "key", "value", &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Take a snapshot where key=value.
   base::UnguessableToken key_value_snapshot;
   base::RunLoop run_loop;
@@ skipping 21 matching lines @@
       key_value_snapshot, StdStringToUint8Vector("key"),
       CaptureConstRef(&error, &value, run_loop2.QuitClosure()));
   run_loop2.Run();
   EXPECT_EQ(mojom::DatabaseError::OK, error);
   EXPECT_EQ("value", Uint8VectorToStdString(value));
 }
 
 TEST_F(LevelDBServiceTest, InvalidArgumentOnInvalidSnapshot) {
   mojom::LevelDBDatabasePtr database;
   mojom::DatabaseError error = mojom::DatabaseError::INVALID_ARGUMENT;
-  LevelDBSyncOpenInMemory(leveldb().get(), GetProxy(&database), &error);
+  LevelDBSyncOpenInMemory(leveldb().get(), MakeRequest(&database), &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   base::UnguessableToken invalid_snapshot = base::UnguessableToken::Create();
 
   error = mojom::DatabaseError::OK;
   std::vector<uint8_t> value;
   base::RunLoop run_loop;
   database->GetFromSnapshot(
       invalid_snapshot, StdStringToUint8Vector("key"),
       CaptureConstRef(&error, &value, run_loop.QuitClosure()));
   run_loop.Run();
   EXPECT_EQ(mojom::DatabaseError::INVALID_ARGUMENT, error);
 }
 
 TEST_F(LevelDBServiceTest, MemoryDBReadWrite) {
   mojom::LevelDBDatabasePtr database;
   mojom::DatabaseError error = mojom::DatabaseError::INVALID_ARGUMENT;
-  LevelDBSyncOpenInMemory(leveldb().get(), GetProxy(&database), &error);
+  LevelDBSyncOpenInMemory(leveldb().get(), MakeRequest(&database), &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Write a key to the database.
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   DatabaseSyncPut(database.get(), "key", "value", &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   // Read the key back from the database.
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   std::vector<uint8_t> value;
@@ skipping 14 matching lines @@
   value.clear();
   DatabaseSyncGet(database.get(), "key", &error, &value);
   EXPECT_EQ(mojom::DatabaseError::NOT_FOUND, error);
   EXPECT_EQ("", Uint8VectorToStdString(value));
 }
 
 TEST_F(LevelDBServiceTest, Prefixed) {
   // Open an in memory database for speed.
   mojom::DatabaseError error = mojom::DatabaseError::INVALID_ARGUMENT;
   mojom::LevelDBDatabasePtr database;
-  LevelDBSyncOpenInMemory(leveldb().get(), GetProxy(&database), &error);
+  LevelDBSyncOpenInMemory(leveldb().get(), MakeRequest(&database), &error);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
 
   const std::string prefix("prefix");
   std::vector<mojom::KeyValuePtr> key_values;
 
   // Completely empty database.
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   DatabaseSyncGetPrefixed(database.get(), prefix, &error, &key_values);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
   EXPECT_TRUE(key_values.empty());
@@ skipping 73 matching lines @@
   EXPECT_EQ(mojom::DatabaseError::OK, error);
   error = mojom::DatabaseError::INVALID_ARGUMENT;
   key_values.clear();
   DatabaseSyncGetPrefixed(database.get(), prefix, &error, &key_values);
   EXPECT_EQ(mojom::DatabaseError::OK, error);
   EXPECT_TRUE(key_values.empty());
 }
 
 }  // namespace
 }  // namespace leveldb