Add SlidingAverage to FPSMeter, use for WebVR prediction time

chrome/browser/android/vr_shell/vr_shell_gl.cc

 // Copyright 2016 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 "chrome/browser/android/vr_shell/vr_shell_gl.h"
 
 #include <chrono>
 #include <limits>
 #include <utility>
 
@@ skipping 64 matching lines @@
 
 // The GVR viewport list has two entries (left eye and right eye) for each
 // GVR buffer.
 static constexpr int kViewportListPrimaryOffset = 0;
 static constexpr int kViewportListHeadlockedOffset = 2;
 
 // Buffer size large enough to handle the current backlog of poses which is
 // 2-3 frames.
 static constexpr unsigned kPoseRingBufferSize = 8;
 
+// Number of frames to use for sliding averages for pose timings,
+// as used for estimating prediction times.
+static constexpr unsigned kWebVRSlidingAverageSize = 5;
+
 // Criteria for considering holding the app button in combination with
 // controller movement as a gesture.
 static constexpr float kMinAppButtonGestureAngleRad = 0.25;
 
 static constexpr gfx::PointF kInvalidTargetPoint =
     gfx::PointF(std::numeric_limits<float>::max(),
                 std::numeric_limits<float>::max());
 
 // Generate a quaternion representing the rotation from the negative Z axis
 // (0, 0, -1) to a specified vector. This is an optimized version of a more
@@ skipping 124 matching lines @@
     : web_vr_mode_(initially_web_vr),
       surfaceless_rendering_(reprojected_rendering),
       daydream_support_(daydream_support),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       binding_(this),
       browser_(browser),
       scene_(scene),
 #if DCHECK_IS_ON()
       fps_meter_(new FPSMeter()),
 #endif
+      webvr_js_time_(new SlidingAverage(kWebVRSlidingAverageSize)),
+      webvr_render_time_(new SlidingAverage(kWebVRSlidingAverageSize)),
       weak_ptr_factory_(this) {
   GvrInit(gvr_api);
 }
 
 VrShellGl::~VrShellGl() {
   vsync_task_.Cancel();
   // TODO(mthiesse): Can we omit the Close() here? Concern is that if
   // both ends of the connection ever live in the same process for
   // some reason, we could receive another VSync request in response
   // to the closing message in the destructor but fail to respond to
@@ skipping 1278 matching lines @@
 void VrShellGl::ForceExitVr() {
   browser_->ForceExitVr();
 }
 
 void VrShellGl::SendVSync(base::TimeDelta time,
                           const GetVSyncCallback& callback) {
   uint8_t frame_index = frame_index_++;
 
   TRACE_EVENT1("input", "VrShellGl::SendVSync", "frame", frame_index);
 
+  int64_t frame_time_micros = vsync_interval_.InMicroseconds();

[cjgrant, 2017/05/24 13:37:30]

How do you feel about dropping this block into
VrShellGl::GetPredictedFrameTime() or similar?

[klausw, 2017/05/24 16:32:23]

Done, I've also added TRACE_COUNTER output so that these (+ FPS) get graphed in
event traces. 

+  // If we aim to submit at vsync, that frame will start scanning out
+  // one vsync later. Add a half frame to split the difference between
+  // left and right eye.
+  int64_t overhead_micros = frame_time_micros * 3 / 2;
+  int64_t expected_frame_time =
+      webvr_js_time_->GetAverageOrDefault(frame_time_micros) +
+      webvr_render_time_->GetAverageOrDefault(frame_time_micros);
+  int64_t prediction_nanos = (expected_frame_time + overhead_micros) * 1000;
+
   vr::Mat4f head_mat;
   device::mojom::VRPosePtr pose =
-      device::GvrDelegate::GetVRPosePtrWithNeckModel(gvr_api_.get(), &head_mat);
+      device::GvrDelegate::GetVRPosePtrWithNeckModel(gvr_api_.get(), &head_mat,
+                                                     prediction_nanos);
 
   webvr_head_pose_[frame_index % kPoseRingBufferSize] = head_mat;
 
   callback.Run(std::move(pose), time, frame_index,
                device::mojom::VRVSyncProvider::Status::SUCCESS);
 }
 
 void VrShellGl::CreateVRDisplayInfo(
     const base::Callback<void(device::mojom::VRDisplayInfoPtr)>& callback,
     uint32_t device_id) {
   // This assumes that the initial webvr_surface_size_ was set to the
   // appropriate recommended render resolution as the default size during
   // InitializeGl. Revisit if the initialization order changes.
   device::mojom::VRDisplayInfoPtr info =
       device::GvrDelegate::CreateVRDisplayInfo(gvr_api_.get(),
                                                webvr_surface_size_, device_id);
   browser_->RunVRDisplayInfoCallback(callback, &info);
 }
 
 }  // namespace vr_shell