Allow wait in CommandBufferClientImpl.

mojo/gles2/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 "mojo/gles2/command_buffer_client_impl.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/process/process_handle.h"
@@ skipping 38 matching lines @@
 void CommandBufferDelegate::ContextLost() {}
 
 class CommandBufferClientImpl::SyncClientImpl
     : public mus::mojom::CommandBufferSyncClient {
  public:
   SyncClientImpl(mus::mojom::CommandBufferSyncClientPtr* ptr,
                  const MojoAsyncWaiter* async_waiter)
       : initialized_successfully_(false), binding_(this, ptr, async_waiter) {}
 
   bool WaitForInitialization() {
+    base::ThreadRestrictions::ScopedAllowWait wait;
     if (!binding_.WaitForIncomingMethodCall())
       return false;
     return initialized_successfully_;
   }
 
   mus::mojom::CommandBufferStatePtr WaitForProgress() {
+    base::ThreadRestrictions::ScopedAllowWait wait;
     if (!binding_.WaitForIncomingMethodCall())
       return mus::mojom::CommandBufferStatePtr();
     return command_buffer_state_.Pass();
   }
 
   gpu::Capabilities GetCapabilities() {
     if (capabilities_)
       return capabilities_.To<gpu::Capabilities>();
     return gpu::Capabilities();
   }
@@ skipping 18 matching lines @@
 };
 
 class CommandBufferClientImpl::SyncPointClientImpl
     : public mus::mojom::CommandBufferSyncPointClient {
  public:
   SyncPointClientImpl(mus::mojom::CommandBufferSyncPointClientPtr* ptr,
                       const MojoAsyncWaiter* async_waiter)
       : sync_point_(0u), binding_(this, ptr, async_waiter) {}
 
   uint32_t WaitForInsertSyncPoint() {
+    base::ThreadRestrictions::ScopedAllowWait wait;
     if (!binding_.WaitForIncomingMethodCall())
       return 0u;
     uint32_t result = sync_point_;
     sync_point_ = 0u;
     return result;
   }
 
  private:
   void DidInsertSyncPoint(uint32_t sync_point) override {
     sync_point_ = sync_point;
@@ skipping 22 matching lines @@
   command_buffer_.Bind(mojo::InterfacePtrInfo<mus::mojom::CommandBuffer>(
                            command_buffer_handle.Pass(), 0u),
                        async_waiter);
   command_buffer_.set_connection_error_handler(
       [this]() { DidLoseContext(gpu::error::kUnknown); });
 }
 
 CommandBufferClientImpl::~CommandBufferClientImpl() {}
 
 bool CommandBufferClientImpl::Initialize() {
-  base::ThreadRestrictions::ScopedAllowWait wait;
-
   const size_t kSharedStateSize = sizeof(gpu::CommandBufferSharedState);
   void* memory = NULL;
   mojo::ScopedSharedBufferHandle duped;
   bool result = CreateMapAndDupSharedBuffer(
       kSharedStateSize, &memory, &shared_state_handle_, &duped);
   if (!result)
     return false;
 
   shared_state_ = static_cast<gpu::CommandBufferSharedState*>(memory);
 
@@ skipping 168 matching lines @@
       gfx::Size(static_cast<int>(width), static_cast<int>(height)),
       gpu::ImageFactory::DefaultBufferFormatForImageFormat(internalformat),
       gfx::BufferUsage::SCANOUT));
   if (!buffer)
     return -1;
 
   return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
 }
 
 uint32_t CommandBufferClientImpl::InsertSyncPoint() {
-  base::ThreadRestrictions::ScopedAllowWait wait;
   command_buffer_->InsertSyncPoint(true);
   return sync_point_client_impl_->WaitForInsertSyncPoint();
 }
 
 uint32_t CommandBufferClientImpl::InsertFutureSyncPoint() {
   command_buffer_->InsertSyncPoint(false);
   return sync_point_client_impl_->WaitForInsertSyncPoint();
 }
 
 void CommandBufferClientImpl::RetireSyncPoint(uint32_t sync_point) {
@@ skipping 85 matching lines @@
   // TODO(dyen)
 }
 
 bool CommandBufferClientImpl::CanWaitUnverifiedSyncToken(
     const gpu::SyncToken* sync_token) {
   // All sync tokens must be flushed before being waited on.
   return false;
 }
 
 }  // namespace gles2