Implemented new fence syncs which replaces the old sync points.

content/common/gpu/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 CONTENT_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_
 #define CONTENT_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 89 matching lines @@
   int channel_id() const { return channel_id_; }
 
   // The GPU stats reported by the GPU process.
   const gpu::GPUInfo& gpu_info() const { return gpu_info_; }
 
   // IPC::Sender implementation:
   bool Send(IPC::Message* msg) override;
 
   // Set an ordering barrier.  AsyncFlushes any pending barriers on other
   // routes. Combines multiple OrderingBarriers into a single AsyncFlush.
-  void OrderingBarrier(int32 route_id,
-                       int32 stream_id,
-                       int32 put_offset,
-                       uint32 flush_count,
-                       const std::vector<ui::LatencyInfo>& latency_info,
-                       bool put_offset_changed,
-                       bool do_flush);
+  // Returns the flush ID for the stream or 0 if put offset was not changed.
+  uint32_t OrderingBarrier(int32 route_id,
+                           int32 stream_id,
+                           int32 put_offset,
+                           uint32 flush_count,
+                           const std::vector<ui::LatencyInfo>& latency_info,
+                           bool put_offset_changed,
+                           bool do_flush);
 
   // Create and connect to a command buffer in the GPU process.
   scoped_ptr<CommandBufferProxyImpl> CreateViewCommandBuffer(
       int32 surface_id,
       CommandBufferProxyImpl* share_group,
       int32 stream_id,
       GpuStreamPriority stream_priority,
       const std::vector<int32>& attribs,
       const GURL& active_url,
       gfx::GpuPreference gpu_preference);
@@ skipping 47 matching lines @@
 
   // Reserve one unused image ID.
   int32 ReserveImageId();
 
   // Generate a route ID guaranteed to be unique for this channel.
   int32 GenerateRouteID();
 
   // Generate a stream ID guaranteed to be unique for this channel.
   int32 GenerateStreamID();
 
+  // Sends a synchronous nop to the server which validate that all previous IPC
+  // messages have been received. Once the synchronous nop has been sent to the
+  // server all previous flushes will all be marked as validated, including
+  // flushes for other streams on the same channel. Once a validation has been
+  // sent, it will return the highest validated flush id for the stream.
+  // If the validation fails (which can only happen upon context lost), the
+  // highest validated flush id will not change. If no flush ID were ever
+  // validated then it will return 0 (Note the lowest valid flush ID is 1).
+  uint32_t ValidateFlushIDReachedServer(int32 stream_id);
+
+  // Returns the highest validated flush ID for a given stream.
+  uint32_t GetHighestValidatedFlushID(int32 stream_id);
+
  private:
   friend class base::RefCountedThreadSafe<GpuChannelHost>;
 
   // A filter used internally to route incoming messages from the IO thread
   // to the correct message loop. It also maintains some shared state between
   // all the contexts.
   class MessageFilter : public IPC::MessageFilter {
    public:
     MessageFilter();
 
@@ skipping 33 matching lines @@
     mutable base::Lock lock_;
 
     // Whether the channel has been lost.
     bool lost_;
   };
 
   struct StreamFlushInfo {
     StreamFlushInfo();
     ~StreamFlushInfo();
 
+    // These are global per stream.
+    uint32_t next_stream_flush_id;
+    uint32_t flushed_stream_flush_id;
+    uint32_t verified_stream_flush_id;
+
+    // These are local per context.
     bool flush_pending;
     int32 route_id;
     int32 put_offset;
     uint32 flush_count;
+    uint32_t flush_id;
     std::vector<ui::LatencyInfo> latency_info;
   };
 
   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);
-  void InternalFlush(int32 stream_id);
+  void InternalFlush(StreamFlushInfo* flush_info);
 
   // Threading notes: all fields are constant during the lifetime of |this|
   // except:
   // - |next_image_id_|, atomic type
   // - |next_route_id_|, atomic type
   // - |next_stream_id_|, atomic type
   // - |channel_| and |stream_flush_info_|, protected by |context_lock_|
   GpuChannelHostFactory* const factory_;
 
   const int channel_id_;
@@ skipping 19 matching lines @@
   mutable base::Lock context_lock_;
   scoped_ptr<IPC::SyncChannel> channel_;
   base::hash_map<int32, StreamFlushInfo> stream_flush_info_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuChannelHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_