SetPreviousFrameSurface should copy latency info to the new surface

cc/surfaces/surface.cc

 // Copyright 2014 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 "cc/surfaces/surface.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 32 matching lines @@
 
   for (auto& observer : observers_)
     observer.OnSurfaceDiscarded(this);
   observers_.Clear();
 }
 
 void Surface::SetPreviousFrameSurface(Surface* surface) {
   DCHECK(surface);
   frame_index_ = surface->frame_index() + 1;
   previous_frame_surface_id_ = surface->surface_id();
+  CompositorFrame& frame = active_frame_ ? *active_frame_ : *pending_frame_;
+  surface->TakeLatencyInfo(&frame.metadata.latency_info);
+  surface->TakeLatencyInfoFromPendingFrame(&frame.metadata.latency_info);
 }
 
 void Surface::QueueFrame(CompositorFrame frame, const DrawCallback& callback) {
+  TakeLatencyInfoFromPendingFrame(&frame.metadata.latency_info);
+
   base::Optional<CompositorFrame> previous_pending_frame =
       std::move(pending_frame_);
   pending_frame_.reset();
 
   UpdateBlockingSurfaces(previous_pending_frame, frame);
 
   // Receive and track the resources referenced from the CompositorFrame
   // regardless of whether it's pending or active.
   factory_->ReceiveFromChild(frame.resource_list);
 
@@ skipping 205 matching lines @@
 }
 
 const CompositorFrame& Surface::GetPendingFrame() {
   DCHECK(pending_frame_);
   return pending_frame_.value();
 }
 
 void Surface::TakeLatencyInfo(std::vector<ui::LatencyInfo>* latency_info) {
   if (!active_frame_)
     return;
-  if (latency_info->empty()) {
-    active_frame_->metadata.latency_info.swap(*latency_info);
-    return;
-  }
-  std::copy(active_frame_->metadata.latency_info.begin(),
-            active_frame_->metadata.latency_info.end(),
-            std::back_inserter(*latency_info));
-  active_frame_->metadata.latency_info.clear();
+  TakeLatencyInfoFromFrame(&active_frame_.value(), latency_info);
 }
 
 void Surface::RunDrawCallbacks() {
   if (!draw_callback_.is_null()) {
     DrawCallback callback = draw_callback_;
     draw_callback_ = DrawCallback();
     callback.Run();
   }
 }
 
@@ skipping 25 matching lines @@
 
 void Surface::ClearCopyRequests() {
   if (active_frame_) {
     for (const auto& render_pass : active_frame_->render_pass_list) {
       for (const auto& copy_request : render_pass->copy_requests)
         copy_request->SendEmptyResult();
     }
   }
 }
 
+void Surface::TakeLatencyInfoFromPendingFrame(
+    std::vector<ui::LatencyInfo>* latency_info) {
+  if (!pending_frame_)
+    return;
+  TakeLatencyInfoFromFrame(&pending_frame_.value(), latency_info);
+}
+
+// static
+void Surface::TakeLatencyInfoFromFrame(
+    CompositorFrame* frame,
+    std::vector<ui::LatencyInfo>* latency_info) {
+  if (latency_info->empty()) {
+    frame->metadata.latency_info.swap(*latency_info);
+    return;
+  }
+  std::copy(frame->metadata.latency_info.begin(),
+            frame->metadata.latency_info.end(),
+            std::back_inserter(*latency_info));
+  frame->metadata.latency_info.clear();
+}
+
 }  // namespace cc