Reland "Added an extra sync token field for extra command buffer..."

content/common/gpu/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 "content/common/gpu/client/gpu_channel_host.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
@@ skipping 55 matching lines @@
     GpuChannelHostFactory* factory,
     int channel_id,
     const gpu::GPUInfo& gpu_info,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager)
     : factory_(factory),
       channel_id_(channel_id),
       gpu_info_(gpu_info),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager) {
   next_image_id_.GetNext();
   next_route_id_.GetNext();
   next_stream_id_.GetNext();

[piman, 2015/12/04 22:48:46]

You'll need to bump this too, otherwise the first user stream will conflict with
the default one.

[David Yen, 2015/12/04 23:30:27]

Is the plan to get rid of the default stream ID and replace it with generated
ones? Or are these going to be used in conjunction with the default ones? If
they are going to be used in conjunction perhaps it would make more sense to
have 0 be invalid, INT_MAX be default, and 1~INT_MAX-1 be generated.

[David Yen, 2015/12/05 00:01:18]

I changed kDefaultStreamId to be -1 and added DCHECKs in GenerateStreamID().

[piman, 2015/12/05 02:16:24]

Maybe we can consider getting rid of the default stream ID at some point, but I
think transitioning all clients is not going to be a simple switch so they will
have to coexist as we transition them incrementally.

 }
 
 void GpuChannelHost::Connect(const IPC::ChannelHandle& channel_handle,
                              base::WaitableEvent* shutdown_event) {
   DCHECK(factory_->IsMainThread());
   // Open a channel to the GPU process. We pass NULL as the main listener here
   // since we need to filter everything to route it to the right thread.
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner =
       factory_->GetIOThreadTaskRunner();
   channel_ =
@@ skipping 68 matching lines @@
                                    latency_info.begin(), latency_info.end());
 
     if (do_flush)
       InternalFlush(&flush_info);
 
     return flush_id;
   }
   return 0;
 }
 
+void GpuChannelHost::FlushPendingStream(int32 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.clear();
   flush_info->flush_pending = false;
@@ skipping 352 matching lines @@
 
   listeners_.clear();
 }
 
 bool GpuChannelHost::MessageFilter::IsLost() const {
   AutoLock lock(lock_);
   return lost_;
 }
 
 }  // namespace content