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

gpu/command_buffer/service/in_process_command_buffer.cc

 // Copyright 2013 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/command_buffer/service/in_process_command_buffer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 931 matching lines @@
 
   scoped_refptr<gpu::SyncPointClientState> release_state =
       sync_point_manager->GetSyncPointClientState(
           sync_token.namespace_id(), sync_token.command_buffer_id());
 
   if (!release_state) {
     callback.Run();
     return;
   }
 
-  sync_point_client_->Wait(release_state.get(), sync_token.release_count(),
-                           WrapCallback(callback));
+  sync_point_client_->WaitOutOfOrder(

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

ditto, how is this different than WaitFenceSyncOnGpuThread in terms of ordering?

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

Here because order numbers are only generated in Flush(), even though
SignalSyncToken is run "in order" it does not have a proper order number
associated with the wait. Since WaitFenceSyncOnGpuThread is called by the
decoder it is properly managed.

Another way to solve this (since we do not currently support descheduling which
means they currently happen to run in order) is to also generate an order number
here around the Wait(), but WaitOutOfOrder() is simpler I think. This also opens
up the possibility of being able to deschedule commands.

+      release_state.get(), sync_token.release_count(), WrapCallback(callback));
 }
 
 void InProcessCommandBuffer::SignalQuery(unsigned query_id,
                                          const base::Closure& callback) {
   CheckSequencedThread();
   QueueTask(base::Bind(&InProcessCommandBuffer::SignalQueryOnGpuThread,
                        base::Unretained(this),
                        query_id,
                        WrapCallback(callback)));
 }
@@ skipping 185 matching lines @@
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu