Eliminate usage of InterfacePtr::WaitForIncomingResponse.

components/mus/public/cpp/lib/command_buffer_client_impl.cc

 // Copyright 2014 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 "components/mus/public/cpp/lib/command_buffer_client_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/process/process_handle.h"
-#include "base/threading/thread_restrictions.h"
 #include "components/mus/common/gpu_type_converters.h"
 #include "components/mus/common/mojo_buffer_backing.h"
 #include "components/mus/common/mojo_gpu_memory_buffer.h"
 #include "gpu/command_buffer/client/gpu_control_client.h"
 #include "gpu/command_buffer/common/command_buffer_id.h"
 #include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 
 namespace mus {
 
 namespace {
 
 bool CreateAndMapSharedBuffer(size_t size,
                               mojo::ScopedSharedBufferMapping* mapping,
                               mojo::ScopedSharedBufferHandle* handle) {
   *handle = mojo::SharedBufferHandle::Create(size);
   if (!handle->is_valid())
     return false;
 
   *mapping = (*handle)->Map(size);
   if (!*mapping)
     return false;
 
   return true;
 }
 
-void MakeProgressCallback(gpu::CommandBuffer::State* output,
-                          const gpu::CommandBuffer::State& input) {
-  *output = input;
-}
-
-void InitializeCallback(mus::mojom::CommandBufferInitializeResultPtr* output,
-                        mus::mojom::CommandBufferInitializeResultPtr input) {
-  *output = std::move(input);
-}
-
 }  // namespace
 
 CommandBufferClientImpl::CommandBufferClientImpl(
     const std::vector<int32_t>& attribs,
     mus::mojom::CommandBufferPtr command_buffer_ptr)
     : gpu_control_client_(nullptr),
       destroyed_(false),
       attribs_(attribs),
       client_binding_(this),
       command_buffer_(std::move(command_buffer_ptr)),
@@ skipping 17 matching lines @@
       CreateAndMapSharedBuffer(kSharedStateSize, &shared_state_, &handle);
   if (!result)
     return false;
 
   shared_state()->Initialize();
 
   mus::mojom::CommandBufferClientPtr client_ptr;
   client_binding_.Bind(GetProxy(&client_ptr));
 
   mus::mojom::CommandBufferInitializeResultPtr initialize_result;
-  command_buffer_->Initialize(
+  bool handled = command_buffer_->Initialize(
       std::move(client_ptr), std::move(handle),
-      mojo::Array<int32_t>::From(attribs_),
-      base::Bind(&InitializeCallback, &initialize_result));
+      mojo::Array<int32_t>::From(attribs_), &initialize_result);
 
-  base::ThreadRestrictions::ScopedAllowWait wait;
-  if (!command_buffer_.WaitForIncomingResponse()) {
+  if (!handled) {
     VLOG(1) << "Channel encountered error while creating command buffer.";
     return false;
   }
 
   if (!initialize_result) {
     VLOG(1) << "Command buffer cannot be initialized successfully.";
     return false;
   }
 
   DCHECK_EQ(gpu::CommandBufferNamespace::MOJO,
@@ skipping 183 matching lines @@
 void CommandBufferClientImpl::UpdateVSyncParameters(int64_t timebase,
                                                     int64_t interval) {}
 
 void CommandBufferClientImpl::TryUpdateState() {
   if (last_state_.error == gpu::error::kNoError)
     shared_state()->Read(&last_state_);
 }
 
 void CommandBufferClientImpl::MakeProgressAndUpdateState() {
   gpu::CommandBuffer::State state;
-  command_buffer_->MakeProgress(last_state_.get_offset,
-                                base::Bind(&MakeProgressCallback, &state));
+  bool handled = command_buffer_->MakeProgress(last_state_.get_offset, &state);
 
-  base::ThreadRestrictions::ScopedAllowWait wait;
-  if (!command_buffer_.WaitForIncomingResponse()) {
+  if (!handled) {
     VLOG(1) << "Channel encountered error while waiting for command buffer.";
     // TODO(piman): is it ok for this to re-enter?
     Destroyed(gpu::error::kUnknown, gpu::error::kLostContext);
     return;
   }
 
   if (state.generation - last_state_.generation < 0x80000000U)
     last_state_ = state;
 }
 
@@ skipping 46 matching lines @@
 
   // It is also safe to wait on the same context.
   if (sync_token->namespace_id() == gpu::CommandBufferNamespace::MOJO &&
       sync_token->command_buffer_id() == GetCommandBufferID())
     return true;
 
   return false;
 }
 
 }  // namespace mus