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

components/filesystem/file_impl_unittest.cc

 // Copyright 2015 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 <stddef.h>
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
 #include "base/files/file.h"
@@ skipping 10 matching lines @@
   mojom::DirectoryPtr directory;
   GetTemporaryRoot(&directory);
   mojom::FileError error;
   bool handled = false;
 
   {
     // Create my_file.
     mojom::FilePtr file;
     error = mojom::FileError::FAILED;
     handled =
-        directory->OpenFile("my_file", GetProxy(&file),
+        directory->OpenFile("my_file", MakeRequest(&file),
                             mojom::kFlagWrite | mojom::kFlagCreate, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     // Write to it.
     std::vector<uint8_t> bytes_to_write;
     bytes_to_write.push_back(static_cast<uint8_t>('h'));
     bytes_to_write.push_back(static_cast<uint8_t>('e'));
     bytes_to_write.push_back(static_cast<uint8_t>('l'));
     bytes_to_write.push_back(static_cast<uint8_t>('l'));
@@ skipping 17 matching lines @@
   error = mojom::FileError::FAILED;
   handled = directory->Rename("my_file", "your_file", &error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::OK, error);
 
   {
     // Open my_file again.
     mojom::FilePtr file;
     error = mojom::FileError::FAILED;
     bool handled =
-        directory->OpenFile("your_file", GetProxy(&file),
+        directory->OpenFile("your_file", MakeRequest(&file),
                             mojom::kFlagRead | mojom::kFlagOpen, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     // Read from it.
     base::Optional<std::vector<uint8_t>> bytes_read;
     error = mojom::FileError::FAILED;
     handled = file->Read(3, 1, mojom::Whence::FROM_BEGIN, &error, &bytes_read);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
@@ skipping 17 matching lines @@
   bytes_to_write.push_back(static_cast<uint8_t>('e'));
   bytes_to_write.push_back(static_cast<uint8_t>('l'));
   bytes_to_write.push_back(static_cast<uint8_t>('l'));
   bytes_to_write.push_back(static_cast<uint8_t>('o'));
 
   {
     // Create my_file.
     mojom::FilePtr file;
     error = mojom::FileError::FAILED;
     bool handled =
-        directory->OpenFile("my_file", GetProxy(&file),
+        directory->OpenFile("my_file", MakeRequest(&file),
                             mojom::kFlagWrite | mojom::kFlagCreate, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     // Write to it.
     error = mojom::FileError::FAILED;
     uint32_t num_bytes_written = 0;
     handled = file->Write(bytes_to_write, 0, mojom::Whence::FROM_CURRENT,
                           &error, &num_bytes_written);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
     EXPECT_EQ(bytes_to_write.size(), num_bytes_written);
 
     // Close it.
     error = mojom::FileError::FAILED;
     handled = file->Close((&error));
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
   }
 
   {
     // Open my_file again, this time with read only mode.
     mojom::FilePtr file;
     error = mojom::FileError::FAILED;
     bool handled =
-        directory->OpenFile("my_file", GetProxy(&file),
+        directory->OpenFile("my_file", MakeRequest(&file),
                             mojom::kFlagRead | mojom::kFlagOpen, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     // Try to write in read mode; it should fail.
     error = mojom::FileError::OK;
     uint32_t num_bytes_written = 0;
     handled = file->Write(bytes_to_write, 0, mojom::Whence::FROM_CURRENT,
                           &error, &num_bytes_written);
 
@@ skipping 12 matching lines @@
 TEST_F(FileImplTest, OpenInAppendMode) {
   mojom::DirectoryPtr directory;
   GetTemporaryRoot(&directory);
   mojom::FileError error;
 
   {
     // Create my_file.
     mojom::FilePtr file;
     error = mojom::FileError::FAILED;
     bool handled =
-        directory->OpenFile("my_file", GetProxy(&file),
+        directory->OpenFile("my_file", MakeRequest(&file),
                             mojom::kFlagWrite | mojom::kFlagCreate, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     // Write to it.
     std::vector<uint8_t> bytes_to_write;
     bytes_to_write.push_back(static_cast<uint8_t>('h'));
     bytes_to_write.push_back(static_cast<uint8_t>('e'));
     bytes_to_write.push_back(static_cast<uint8_t>('l'));
     bytes_to_write.push_back(static_cast<uint8_t>('l'));
@@ skipping 11 matching lines @@
     handled = file->Close(&error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
   }
 
   {
     // Append to my_file.
     mojom::FilePtr file;
     error = mojom::FileError::FAILED;
     bool handled =
-        directory->OpenFile("my_file", GetProxy(&file),
+        directory->OpenFile("my_file", MakeRequest(&file),
                             mojom::kFlagAppend | mojom::kFlagOpen, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     // Write to it.
     std::vector<uint8_t> bytes_to_write;
     bytes_to_write.push_back(static_cast<uint8_t>('g'));
     bytes_to_write.push_back(static_cast<uint8_t>('o'));
     bytes_to_write.push_back(static_cast<uint8_t>('o'));
     bytes_to_write.push_back(static_cast<uint8_t>('d'));
@@ skipping 13 matching lines @@
     handled = file->Close((&error));
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
   }
 
   {
     // Open my_file again.
     mojom::FilePtr file;
     error = mojom::FileError::FAILED;
     bool handled =
-        directory->OpenFile("my_file", GetProxy(&file),
+        directory->OpenFile("my_file", MakeRequest(&file),
                             mojom::kFlagRead | mojom::kFlagOpen, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     // Read from it.
     base::Optional<std::vector<uint8_t>> bytes_read;
     error = mojom::FileError::FAILED;
     handled = file->Read(12, 0, mojom::Whence::FROM_BEGIN, &error, &bytes_read);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
     ASSERT_TRUE(bytes_read.has_value());
     ASSERT_EQ(12u, bytes_read.value().size());
     EXPECT_EQ(static_cast<uint8_t>('l'), bytes_read.value()[3]);
     EXPECT_EQ(static_cast<uint8_t>('o'), bytes_read.value()[4]);
     EXPECT_EQ(static_cast<uint8_t>('g'), bytes_read.value()[5]);
     EXPECT_EQ(static_cast<uint8_t>('o'), bytes_read.value()[6]);
   }
 }
 
 TEST_F(FileImplTest, OpenInTruncateMode) {
   mojom::DirectoryPtr directory;
   GetTemporaryRoot(&directory);
   mojom::FileError error;
 
   {
     // Create my_file.
     mojom::FilePtr file;
     error = mojom::FileError::FAILED;
     bool handled =
-        directory->OpenFile("my_file", GetProxy(&file),
+        directory->OpenFile("my_file", MakeRequest(&file),
                             mojom::kFlagWrite | mojom::kFlagCreate, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     // Write to it.
     std::vector<uint8_t> bytes_to_write;
     bytes_to_write.push_back(static_cast<uint8_t>('h'));
     bytes_to_write.push_back(static_cast<uint8_t>('e'));
     bytes_to_write.push_back(static_cast<uint8_t>('l'));
     bytes_to_write.push_back(static_cast<uint8_t>('l'));
@@ skipping 11 matching lines @@
     handled = file->Close(&error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
   }
 
   {
     // Append to my_file.
     mojom::FilePtr file;
     error = mojom::FileError::FAILED;
     bool handled = directory->OpenFile(
-        "my_file", GetProxy(&file),
+        "my_file", MakeRequest(&file),
         mojom::kFlagWrite | mojom::kFlagOpenTruncated, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     // Write to it.
     std::vector<uint8_t> bytes_to_write;
     bytes_to_write.push_back(static_cast<uint8_t>('g'));
     bytes_to_write.push_back(static_cast<uint8_t>('o'));
     bytes_to_write.push_back(static_cast<uint8_t>('o'));
     bytes_to_write.push_back(static_cast<uint8_t>('d'));
@@ skipping 13 matching lines @@
     handled = file->Close(&error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
   }
 
   {
     // Open my_file again.
     mojom::FilePtr file;
     error = mojom::FileError::FAILED;
     bool handled =
-        directory->OpenFile("my_file", GetProxy(&file),
+        directory->OpenFile("my_file", MakeRequest(&file),
                             mojom::kFlagRead | mojom::kFlagOpen, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     // Read from it.
     base::Optional<std::vector<uint8_t>> bytes_read;
     error = mojom::FileError::FAILED;
     handled = file->Read(7, 0, mojom::Whence::FROM_BEGIN, &error, &bytes_read);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
@@ skipping 10 matching lines @@
 // least second-resolution support though.
 TEST_F(FileImplTest, StatTouch) {
   mojom::DirectoryPtr directory;
   GetTemporaryRoot(&directory);
   mojom::FileError error;
 
   // Create my_file.
   mojom::FilePtr file;
   error = mojom::FileError::FAILED;
   bool handled =
-      directory->OpenFile("my_file", GetProxy(&file),
+      directory->OpenFile("my_file", MakeRequest(&file),
                           mojom::kFlagWrite | mojom::kFlagCreate, &error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::OK, error);
 
   // Stat it.
   error = mojom::FileError::FAILED;
   mojom::FileInformationPtr file_info;
   handled = file->Stat(&error, &file_info);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::OK, error);
@@ skipping 50 matching lines @@
 
 TEST_F(FileImplTest, TellSeek) {
   mojom::DirectoryPtr directory;
   GetTemporaryRoot(&directory);
   mojom::FileError error;
 
   // Create my_file.
   mojom::FilePtr file;
   error = mojom::FileError::FAILED;
   bool handled =
-      directory->OpenFile("my_file", GetProxy(&file),
+      directory->OpenFile("my_file", MakeRequest(&file),
                           mojom::kFlagWrite | mojom::kFlagCreate, &error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::OK, error);
 
   // Write to it.
   std::vector<uint8_t> bytes_to_write(1000, '!');
   error = mojom::FileError::FAILED;
   uint32_t num_bytes_written = 0;
   handled = file->Write(bytes_to_write, 0, mojom::Whence::FROM_CURRENT, &error,
                         &num_bytes_written);
@@ skipping 65 matching lines @@
 
 TEST_F(FileImplTest, Dup) {
   mojom::DirectoryPtr directory;
   GetTemporaryRoot(&directory);
   mojom::FileError error;
 
   // Create my_file.
   mojom::FilePtr file1;
   error = mojom::FileError::FAILED;
   bool handled = directory->OpenFile(
-      "my_file", GetProxy(&file1),
+      "my_file", MakeRequest(&file1),
       mojom::kFlagRead | mojom::kFlagWrite | mojom::kFlagCreate, &error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::OK, error);
 
   // Write to it.
   std::vector<uint8_t> bytes_to_write;
   bytes_to_write.push_back(static_cast<uint8_t>('h'));
   bytes_to_write.push_back(static_cast<uint8_t>('e'));
   bytes_to_write.push_back(static_cast<uint8_t>('l'));
   bytes_to_write.push_back(static_cast<uint8_t>('l'));
   bytes_to_write.push_back(static_cast<uint8_t>('o'));
   error = mojom::FileError::FAILED;
   uint32_t num_bytes_written = 0;
   handled = file1->Write(bytes_to_write, 0, mojom::Whence::FROM_CURRENT, &error,
                          &num_bytes_written);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::OK, error);
   EXPECT_EQ(bytes_to_write.size(), num_bytes_written);
   const int end_hello_pos = static_cast<int>(num_bytes_written);
 
   // Dup it.
   mojom::FilePtr file2;
   error = mojom::FileError::FAILED;
-  handled = file1->Dup(GetProxy(&file2), &error);
+  handled = file1->Dup(MakeRequest(&file2), &error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::OK, error);
 
   // |file2| should have the same position.
   error = mojom::FileError::FAILED;
   int64_t position = -1;
   handled = file2->Tell(&error, &position);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::OK, error);
   EXPECT_EQ(end_hello_pos, position);
@@ skipping 49 matching lines @@
   const uint32_t kTruncatedSize = 654;
 
   mojom::DirectoryPtr directory;
   GetTemporaryRoot(&directory);
   mojom::FileError error;
 
   // Create my_file.
   mojom::FilePtr file;
   error = mojom::FileError::FAILED;
   bool handled =
-      directory->OpenFile("my_file", GetProxy(&file),
+      directory->OpenFile("my_file", MakeRequest(&file),
                           mojom::kFlagWrite | mojom::kFlagCreate, &error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::OK, error);
 
   // Write to it.
   std::vector<uint8_t> bytes_to_write(kInitialSize, '!');
   error = mojom::FileError::FAILED;
   uint32_t num_bytes_written = 0;
   handled = file->Write(bytes_to_write, 0, mojom::Whence::FROM_CURRENT, &error,
                         &num_bytes_written);
@@ skipping 29 matching lines @@
 TEST_F(FileImplTest, AsHandle) {
   mojom::DirectoryPtr directory;
   GetTemporaryRoot(&directory);
   mojom::FileError error;
 
   {
     // Create my_file.
     mojom::FilePtr file1;
     error = mojom::FileError::FAILED;
     bool handled = directory->OpenFile(
-        "my_file", GetProxy(&file1),
+        "my_file", MakeRequest(&file1),
         mojom::kFlagRead | mojom::kFlagWrite | mojom::kFlagCreate, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     // Fetch the file.
     error = mojom::FileError::FAILED;
     base::File raw_file;
     handled = file1->AsHandle(&error, &raw_file);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     ASSERT_TRUE(raw_file.IsValid());
     EXPECT_EQ(5, raw_file.WriteAtCurrentPos("hello", 5));
   }
 
   {
     // Reopen my_file.
     mojom::FilePtr file2;
     error = mojom::FileError::FAILED;
     bool handled =
-        directory->OpenFile("my_file", GetProxy(&file2),
+        directory->OpenFile("my_file", MakeRequest(&file2),
                             mojom::kFlagRead | mojom::kFlagOpen, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     // Verify that we wrote data raw on the file descriptor.
     base::Optional<std::vector<uint8_t>> bytes_read;
     error = mojom::FileError::FAILED;
     handled = file2->Read(5, 0, mojom::Whence::FROM_BEGIN, &error, &bytes_read);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
     ASSERT_TRUE(bytes_read.has_value());
     ASSERT_EQ(5u, bytes_read.value().size());
     EXPECT_EQ(static_cast<uint8_t>('h'), bytes_read.value()[0]);
     EXPECT_EQ(static_cast<uint8_t>('e'), bytes_read.value()[1]);
     EXPECT_EQ(static_cast<uint8_t>('l'), bytes_read.value()[2]);
     EXPECT_EQ(static_cast<uint8_t>('l'), bytes_read.value()[3]);
     EXPECT_EQ(static_cast<uint8_t>('o'), bytes_read.value()[4]);
   }
 }
 
 TEST_F(FileImplTest, SimpleLockUnlock) {
   mojom::DirectoryPtr directory;
   GetTemporaryRoot(&directory);
   mojom::FileError error;
 
   // Create my_file.
   mojom::FilePtr file;
   error = mojom::FileError::FAILED;
   bool handled = directory->OpenFile(
-      "my_file", GetProxy(&file),
+      "my_file", MakeRequest(&file),
       mojom::kFlagRead | mojom::kFlagWrite | mojom::kFlagCreate, &error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::OK, error);
 
   // Lock the file.
   error = mojom::FileError::FAILED;
   handled = file->Lock(&error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::OK, error);
 
   // Unlock the file.
   error = mojom::FileError::FAILED;
   handled = file->Unlock(&error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::OK, error);
 }
 
 TEST_F(FileImplTest, CantDoubleLock) {
   mojom::DirectoryPtr directory;
   GetTemporaryRoot(&directory);
   mojom::FileError error;
 
   // Create my_file.
   mojom::FilePtr file;
   error = mojom::FileError::FAILED;
   bool handled = directory->OpenFile(
-      "my_file", GetProxy(&file),
+      "my_file", MakeRequest(&file),
       mojom::kFlagRead | mojom::kFlagWrite | mojom::kFlagCreate, &error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::OK, error);
 
   // Lock the file.
   error = mojom::FileError::FAILED;
   handled = file->Lock(&error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::OK, error);
 
   // Lock the file again.
   error = mojom::FileError::OK;
   handled = file->Lock(&error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(mojom::FileError::FAILED, error);
 }
 
 TEST_F(FileImplTest, ClosingFileClearsLock) {
   mojom::DirectoryPtr directory;
   GetTemporaryRoot(&directory);
   mojom::FileError error;
 
   {
     // Create my_file.
     mojom::FilePtr file;
     error = mojom::FileError::FAILED;
     bool handled = directory->OpenFile(
-        "my_file", GetProxy(&file),
+        "my_file", MakeRequest(&file),
         mojom::kFlagRead | mojom::kFlagWrite | mojom::kFlagOpenAlways, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     // Lock the file.
     error = mojom::FileError::FAILED;
     handled = file->Lock(&error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
   }
 
   {
     // Open the file again.
     mojom::FilePtr file;
     error = mojom::FileError::FAILED;
     bool handled = directory->OpenFile(
-        "my_file", GetProxy(&file),
+        "my_file", MakeRequest(&file),
         mojom::kFlagRead | mojom::kFlagWrite | mojom::kFlagOpenAlways, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
 
     // The file shouldn't be locked (and we check by trying to lock it).
     error = mojom::FileError::FAILED;
     handled = file->Lock(&error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(mojom::FileError::OK, error);
   }
 }
 
 }  // namespace
 }  // namespace filesystem