gpu: Add sync token dependencies to flush metadata.

gpu/ipc/client/gpu_channel_host.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/gpu_channel_host.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
@@ skipping 116 matching lines @@
   bool result = sync_filter_->Send(message.release());
   return result;
 }
 
 uint32_t GpuChannelHost::OrderingBarrier(
     int32_t route_id,
     int32_t stream_id,
     int32_t put_offset,
     uint32_t flush_count,
     const std::vector<ui::LatencyInfo>& latency_info,
+    const std::vector<SyncToken>& sync_token_dependencies,
     bool put_offset_changed,
     bool do_flush,
     uint32_t* highest_verified_flush_id) {
   AutoLock lock(context_lock_);
   StreamFlushInfo& flush_info = stream_flush_info_[stream_id];
   if (flush_info.flush_pending && flush_info.route_id != route_id)
     InternalFlush(&flush_info);
 
   *highest_verified_flush_id = flush_info.verified_stream_flush_id;
 
   if (put_offset_changed) {
     const uint32_t flush_id = flush_info.next_stream_flush_id++;
     flush_info.flush_pending = true;
     flush_info.route_id = route_id;
     flush_info.put_offset = put_offset;
     flush_info.flush_count = flush_count;
     flush_info.flush_id = flush_id;
     flush_info.latency_info.insert(flush_info.latency_info.end(),
                                    latency_info.begin(), latency_info.end());
+    flush_info.sync_token_dependencies.insert(
+        flush_info.sync_token_dependencies.end(),
+        sync_token_dependencies.begin(), sync_token_dependencies.end());
 
     if (do_flush)
       InternalFlush(&flush_info);
 
     return flush_id;
   }
   return 0;
 }
 
 void GpuChannelHost::FlushPendingStream(int32_t stream_id) {
   AutoLock lock(context_lock_);
   auto flush_info_iter = stream_flush_info_.find(stream_id);
   if (flush_info_iter == stream_flush_info_.end())
     return;
 
   StreamFlushInfo& flush_info = flush_info_iter->second;
   if (flush_info.flush_pending)
     InternalFlush(&flush_info);
 }
 
 void GpuChannelHost::InternalFlush(StreamFlushInfo* flush_info) {
   context_lock_.AssertAcquired();
   DCHECK(flush_info);
   DCHECK(flush_info->flush_pending);
   DCHECK_LT(flush_info->flushed_stream_flush_id, flush_info->flush_id);
   Send(new GpuCommandBufferMsg_AsyncFlush(
       flush_info->route_id, flush_info->put_offset, flush_info->flush_count,
-      flush_info->latency_info));
+      flush_info->latency_info, flush_info->sync_token_dependencies));
   flush_info->latency_info.clear();
+  flush_info->sync_token_dependencies.clear();
   flush_info->flush_pending = false;
 
   flush_info->flushed_stream_flush_id = flush_info->flush_id;
 }
 
 void GpuChannelHost::DestroyChannel() {
   DCHECK(factory_->IsMainThread());
   AutoLock lock(context_lock_);
   channel_.reset();
 }
@@ skipping 181 matching lines @@
 
   listeners_.clear();
 }
 
 bool GpuChannelHost::MessageFilter::IsLost() const {
   AutoLock lock(lock_);
   return lost_;
 }
 
 }  // namespace gpu