Added a way for sync point clients to issue out of order waits.

content/common/gpu/gpu_command_buffer_stub.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/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 991 matching lines @@
       base::Bind(&GpuCommandBufferStub::OnSignalAck, this->AsWeakPtr(), id));
 }
 
 void GpuCommandBufferStub::OnSignalSyncToken(const gpu::SyncToken& sync_token,
                                              uint32_t id) {
   scoped_refptr<gpu::SyncPointClientState> release_state =
       sync_point_manager_->GetSyncPointClientState(
           sync_token.namespace_id(), sync_token.command_buffer_id());
 
   if (release_state) {
-    sync_point_client_->Wait(release_state.get(), sync_token.release_count(),
-                             base::Bind(&GpuCommandBufferStub::OnSignalAck,
-                                        this->AsWeakPtr(), id));
+    // This wait must use the out of order variant since it is not processed
+    // within the global order.

[piman, 2016/01/07 01:16:22]

I don't think that's true, this is processed on the main thread, just like every
other message (it would be a good idea to do on the IO thread, actually, but we
don't do that now).

[David Yen, 2016/01/07 18:40:58]

You are right, this should be Wait instead of WaitOutOfOrder. I forgot that the
command buffer stub runs on the main thread and has an order number attached to
every command. That is not true for the InProcess case though.

Alternatively we can do this on the IO thread using WaitOutOfOrder if we want
to. I will change it back for now though.

+    sync_point_client_->WaitOutOfOrder(
+        release_state.get(), sync_token.release_count(),
+        base::Bind(&GpuCommandBufferStub::OnSignalAck, this->AsWeakPtr(), id));
   } else {
     OnSignalAck(id);
   }
 }
 
 void GpuCommandBufferStub::OnSignalAck(uint32_t id) {
   Send(new GpuCommandBufferMsg_SignalAck(route_id_, id));
 }
 
 void GpuCommandBufferStub::OnSignalQuery(uint32_t query_id, uint32_t id) {
@@ skipping 230 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content