gpu: Add sync token dependencies to flush metadata.

gpu/ipc/client/gpu_channel_host.h

 // 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.
 
 #ifndef GPU_IPC_CLIENT_GPU_CHANNEL_HOST_H_
 #define GPU_IPC_CLIENT_GPU_CHANNEL_HOST_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 23 matching lines @@
 
 namespace IPC {
 class SyncMessageFilter;
 }
 
 namespace gpu {
 class GpuMemoryBufferManager;
 }
 
 namespace gpu {
-
+struct SyncToken;
 class GpuChannelHost;
 using GpuChannelEstablishedCallback =
     base::Callback<void(scoped_refptr<GpuChannelHost>)>;
 
 class GPU_EXPORT GpuChannelEstablishFactory {
  public:
   virtual ~GpuChannelEstablishFactory() {}
 
   virtual void EstablishGpuChannel(
       const GpuChannelEstablishedCallback& callback) = 0;
@@ skipping 44 matching lines @@
 
   // Set an ordering barrier.  AsyncFlushes any pending barriers on other
   // routes. Combines multiple OrderingBarriers into a single AsyncFlush.
   // Returns the flush ID for the stream or 0 if put offset was not changed.
   // Outputs *highest_verified_flush_id.
   uint32_t 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_fences,
                            bool put_offset_changed,
                            bool do_flush,
                            uint32_t* highest_verified_flush_id);
 
   void FlushPendingStream(int32_t stream_id);
 
   // Destroy this channel. Must be called on the main thread, before
   // destruction.
   void DestroyChannel();
 
@@ skipping 106 matching lines @@
     uint32_t flushed_stream_flush_id;
     uint32_t verified_stream_flush_id;
 
     // These are local per context.
     bool flush_pending;
     int32_t route_id;
     int32_t put_offset;
     uint32_t flush_count;
     uint32_t flush_id;
     std::vector<ui::LatencyInfo> latency_info;
+    std::vector<SyncToken> sync_token_fences;
   };
 
   GpuChannelHost(GpuChannelHostFactory* factory,
                  int channel_id,
                  const gpu::GPUInfo& gpu_info,
                  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager);
   ~GpuChannelHost() override;
   void Connect(const IPC::ChannelHandle& channel_handle,
                base::WaitableEvent* shutdown_event);
   bool InternalSend(IPC::Message* msg);
@@ skipping 30 matching lines @@
   mutable base::Lock context_lock_;
   std::unique_ptr<IPC::SyncChannel> channel_;
   base::hash_map<int32_t, StreamFlushInfo> stream_flush_info_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuChannelHost);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_IPC_CLIENT_GPU_CHANNEL_HOST_H_