Allow VRDisplay to specify which frame the layer bounds should be updated at.

chrome/browser/android/vr_shell/non_presenting_gvr_delegate.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/non_presenting_gvr_delegate.h"
 
 #include "chrome/browser/android/vr_shell/vr_shell.h"
 
 namespace vr_shell {
 
@@ skipping 42 matching lines @@
 NonPresentingGvrDelegate::OnSwitchToPresentingDelegate() {
   StopVSyncLoop();
   if (binding_.is_bound())
     return binding_.Unbind();
   return nullptr;
 }
 
 void NonPresentingGvrDelegate::StopVSyncLoop() {
   vsync_task_.Cancel();
   if (!callback_.is_null())
-    callback_.Run(nullptr, base::TimeDelta());
+    callback_.Run(nullptr, base::TimeDelta(), -1);
   callback_.Reset();
   gvr_api_->PauseTracking();
   paused_ = false;
 }
 
 void NonPresentingGvrDelegate::StartVSyncLoop() {
   vsync_task_.Reset(
       base::Bind(&NonPresentingGvrDelegate::OnVSync, base::Unretained(this)));
   gvr_api_->RefreshViewerProfile();
   gvr_api_->ResumeTracking();
@@ skipping 15 matching lines @@
   target = now + vsync_interval_;
   int64_t intervals = (target - vsync_timebase_) / vsync_interval_;
   target = vsync_timebase_ + intervals * vsync_interval_;
   if (!vsync_task_.IsCancelled()) {
     task_runner_->PostDelayedTask(FROM_HERE, vsync_task_.callback(),
                                   target - now);
   }
 
   base::TimeDelta time = intervals * vsync_interval_;
   if (!callback_.is_null()) {
-    callback_.Run(GetPose(), time);
-    callback_.Reset();
+    SendVSync(time, std::move(callback_));
   } else {
     pending_vsync_ = true;
     pending_time_ = time;
   }
 }
 
 void NonPresentingGvrDelegate::GetVSync(const GetVSyncCallback& callback) {
   if (!pending_vsync_) {
     if (!callback_.is_null()) {
       mojo::ReportBadMessage("Requested VSync before waiting for response to "
           "previous request.");
       return;
     }
     callback_ = std::move(callback);
     return;
   }
   pending_vsync_ = false;
-  callback.Run(GetPose(), pending_time_);
+  SendVSync(pending_time_, std::move(callback));

[dcheng, 2017/01/18 23:58:07]

Nit: std::move() here is a no-op

[mthiesse, 2017/01/19 01:19:08]

Done.

 }
 
 void NonPresentingGvrDelegate::UpdateVSyncInterval(long timebase_nanos,
                                                    double interval_seconds) {
   vsync_timebase_ = base::TimeTicks();
   vsync_timebase_ += base::TimeDelta::FromMicroseconds(timebase_nanos / 1000);
   vsync_interval_ = base::TimeDelta::FromSecondsD(interval_seconds);
   StartVSyncLoop();
 }
 
-device::mojom::VRPosePtr NonPresentingGvrDelegate::GetPose() {
+void NonPresentingGvrDelegate::SendVSync(const base::TimeDelta& time,
+                                         GetVSyncCallback callback) {
   gvr::ClockTimePoint target_time = gvr::GvrApi::GetTimePointNow();
   target_time.monotonic_system_time_nanos += kPredictionTimeWithoutVsyncNanos;
 
-  gvr::Mat4f head_mat =
-      gvr_api_->GetHeadSpaceFromStartSpaceRotation(target_time);
-  head_mat = gvr_api_->ApplyNeckModel(head_mat, 1.0f);
-
-  uint32_t pose_index = pose_index_++;
-
-  return VrShell::VRPosePtrFromGvrPose(head_mat, pose_index);
+  gvr::Mat4f head_mat = gvr_api_->ApplyNeckModel(
+      gvr_api_->GetHeadSpaceFromStartSpaceRotation(target_time), 1.0f);
+  callback.Run(VrShell::VRPosePtrFromGvrPose(head_mat), time, -1);
 }
 
 }  // namespace vr_shell