Rename InterfacePtr's WaitForIncomingMethodCall() -> WaitForIncomingResponse().

mojo/services/files/public/c/tests/test_utils.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 "files/public/c/tests/test_utils.h"
 
 #include "files/public/c/lib/template_util.h"
 #include "files/public/interfaces/file.mojom.h"
 #include "files/public/interfaces/types.mojom.h"
 #include "mojo/public/cpp/environment/logging.h"
 
 namespace mojio {
 namespace test {
 
 void MakeDirAt(mojo::files::DirectoryPtr* root, const char* path) {
   MOJO_CHECK(root);
   MOJO_CHECK(path);
   mojo::files::DirectoryPtr& dir = *root;
 
   mojo::files::Error error = mojo::files::ERROR_INTERNAL;
   dir->OpenDirectory(path, nullptr,
                      mojo::files::kOpenFlagRead | mojo::files::kOpenFlagWrite |
                          mojo::files::kOpenFlagCreate,
                      Capture(&error));
-  MOJO_CHECK(dir.WaitForIncomingMethodCall());
+  MOJO_CHECK(dir.WaitForIncomingResponse());
   MOJO_CHECK(error == mojo::files::ERROR_OK);
 }
 
 mojo::files::FilePtr OpenFileAt(mojo::files::DirectoryPtr* root,
                                 const char* path,
                                 uint32_t open_flags) {
   MOJO_CHECK(root);
   MOJO_CHECK(path);
   mojo::files::DirectoryPtr& dir = *root;
 
   mojo::files::FilePtr file;
   mojo::files::Error error = mojo::files::ERROR_INTERNAL;
   dir->OpenFile(path, mojo::GetProxy(&file), open_flags, Capture(&error));
-  MOJO_CHECK(dir.WaitForIncomingMethodCall());
+  MOJO_CHECK(dir.WaitForIncomingResponse());
   if (error != mojo::files::ERROR_OK)
     return nullptr;
 
   return file.Pass();
 }
 
 void CreateTestFileAt(mojo::files::DirectoryPtr* root,
                       const char* path,
                       size_t size) {
   mojo::files::FilePtr file = OpenFileAt(
       root, path, mojo::files::kOpenFlagWrite | mojo::files::kOpenFlagCreate |
                       mojo::files::kOpenFlagExclusive);
   MOJO_CHECK(file);
 
   if (!size)
     return;
 
   std::vector<uint8_t> bytes_to_write(size);
   for (size_t i = 0; i < size; i++)
     bytes_to_write[i] = static_cast<uint8_t>(i);
   mojo::files::Error error = mojo::files::ERROR_INTERNAL;
   uint32_t num_bytes_written = 0;
   file->Write(mojo::Array<uint8_t>::From(bytes_to_write), 0,
               mojo::files::WHENCE_FROM_CURRENT,
               Capture(&error, &num_bytes_written));
-  MOJO_CHECK(file.WaitForIncomingMethodCall());
+  MOJO_CHECK(file.WaitForIncomingResponse());
   MOJO_CHECK(error == mojo::files::ERROR_OK);
   MOJO_CHECK(num_bytes_written == bytes_to_write.size());
 }
 
 int64_t GetFileSize(mojo::files::DirectoryPtr* root, const char* path) {
   mojo::files::FilePtr file =
       OpenFileAt(root, path, mojo::files::kOpenFlagRead);
   if (!file)
     return -1;
 
   // Seek to the end to get the file size (we could also stat).
   mojo::files::Error error = mojo::files::ERROR_INTERNAL;
   int64_t position = -1;
   file->Seek(0, mojo::files::WHENCE_FROM_END, Capture(&error, &position));
-  MOJO_CHECK(file.WaitForIncomingMethodCall());
+  MOJO_CHECK(file.WaitForIncomingResponse());
   MOJO_CHECK(error == mojo::files::ERROR_OK);
   MOJO_CHECK(position >= 0);
   return position;
 }
 
 std::string GetFileContents(mojo::files::DirectoryPtr* root, const char* path) {
   mojo::files::FilePtr file =
       OpenFileAt(root, path, mojo::files::kOpenFlagRead);
   MOJO_CHECK(file);
 
   mojo::Array<uint8_t> bytes_read;
   mojo::files::Error error = mojo::files::ERROR_INTERNAL;
   file->Read(1024 * 1024, 0, mojo::files::WHENCE_FROM_START,
              Capture(&error, &bytes_read));
-  MOJO_CHECK(file.WaitForIncomingMethodCall());
+  MOJO_CHECK(file.WaitForIncomingResponse());
   if (!bytes_read.size())
     return std::string();
   return std::string(reinterpret_cast<const char*>(&bytes_read[0]),
                      bytes_read.size());
 }
 
 }  // namespace test
 }  // namespace mojio