gpu: Add sync token dependencies to flush metadata.

gpu/ipc/client/command_buffer_proxy_impl.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.
 
 #include "gpu/ipc/client/command_buffer_proxy_impl.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 26 matching lines @@
 
 namespace gpu {
 
 namespace {
 
 gpu::CommandBufferId CommandBufferProxyID(int channel_id, int32_t route_id) {
   return gpu::CommandBufferId::FromUnsafeValue(
       (static_cast<uint64_t>(channel_id) << 32) | route_id);
 }
 
+int GetChannelID(gpu::CommandBufferId command_buffer_id) {
+  return static_cast<int>(command_buffer_id.GetUnsafeValue() >> 32);
+}
+
 }  // namespace
 
 CommandBufferProxyImpl::CommandBufferProxyImpl(int channel_id,
                                                int32_t route_id,
                                                int32_t stream_id)
     : lock_(nullptr),
       gpu_control_client_(nullptr),
       command_buffer_id_(CommandBufferProxyID(channel_id, route_id)),
       route_id_(route_id),
       stream_id_(stream_id),
-      flush_count_(0),
-      last_put_offset_(-1),
-      last_barrier_put_offset_(-1),
-      next_fence_sync_release_(1),
-      flushed_fence_sync_release_(0),
-      verified_fence_sync_release_(0),
-      next_signal_id_(0),
       weak_this_(AsWeakPtr()) {
   DCHECK(route_id);
   DCHECK_NE(stream_id, GPU_STREAM_INVALID);
 }
 
 // static
 std::unique_ptr<CommandBufferProxyImpl> CommandBufferProxyImpl::Create(
     scoped_refptr<GpuChannelHost> host,
     gpu::SurfaceHandle surface_handle,
     CommandBufferProxyImpl* share_group,
@@ skipping 184 matching lines @@
                put_offset);
 
   bool put_offset_changed = last_put_offset_ != put_offset;
   last_put_offset_ = put_offset;
   last_barrier_put_offset_ = put_offset;
 
   if (channel_) {
     uint32_t highest_verified_flush_id;
     const uint32_t flush_id = channel_->OrderingBarrier(
         route_id_, stream_id_, put_offset, ++flush_count_, latency_info_,
-        put_offset_changed, true, &highest_verified_flush_id);
+        pending_sync_token_fences_, put_offset_changed, true,
+        &highest_verified_flush_id);
     if (put_offset_changed) {
       DCHECK(flush_id);
       const uint64_t fence_sync_release = next_fence_sync_release_ - 1;
       if (fence_sync_release > flushed_fence_sync_release_) {
         flushed_fence_sync_release_ = fence_sync_release;
         flushed_release_flush_id_.push(
             std::make_pair(fence_sync_release, flush_id));
       }
     }
     CleanupFlushedReleases(highest_verified_flush_id);
   }
 
-  if (put_offset_changed)
+  if (put_offset_changed) {
     latency_info_.clear();
+    pending_sync_token_fences_.clear();
+  }
 }
 
 void CommandBufferProxyImpl::OrderingBarrier(int32_t put_offset) {
   CheckLock();
   base::AutoLock lock(last_state_lock_);
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   TRACE_EVENT1("gpu", "CommandBufferProxyImpl::OrderingBarrier", "put_offset",
                put_offset);
 
   bool put_offset_changed = last_barrier_put_offset_ != put_offset;
   last_barrier_put_offset_ = put_offset;
 
   if (channel_) {
     uint32_t highest_verified_flush_id;
     const uint32_t flush_id = channel_->OrderingBarrier(
         route_id_, stream_id_, put_offset, ++flush_count_, latency_info_,
-        put_offset_changed, false, &highest_verified_flush_id);
+        pending_sync_token_fences_, put_offset_changed, false,
+        &highest_verified_flush_id);
 
     if (put_offset_changed) {
       DCHECK(flush_id);
       const uint64_t fence_sync_release = next_fence_sync_release_ - 1;
       if (fence_sync_release > flushed_fence_sync_release_) {
         flushed_fence_sync_release_ = fence_sync_release;
         flushed_release_flush_id_.push(
             std::make_pair(fence_sync_release, flush_id));
       }
     }
     CleanupFlushedReleases(highest_verified_flush_id);
   }
