Plumbing input event latency reporting through Mus GPU.

gpu/ipc/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/ipc/in_process_command_buffer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 166 matching lines @@
   }
   return program_cache_.get();
 }
 
 InProcessCommandBuffer::InProcessCommandBuffer(
     const scoped_refptr<Service>& service)
     : command_buffer_id_(CommandBufferId::FromUnsafeValue(
           g_next_command_buffer_id.GetNext() + 1)),
       delayed_work_pending_(false),
       image_factory_(nullptr),
+      latency_info_(base::MakeUnique<std::vector<ui::LatencyInfo>>()),
       gpu_control_client_(nullptr),
 #if DCHECK_IS_ON()
       context_lost_(false),
 #endif
       last_put_offset_(-1),
       gpu_memory_buffer_manager_(nullptr),
       next_fence_sync_release_(1),
       flushed_fence_sync_release_(0),
       flush_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                    base::WaitableEvent::InitialState::NOT_SIGNALED),
@@ skipping 327 matching lines @@
 void InProcessCommandBuffer::ProcessTasksOnGpuThread() {
   while (executor_->scheduled()) {
     base::AutoLock lock(task_queue_lock_);
     if (task_queue_.empty())
       break;
     GpuTask* task = task_queue_.front().get();
     sync_point_order_data_->BeginProcessingOrderNumber(task->order_number);
     task->callback.Run();
     if (!executor_->scheduled() && !service_->BlockThreadOnWaitSyncToken()) {
       sync_point_order_data_->PauseProcessingOrderNumber(task->order_number);
+      // Don't pop the task if it was preempted - it may have been preempted, so
+      // we need to execute it again later.
       return;
     }
     sync_point_order_data_->FinishProcessingOrderNumber(task->order_number);
     task_queue_.pop();
   }
 }
 
 CommandBuffer::State InProcessCommandBuffer::GetLastState() {
   CheckSequencedThread();
   base::AutoLock lock(last_state_lock_);
   return last_state_;
 }
 
 void InProcessCommandBuffer::UpdateLastStateOnGpuThread() {
   CheckSequencedThread();
   command_buffer_lock_.AssertAcquired();
   base::AutoLock lock(last_state_lock_);
   State state = command_buffer_->GetLastState();
   if (state.generation - last_state_.generation < 0x80000000U)
     last_state_ = state;
 }
 
-void InProcessCommandBuffer::FlushOnGpuThread(int32_t put_offset) {
+void InProcessCommandBuffer::FlushOnGpuThread(
+    int32_t put_offset,
+    std::vector<ui::LatencyInfo>* latency_info) {
   CheckSequencedThread();
   ScopedEvent handle_flush(&flush_event_);
   base::AutoLock lock(command_buffer_lock_);
 
+  // Need to run the latency callback before Flush().
+  if (ui::LatencyInfo::Verify(*latency_info,
+                              "InProcessCommandBuffer::FlushOnGpuThread") &&
+      !latency_info_callback_.is_null()) {
+    if (!latency_info->empty()) {
+      latency_info_callback_.Run(*latency_info);
+      // FlushOnGpuThread task might be preempted and re-executed (see
+      // ProcessTasksOnGpuThread), so clear the |latency_info| to prevent
+      // executing |latency_info_callback_| multiple times with the same data.
+      latency_info->clear();
+    }
+  }
+
   command_buffer_->Flush(put_offset);
   // Update state before signaling the flush event.
   UpdateLastStateOnGpuThread();
 
   // If we've processed all pending commands but still have pending queries,
   // pump idle work until the query is passed.
   if (put_offset == command_buffer_->GetLastState().get_offset &&
       (executor_->HasMoreIdleWork() || executor_->HasPendingQueries())) {
     ScheduleDelayedWorkOnGpuThread();
   }
@@ skipping 25 matching lines @@
 void InProcessCommandBuffer::Flush(int32_t put_offset) {
   CheckSequencedThread();
   if (GetLastState().error != gpu::error::kNoError)
     return;
 
   if (last_put_offset_ == put_offset)
     return;
 
   last_put_offset_ = put_offset;
   base::Closure task = base::Bind(&InProcessCommandBuffer::FlushOnGpuThread,
-                                  gpu_thread_weak_ptr_, put_offset);
+                                  gpu_thread_weak_ptr_, put_offset,
+                                  base::Owned(latency_info_.release()));
+  latency_info_.reset(new std::vector<ui::LatencyInfo>);
   QueueTask(false, task);
 
   flushed_fence_sync_release_ = next_fence_sync_release_ - 1;
 }
 
 void InProcessCommandBuffer::OrderingBarrier(int32_t put_offset) {
   Flush(put_offset);
 }
 
 CommandBuffer::State InProcessCommandBuffer::WaitForTokenInRange(int32_t start,
@@ skipping 367 matching lines @@
                  base::Unretained(this), sync_token, WrapCallback(callback)));
 }
 
 void InProcessCommandBuffer::WaitSyncTokenHint(const SyncToken& sync_token) {}
 
 bool InProcessCommandBuffer::CanWaitUnverifiedSyncToken(
     const SyncToken& sync_token) {
   return sync_token.namespace_id() == GetNamespaceID();
 }
 
+void InProcessCommandBuffer::AddLatencyInfo(
+    const std::vector<ui::LatencyInfo>& latency_info) {
+  latency_info_->insert(latency_info_->end(), latency_info.begin(),
+                        latency_info.end());
+}
+
 #if defined(OS_WIN)
 void InProcessCommandBuffer::DidCreateAcceleratedSurfaceChildWindow(
     SurfaceHandle parent_window,
     SurfaceHandle child_window) {
   ::SetParent(child_window, parent_window);
 }
 #endif
 
 void InProcessCommandBuffer::DidSwapBuffersComplete(
     SwapBuffersCompleteParams params) {
   if (!origin_task_runner_) {
     DidSwapBuffersCompleteOnOriginThread(std::move(params));
     return;
   }
   origin_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&InProcessCommandBuffer::DidSwapBuffersCompleteOnOriginThread,
                  client_thread_weak_ptr_, base::Passed(&params)));
 }
 
 const gles2::FeatureInfo* InProcessCommandBuffer::GetFeatureInfo() const {
   return context_group_->feature_info();
 }
 
 void InProcessCommandBuffer::SetLatencyInfoCallback(
     const LatencyInfoCallback& callback) {
-  // TODO(fsamuel): Implement this.
+  latency_info_callback_ = callback;
 }
 
 void InProcessCommandBuffer::UpdateVSyncParameters(base::TimeTicks timebase,
                                                    base::TimeDelta interval) {
   if (!origin_task_runner_) {
     UpdateVSyncParametersOnOriginThread(timebase, interval);
     return;
   }
   origin_task_runner_->PostTask(
       FROM_HERE,
@@ skipping 93 matching lines @@
   return wrapped_callback;
 }
 
 InProcessCommandBuffer::GpuTask::GpuTask(const base::Closure& callback,
                                          uint32_t order_number)
     : callback(callback), order_number(order_number) {}
 
 InProcessCommandBuffer::GpuTask::~GpuTask() {}
 
 }  // namespace gpu