gpu: Implement the new fence syncs in mojo command buffer.

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"
 #include "base/threading/thread_restrictions.h"
 #include "components/mus/gles2/command_buffer_type_conversions.h"
 #include "components/mus/gles2/mojo_buffer_backing.h"
 #include "components/mus/gles2/mojo_gpu_memory_buffer.h"
+#include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "mojo/platform_handle/platform_handle_functions.h"
 
 namespace gles2 {
 
 namespace {
 
 bool CreateMapAndDupSharedBuffer(size_t size,
                                  void** memory,
                                  mojo::ScopedSharedBufferHandle* handle,
@@ skipping 21 matching lines @@
 
 CommandBufferDelegate::~CommandBufferDelegate() {}
 
 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) {}
+      : initialized_successfully_(false),
+        command_buffer_id_(0),
+        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();
   }
 
+  uint64_t GetCommandBufferID() const {
+    return command_buffer_id_;
+  }
+
  private:
   // CommandBufferSyncClient methods:
   void DidInitialize(bool success,
+                     int32_t command_buffer_namespace,
+                     uint64_t command_buffer_id,
                      mus::mojom::GpuCapabilitiesPtr capabilities) override {
+    DCHECK_EQ(command_buffer_namespace, gpu::CommandBufferNamespace::MOJO);
     initialized_successfully_ = success;
+    command_buffer_id_ = command_buffer_id;
     capabilities_ = capabilities.Pass();
   }
   void DidMakeProgress(mus::mojom::CommandBufferStatePtr state) override {
     command_buffer_state_ = state.Pass();
   }
 
   bool initialized_successfully_;
+  uint64_t command_buffer_id_;
   mus::mojom::GpuCapabilitiesPtr capabilities_;
   mus::mojom::CommandBufferStatePtr command_buffer_state_;
   mojo::Binding<mus::mojom::CommandBufferSyncClient> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncClientImpl);
 };
 
 class CommandBufferClientImpl::SyncPointClientImpl
     : public mus::mojom::CommandBufferSyncPointClient {
  public:
@@ skipping 296 matching lines @@
 bool CommandBufferClientImpl::IsGpuChannelLost() {
   // This is only possible for out-of-process command buffers.
   return false;
 }
 
 gpu::CommandBufferNamespace CommandBufferClientImpl::GetNamespaceID() const {
   return gpu::CommandBufferNamespace::MOJO;
 }
 
 uint64_t CommandBufferClientImpl::GetCommandBufferID() const {
-  // TODO (rjkroege): This must correspond to the command buffer ID on the
-  // server side. Most likely a combination of the client-specific integer and
-  // the connect id.
-  NOTIMPLEMENTED();
-  return 0;
+  return sync_client_impl_->GetCommandBufferID();
 }
 
 uint64_t CommandBufferClientImpl::GenerateFenceSyncRelease() {
   return next_fence_sync_release_++;
 }
 
 bool CommandBufferClientImpl::IsFenceSyncRelease(uint64_t release) {
   return release != 0 && release < next_fence_sync_release_;
 }
 
 bool CommandBufferClientImpl::IsFenceSyncFlushed(uint64_t release) {
   return release != 0 && release <= flushed_fence_sync_release_;
 }
 
 bool CommandBufferClientImpl::IsFenceSyncFlushReceived(uint64_t release) {
   return IsFenceSyncFlushed(release);
 }
 
 void CommandBufferClientImpl::SignalSyncToken(const gpu::SyncToken& sync_token,
                                               const base::Closure& callback) {
   // TODO(dyen)
 }
 
 bool CommandBufferClientImpl::CanWaitUnverifiedSyncToken(
     const gpu::SyncToken* sync_token) {
-  // All sync tokens must be flushed before being waited on.
+  // Right now, MOJO_LOCAL is only used by trusted code, so it is safe to wait
+  // on a sync token in MOJO_LOCAL command buffer.
+  if (sync_token->namespace_id() == gpu::CommandBufferNamespace::MOJO_LOCAL)
+    return true;
+
+  // 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 gles2