Re-land^2 WebVR compositor bypass via BrowserMain context + mailbox

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 <utility>
 
 #include "base/callback_helpers.h"
 #include "chrome/browser/android/vr_shell/vr_shell.h"
 #include "third_party/gvr-android-sdk/src/libraries/headers/vr/gvr/capi/include/gvr.h"
 
 namespace vr_shell {
 
 namespace {
 static constexpr int64_t kPredictionTimeWithoutVsyncNanos = 50000000;
 }  // namespace
 
 NonPresentingGvrDelegate::NonPresentingGvrDelegate(gvr_context* context)
     : task_runner_(base::ThreadTaskRunnerHandle::Get()),
       binding_(this),
       weak_ptr_factory_(this) {
-  gvr_api_ = gvr::GvrApi::WrapNonOwned(context);
+  if (context)

[dcheng, 2017/03/08 07:23:39]

Just for my understanding: why can context be null

[klausw, 2017/03/08 08:11:09]

mthiesse@, can you clarify? You had suggested this change as part of the
lifecycle refactor. Was this to prevent crashes in error conditions?

[mthiesse, 2017/03/08 13:44:48]

Yeah, this is to prevent crashes in strange error conditions. See
VrShellDelegate#createNonPresentingNativeContext for the possible reasons a
context would fail to be created.

Basically, vr support can change at runtime in response to the user uninstalling
apps/clearing data/etc. so we could fail to create a context even after we
thought we had VR support and created a VR Display.

[klausw, 2017/03/08 16:56:26]

Added this as a comment. That is rather devious.

+    gvr_api_ = gvr::GvrApi::WrapNonOwned(context);
 }
 
 NonPresentingGvrDelegate::~NonPresentingGvrDelegate() {
   StopVSyncLoop();
 }
 
 void NonPresentingGvrDelegate::OnVRVsyncProviderRequest(
     device::mojom::VRVSyncProviderRequest request) {
   binding_.Close();
   binding_.Bind(std::move(request));
   binding_.set_connection_error_handler(
       base::Bind(&NonPresentingGvrDelegate::StopVSyncLoop,
                  weak_ptr_factory_.GetWeakPtr()));
   StartVSyncLoop();
 }
 
 void NonPresentingGvrDelegate::Pause() {
   vsync_task_.Cancel();
   vsync_paused_ = true;
-  gvr_api_->PauseTracking();
+  if (gvr_api_)
+    gvr_api_->PauseTracking();
 }
 
 void NonPresentingGvrDelegate::Resume() {
   if (!vsync_paused_)
     return;
   vsync_paused_ = false;
   StartVSyncLoop();
 }
 
 device::mojom::VRVSyncProviderRequest
 NonPresentingGvrDelegate::OnSwitchToPresentingDelegate() {
   StopVSyncLoop();
   if (binding_.is_bound())
     return binding_.Unbind();
   return nullptr;
 }
 
 void NonPresentingGvrDelegate::StopVSyncLoop() {
   vsync_task_.Cancel();
+  binding_.Close();
   if (!callback_.is_null()) {
     base::ResetAndReturn(&callback_)
         .Run(nullptr, base::TimeDelta(), -1,
-             device::mojom::VRVSyncProvider::Status::RETRY);
+             device::mojom::VRVSyncProvider::Status::CLOSING);
   }
-  gvr_api_->PauseTracking();
+  if (gvr_api_)
+    gvr_api_->PauseTracking();
   // If the loop is stopped, it's not considered to be paused.
   vsync_paused_ = false;
 }
 
 void NonPresentingGvrDelegate::StartVSyncLoop() {
   vsync_task_.Reset(
       base::Bind(&NonPresentingGvrDelegate::OnVSync, base::Unretained(this)));
-  gvr_api_->RefreshViewerProfile();
-  gvr_api_->ResumeTracking();
+  if (gvr_api_) {
+    gvr_api_->RefreshViewerProfile();
+    gvr_api_->ResumeTracking();
+  }
   OnVSync();
 }
 
 void NonPresentingGvrDelegate::OnVSync() {
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeTicks target;
 
   // Don't run the VSync loop if we're not bound.
   if (!binding_.is_bound()) {
     return;
@@ skipping 41 matching lines @@
   vsync_timebase_ += base::TimeDelta::FromMicroseconds(timebase_nanos / 1000);
   vsync_interval_ = base::TimeDelta::FromSecondsD(interval_seconds);
   StartVSyncLoop();
 }
 
 void NonPresentingGvrDelegate::SendVSync(base::TimeDelta time,
                                          const GetVSyncCallback& callback) {
   gvr::ClockTimePoint target_time = gvr::GvrApi::GetTimePointNow();
   target_time.monotonic_system_time_nanos += kPredictionTimeWithoutVsyncNanos;
 
+  if (!gvr_api_) {
+    callback.Run(device::mojom::VRPosePtr(nullptr), time, -1,
+                 device::mojom::VRVSyncProvider::Status::SUCCESS);
+    return;
+  }
+
   gvr::Mat4f head_mat = gvr_api_->ApplyNeckModel(
       gvr_api_->GetHeadSpaceFromStartSpaceRotation(target_time), 1.0f);
   callback.Run(VrShell::VRPosePtrFromGvrPose(head_mat), time, -1,
                device::mojom::VRVSyncProvider::Status::SUCCESS);
 }
 
 bool NonPresentingGvrDelegate::SupportsPresentation() {
   return false;
 }
 
 void NonPresentingGvrDelegate::ResetPose() {
   // Should never call RecenterTracking when using with Daydream viewers. On
   // those devices recentering should only be done via the controller.
   if (gvr_api_ && gvr_api_->GetViewerType() == GVR_VIEWER_TYPE_CARDBOARD)
     gvr_api_->RecenterTracking();
 }
 
 void NonPresentingGvrDelegate::CreateVRDisplayInfo(
     const base::Callback<void(device::mojom::VRDisplayInfoPtr)>& callback,
     uint32_t device_id) {
+  if (!gvr_api_) {
+    callback.Run(device::mojom::VRDisplayInfoPtr(nullptr));
+    return;
+  }
+
   callback.Run(VrShell::CreateVRDisplayInfo(
       gvr_api_.get(), device::kInvalidRenderTargetSize, device_id));
 }
 
 }  // namespace vr_shell