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 540 matching lines @@
   State state = command_buffer_->GetLastState();
   if (state.generation - last_state_.generation < 0x80000000U)
     last_state_ = state;
 }
 
 void InProcessCommandBuffer::FlushOnGpuThread(int32_t put_offset) {
   CheckSequencedThread();
   ScopedEvent handle_flush(&flush_event_);
   base::AutoLock lock(command_buffer_lock_);
 
+  if (ui::LatencyInfo::Verify(latency_info_,

[piman, 2017/04/10 23:50:34]

latency_info_ is written on another thread (without lock), so it's unsafe to
read (or modify) here.

I think what should happen instead is that InProcessCommandBuffer::Flush should
extract the latency_info_ and pass it to the queued task (i.e. bound to this
function).

[mfomitchev, 2017/04/13 03:00:00]

Done.

+                              "InProcessCommandBuffer::FlushOnGpuThread") &&
+      !latency_info_callback_.is_null()) {
+    latency_info_callback_.Run(latency_info_);
+  }
+  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 413 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