gpu: Add sync token dependencies to flush metadata.

gpu/command_buffer/client/gles2_implementation.cc

 // Copyright (c) 2012 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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
@@ skipping 360 matching lines @@
 
 void GLES2Implementation::RunIfContextNotLost(const base::Closure& callback) {
   if (!lost_context_callback_run_)
     callback.Run();
 }
 
 void GLES2Implementation::SignalSyncToken(const gpu::SyncToken& sync_token,
                                           const base::Closure& callback) {
   if (sync_token.HasData() &&
       (sync_token.verified_flush() ||
-       gpu_control_->CanWaitUnverifiedSyncToken(&sync_token))) {
-
-    gpu::SyncToken intermediate_sync_token = sync_token;
-
-    // Mark the intermediate sync token as verified if we can wait on
-    // unverified sync tokens.
-    intermediate_sync_token.SetVerifyFlush();
+       gpu_control_->CanWaitUnverifiedSyncToken(sync_token))) {
+    // We can only send verified sync tokens across IPC.
+    gpu::SyncToken verified_sync_token = sync_token;
+    verified_sync_token.SetVerifyFlush();
 
     gpu_control_->SignalSyncToken(
-        intermediate_sync_token,
+        verified_sync_token,
         base::Bind(&GLES2Implementation::RunIfContextNotLost,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   callback));
+                   weak_ptr_factory_.GetWeakPtr(), callback));
   } else {
     // Invalid sync token, just call the callback immediately.
     callback.Run();
   }
 }
 
 // This may be called from any thread. It's safe to access gpu_control_ without
 // the lock because it is const.
-bool GLES2Implementation::IsSyncTokenSignalled(
+bool GLES2Implementation::IsSyncTokenSignaled(
     const gpu::SyncToken& sync_token) {
   // Check that the sync token belongs to this context.
   DCHECK_EQ(gpu_control_->GetNamespaceID(), sync_token.namespace_id());
   DCHECK_EQ(gpu_control_->GetCommandBufferID(), sync_token.command_buffer_id());
   return gpu_control_->IsFenceSyncReleased(sync_token.release_count());
 }
 
 void GLES2Implementation::SignalQuery(uint32_t query,
                                       const base::Closure& callback) {
   // Flush previously entered commands to ensure ordering with any
@@ skipping 5695 matching lines @@
 
 void GLES2Implementation::VerifySyncTokensCHROMIUM(GLbyte **sync_tokens,
                                                    GLsizei count) {
   bool requires_synchronization = false;
   for (GLsizei i = 0; i < count; ++i) {
     if (sync_tokens[i]) {
       SyncToken sync_token;
       memcpy(&sync_token, sync_tokens[i], sizeof(sync_token));
 
       if (sync_token.HasData() && !sync_token.verified_flush()) {
-        if (!gpu_control_->CanWaitUnverifiedSyncToken(&sync_token)) {
+        if (!gpu_control_->CanWaitUnverifiedSyncToken(sync_token)) {
           SetGLError(GL_INVALID_VALUE, "glVerifySyncTokensCHROMIUM",
                      "Cannot verify sync token using this context.");
           return;
         }
         requires_synchronization = true;
       }
     }
   }
 
   // This step must be done after all unverified tokens have finished processing
@@ skipping 13 matching lines @@
         memcpy(&sync_token, sync_tokens[i], sizeof(sync_token));
         if (sync_token.HasData() && !sync_token.verified_flush()) {
           sync_token.SetVerifyFlush();
           memcpy(sync_tokens[i], &sync_token, sizeof(sync_token));
         }
       }
     }
   }
 }
 
-void GLES2Implementation::WaitSyncTokenCHROMIUM(const GLbyte* sync_token) {
-  if (sync_token) {
-    // Copy the data over before data access to ensure alignment.
-    SyncToken sync_token_data;
-    memcpy(&sync_token_data, sync_token, sizeof(SyncToken));
-    if (sync_token_data.HasData()) {
-      if (!sync_token_data.verified_flush() &&
-          !gpu_control_->CanWaitUnverifiedSyncToken(&sync_token_data)) {
-        SetGLError(GL_INVALID_VALUE, "glWaitSyncTokenCHROMIUM",
-                   "Cannot wait on sync_token which has not been verified");
-        return;
-      }
+void GLES2Implementation::WaitSyncTokenCHROMIUM(const GLbyte* sync_token_data) {
+  if (!sync_token_data)
+    return;
 
-      helper_->WaitSyncTokenCHROMIUM(
-          static_cast<GLint>(sync_token_data.namespace_id()),
-          sync_token_data.command_buffer_id().GetUnsafeValue(),
-          sync_token_data.release_count());
-    }
+  // Copy the data over before data access to ensure alignment.
+  SyncToken sync_token;
+  memcpy(&sync_token, sync_token_data, sizeof(SyncToken));
+
+  if (!sync_token.HasData())
+    return;
+
+  if (!sync_token.verified_flush() &&
+      !gpu_control_->CanWaitUnverifiedSyncToken(sync_token)) {
+    SetGLError(GL_INVALID_VALUE, "glWaitSyncTokenCHROMIUM",
+               "Cannot wait on sync_token which has not been verified");
+    return;
   }
+
+  gpu_control_->WaitSyncToken(sync_token);

[jbauman, 2017/03/09 02:00:09]

I think this should actually go after the call to
helper_->WaitSyncTokenCHROMIUM. Otherwise if the helper needs to flush the
command buffer before putting in the command then the wait would go on the wrong
flush.

[sunnyps, 2017/03/10 03:26:20]

Nice catch!

+
+  helper_->WaitSyncTokenCHROMIUM(
+      static_cast<GLint>(sync_token.namespace_id()),
+      sync_token.command_buffer_id().GetUnsafeValue(),
+      sync_token.release_count());
 }
 
 namespace {
 
 bool CreateImageValidInternalFormat(GLenum internalformat,
                                     const Capabilities& capabilities) {
   switch (internalformat) {
     case GL_ATC_RGB_AMD:
     case GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD:
       return capabilities.texture_format_atc;
@@ skipping 842 matching lines @@
   CheckGLError();
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu