Added global order numbers to in process command buffers.

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 <queue>
 #include <set>
 #include <utility>
 
@@ skipping 326 matching lines @@
     else
       surface_ = gfx::GLSurface::CreateViewGLSurface(params.window);
   }
 
   if (!surface_.get()) {
     LOG(ERROR) << "Could not create GLSurface.";
     DestroyOnGpuThread();
     return false;
   }
 
+  sync_point_client_ = service_->sync_point_manager()->CreateSyncPointClient(
+      GetNamespaceID(), GetCommandBufferID());
+
   if (service_->UseVirtualizedGLContexts() ||
       decoder_->GetContextGroup()
           ->feature_info()
           ->workarounds()
           .use_virtualized_gl_contexts) {
     context_ = gl_share_group_->GetSharedContext();
     if (!context_.get()) {
       context_ = gfx::GLContext::CreateGLContext(
           gl_share_group_.get(), surface_.get(), params.gpu_preference);
       gl_share_group_->SetSharedContext(context_.get());
@@ skipping 75 matching lines @@
   gpu_thread_weak_ptr_factory_.InvalidateWeakPtrs();
   command_buffer_.reset();
   // Clean up GL resources if possible.
   bool have_context = context_.get() && context_->MakeCurrent(surface_.get());
   if (decoder_) {
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
   context_ = NULL;
   surface_ = NULL;
+  sync_point_client_ = NULL;
   gl_share_group_ = NULL;
 #if defined(OS_ANDROID)
   stream_texture_manager_.reset();
 #endif
 
   return true;
 }
 
 void InProcessCommandBuffer::CheckSequencedThread() {
   DCHECK(!sequence_checker_ ||
@@ skipping 22 matching lines @@
   CheckSequencedThread();
   return last_state_;
 }
 
 int32 InProcessCommandBuffer::GetLastToken() {
   CheckSequencedThread();
   GetStateFast();
   return last_state_.token;
 }
 
-void InProcessCommandBuffer::FlushOnGpuThread(int32 put_offset) {
+void InProcessCommandBuffer::FlushOnGpuThread(int32 put_offset,
+                                              uint32_t order_num) {
   CheckSequencedThread();
   ScopedEvent handle_flush(&flush_event_);
   base::AutoLock lock(command_buffer_lock_);
+
+  sync_point_client_->BeginProcessingOrderNumber(order_num);
   command_buffer_->Flush(put_offset);
   {
     // Update state before signaling the flush event.
     base::AutoLock lock(state_after_last_flush_lock_);
     state_after_last_flush_ = command_buffer_->GetLastState();
   }
   DCHECK((!error::IsError(state_after_last_flush_.error) && !context_lost_) ||
          (error::IsError(state_after_last_flush_.error) && context_lost_));
+  DCHECK(context_lost_ || put_offset == state_after_last_flush_.get_offset);

[piman, 2015/09/18 21:39:15]

I don't think this DCHECK is true, if the command buffer had to unschedule, it
will return from Flush with some commands left.

OTOH, InProcessCommandBuffer doesn't register a SchedulingChangedCallback on the
GpuScheduler, so if that happens, there won't really be anything to make
progress.

Maybe leave a TODO to explain?

[David Yen, 2015/09/18 22:39:58]

Yeah, at least currently it can't happen. If it does in the future, we would
also need to back off on calling "FinishProcessingOrderNumber" until the message
is rescheduled and processed. I can add a comment about this.

+  sync_point_client_->FinishProcessingOrderNumber(order_num);
 
   // If we've processed all pending commands but still have pending queries,
   // pump idle work until the query is passed.
   if (put_offset == state_after_last_flush_.get_offset &&
       (gpu_scheduler_->HasMoreIdleWork() ||
        gpu_scheduler_->HasPendingQueries())) {
     ScheduleDelayedWorkOnGpuThread();
   }
 }
 
@@ skipping 21 matching lines @@
 }
 
 void InProcessCommandBuffer::Flush(int32 put_offset) {
   CheckSequencedThread();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   if (last_put_offset_ == put_offset)
     return;
 
+  uint32_t order_num = sync_point_client_->GenerateUnprocessedOrderNumber();
   last_put_offset_ = put_offset;
   base::Closure task = base::Bind(&InProcessCommandBuffer::FlushOnGpuThread,
                                   gpu_thread_weak_ptr_,
-                                  put_offset);
+                                  put_offset,
+                                  order_num);
   QueueTask(task);
 }
 
 void InProcessCommandBuffer::OrderingBarrier(int32 put_offset) {
   Flush(put_offset);
 }
 
 void InProcessCommandBuffer::WaitForTokenInRange(int32 start, int32 end) {
   CheckSequencedThread();
   while (!InRange(start, end, GetLastToken()) &&
@@ skipping 416 matching lines @@
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu