WIP: 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 266 matching lines @@
   completion.Wait();
 
   gpu_memory_buffer_manager_ = gpu_memory_buffer_manager;
 
   if (result)
     capabilities_ = capabilities;
 
   return result;
 }
 
+void InProcessCommandBuffer::SetLatencyInfo(const std::vector<ui::LatencyInfo>& latency_info) {
+  latency_info_.insert(latency_info_.end(), latency_info.begin(), latency_info.end());
+}
+
 bool InProcessCommandBuffer::InitializeOnGpuThread(
     const InitializeOnGpuThreadParams& params) {
   CheckSequencedThread();
   gpu_thread_weak_ptr_ = gpu_thread_weak_ptr_factory_.GetWeakPtr();
 
   TransferBufferManager* manager = new TransferBufferManager(nullptr);
   transfer_buffer_manager_ = manager;
   manager->Initialize();
 
   std::unique_ptr<CommandBufferService> command_buffer(
@@ skipping 251 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_,
+                              "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 439 matching lines @@
       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