-
-  if (put_offset_changed)
+  if (put_offset_changed) {
     latency_info_.clear();
+    pending_sync_token_fences_.clear();
+  }
 }
 
 void CommandBufferProxyImpl::SetLatencyInfo(
     const std::vector<ui::LatencyInfo>& latency_info) {
   CheckLock();
   for (size_t i = 0; i < latency_info.size(); i++)
     latency_info_.push_back(latency_info[i]);
 }
 
 void CommandBufferProxyImpl::SetSwapBuffersCompletionCallback(
@@ skipping 320 matching lines @@
   base::AutoLock lock(last_state_lock_);
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   uint32_t signal_id = next_signal_id_++;
   Send(new GpuCommandBufferMsg_SignalSyncToken(route_id_, sync_token,
                                                signal_id));
   signal_tasks_.insert(std::make_pair(signal_id, callback));
 }
 
+void CommandBufferProxyImpl::WaitSyncToken(const SyncToken& sync_token) {
+  CheckLock();
+  base::AutoLock lock(last_state_lock_);
+  if (last_state_.error != gpu::error::kNoError)
+    return;
+
+  // We can only send verified sync tokens across IPC.
+  SyncToken verified_sync_token = sync_token;
+  verified_sync_token.SetVerifyFlush();

[piman, 2017/03/13 23:17:39]

nit: I would suggest moving this to GLES2Implementation for consistency with
e.g. SignalSyncToken. It could even coalesce into a "bool
GetVerifiedSyncTokenForIPC(const SyncToken& sync_token, SyncToken* verified)"
helper that checks if it's verified, or can be waited without verification, and
sets the verified bit in the latter case.

+
+  pending_sync_token_fences_.push_back(verified_sync_token);
+}
+
 bool CommandBufferProxyImpl::CanWaitUnverifiedSyncToken(
-    const gpu::SyncToken* sync_token) {
+    const gpu::SyncToken& sync_token) {
   // Can only wait on an unverified sync token if it is from the same channel.
-  const uint64_t token_channel =
-      sync_token->command_buffer_id().GetUnsafeValue() >> 32;
-  const uint64_t channel = command_buffer_id_.GetUnsafeValue() >> 32;
-  if (sync_token->namespace_id() != gpu::CommandBufferNamespace::GPU_IO ||
-      token_channel != channel) {
+  int sync_token_channel_id = GetChannelID(sync_token.command_buffer_id());
+  int channel_id = GetChannelID(command_buffer_id_);
+  if (sync_token.namespace_id() != gpu::CommandBufferNamespace::GPU_IO ||
+      sync_token_channel_id != channel_id) {
     return false;
   }
 
   // If waiting on a different stream, flush pending commands on that stream.
-  const int32_t release_stream_id = sync_token->extra_data_field();
+  int32_t release_stream_id = sync_token.extra_data_field();
   if (release_stream_id == gpu::GPU_STREAM_INVALID)
     return false;
 
   if (release_stream_id != stream_id_)
     channel_->FlushPendingStream(release_stream_id);
 
   return true;
 }
 
 void CommandBufferProxyImpl::SignalQuery(uint32_t query,
@@ skipping 256 matching lines @@
     return;
   channel_->FlushPendingStream(stream_id_);
   channel_->Send(new GpuChannelMsg_DestroyCommandBuffer(route_id_));
   channel_->RemoveRoute(route_id_);
   channel_ = nullptr;
   if (gpu_control_client_)
     gpu_control_client_->OnGpuControlLostContext();
 }
 
 }  // namespace gpu