Fix WebVR support for devices without Async Reprojection.

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 "base/android/jni_android.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/android/vr_shell/ui_elements.h"
 #include "chrome/browser/android/vr_shell/ui_scene.h"
 #include "chrome/browser/android/vr_shell/vr_controller.h"
 #include "chrome/browser/android/vr_shell/vr_gl_util.h"
 #include "chrome/browser/android/vr_shell/vr_input_manager.h"
 #include "chrome/browser/android/vr_shell/vr_math.h"
 #include "chrome/browser/android/vr_shell/vr_shell.h"
@@ skipping 149 matching lines @@
   VLOG(1) << "WebVR: reject decoded pose index " << (int)pixels[0] <<
       ", bad magic number " << (int)pixels[1] << ", " << (int)pixels[2];
   return -1;
 }
 
 int64_t TimeInMicroseconds() {
   return std::chrono::duration_cast<std::chrono::microseconds>(
       std::chrono::steady_clock::now().time_since_epoch()).count();
 }
 
+void WaitForSwapAck(const base::Closure& callback, gfx::SwapResult result) {
+  callback.Run();
+}
+
 }  // namespace
 
 VrShellGl::VrShellGl(
     const base::WeakPtr<VrShell>& weak_vr_shell,
     const base::WeakPtr<VrInputManager>& content_input_manager,
     const base::WeakPtr<VrInputManager>& ui_input_manager,
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
     gvr_context* gvr_api,
-    bool initially_web_vr)
+    bool initially_web_vr,
+    bool reprojected_rendering)
       : web_vr_mode_(initially_web_vr),
+        surfaceless_rendering_(reprojected_rendering),
         task_runner_(base::ThreadTaskRunnerHandle::Get()),
         weak_vr_shell_(weak_vr_shell),
         content_input_manager_(content_input_manager),
         ui_input_manager_(ui_input_manager),
         main_thread_task_runner_(std::move(main_thread_task_runner)),
         weak_ptr_factory_(this) {
   GvrInit(gvr_api);
 }
 
 VrShellGl::~VrShellGl() {
   draw_task_.Cancel();
 }
 
-bool VrShellGl::Initialize() {
-  if (!InitializeGl()) return false;
-
+void VrShellGl::Initialize() {
   gvr::Mat4f identity;
   SetIdentityM(identity);
   webvr_head_pose_.resize(kPoseRingBufferSize, identity);
   webvr_head_pose_valid_.resize(kPoseRingBufferSize, false);
 
-  draw_task_.Reset(base::Bind(&VrShellGl::DrawFrame, base::Unretained(this)));
-
   scene_.reset(new UiScene);
 
-  InitializeRenderer();
-
-  ScheduleNextDrawFrame();
-  return true;
+  if (surfaceless_rendering_) {
+    // If we're rendering surfaceless, we'll never get a java surface to render
+    // into, so we can initialize GL right away.
+    InitializeGl(nullptr);
+  }
 }
 
-bool VrShellGl::InitializeGl() {
+void VrShellGl::InitializeGl(gfx::AcceleratedWidget window) {
+  CHECK(!ready_to_draw_);

[bshe, 2017/01/04 16:40:23]

optional nit: rename to gl_initialized_?

[mthiesse, 2017/01/04 16:58:09]

I think ready_to_draw_ is clearer. GL being initialized doesn't necessarily mean
we're ready to enter our render loop.

   if (gl::GetGLImplementation() == gl::kGLImplementationNone &&
       !gl::init::InitializeGLOneOff()) {
     LOG(ERROR) << "gl::init::InitializeGLOneOff failed";
     ForceExitVr();
-    return false;
+    return;
   }
-  surface_ = gl::init::CreateOffscreenGLSurface(gfx::Size());
+  if (window) {
+    CHECK(!surfaceless_rendering_);
+    surface_ = gl::init::CreateViewGLSurface(window);
+  } else {
+    CHECK(surfaceless_rendering_);
+    surface_ = gl::init::CreateOffscreenGLSurface(gfx::Size());
+  }
   if (!surface_.get()) {
     LOG(ERROR) << "gl::init::CreateOffscreenGLSurface failed";
     ForceExitVr();
-    return false;
+    return;
   }
   context_ = gl::init::CreateGLContext(nullptr, surface_.get(),
                                        gl::GLContextAttribs());
   if (!context_.get()) {
     LOG(ERROR) << "gl::init::CreateGLContext failed";
     ForceExitVr();
-    return false;
+    return;
   }
   if (!context_->MakeCurrent(surface_.get())) {
     LOG(ERROR) << "gl::GLContext::MakeCurrent() failed";
     ForceExitVr();
-    return false;
+    return;
   }
 
   // TODO(mthiesse): We don't appear to have a VSync provider ever here. This is
   // sort of okay, because the GVR swap chain will block if we render too fast,
   // but we should address this properly.
   if (surface_->GetVSyncProvider()) {
     surface_->GetVSyncProvider()->GetVSyncParameters(base::Bind(
         &VrShellGl::UpdateVSyncParameters, weak_ptr_factory_.GetWeakPtr()));
   } else {
     LOG(ERROR) << "No VSync Provider";
@@ skipping 15 matching lines @@
 
   content_surface_texture_->SetDefaultBufferSize(
       content_tex_physical_size_.width, content_tex_physical_size_.height);
   ui_surface_texture_->SetDefaultBufferSize(ui_tex_physical_size_.width,
                                             ui_tex_physical_size_.height);
 
   main_thread_task_runner_->PostTask(FROM_HERE, base::Bind(
       &VrShell::SurfacesChanged, weak_vr_shell_,
       content_surface_->j_surface().obj(),
       ui_surface_->j_surface().obj()));
-  return true;
+
+  InitializeRenderer();
+
+  draw_task_.Reset(base::Bind(&VrShellGl::DrawFrame, base::Unretained(this)));
+  ScheduleNextDrawFrame();
+
+  ready_to_draw_ = true;
+
+  return;

[bshe, 2017/01/04 16:40:23]

nit: remove return

[mthiesse, 2017/01/04 16:58:09]

Done.

 }
 
 void VrShellGl::OnUIFrameAvailable() {
   ui_surface_texture_->UpdateTexImage();
 }
 
 void VrShellGl::OnContentFrameAvailable() {
   content_surface_texture_->UpdateTexImage();
 }
 
@@ skipping 92 matching lines @@
                                            webvr_right_viewport_.get());
   webvr_right_viewport_->SetSourceBufferIndex(kFramePrimaryBuffer);
 
   main_thread_task_runner_->PostTask(FROM_HERE, base::Bind(
       &VrShell::GvrDelegateReady, weak_vr_shell_));
 }
 
 void VrShellGl::UpdateController(const gvr::Vec3f& forward_vector) {
   controller_->UpdateState();
 
-
   // Note that button up/down state is transient, so ButtonUpHappened only
   // returns true for a single frame (and we're guaranteed not to miss it).
   if (controller_->ButtonUpHappened(
           gvr::ControllerButton::GVR_CONTROLLER_BUTTON_APP)) {
     main_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&VrShell::AppButtonPressed, weak_vr_shell_));
   }
 
   if (web_vr_mode_) {
     // Process screen touch events for Cardboard button compatibility.
@@ skipping 257 matching lines @@
         webvr_right_viewport_->SetReprojection(GVR_REPROJECTION_NONE);
       }
     }
   }
 
   DrawVrShell(head_pose, frame);
 
   frame.Unbind();
   frame.Submit(*buffer_viewport_list_, head_pose);
 
-  // No need to SwapBuffers for an offscreen surface.
-  ScheduleNextDrawFrame();
+  // No need to swap buffers for surfaceless rendering.
+  if (surfaceless_rendering_) {
+    ScheduleNextDrawFrame();
+    return;
+  }
+
+  if (surface_->SupportsAsyncSwap()) {
+    surface_->SwapBuffersAsync(base::Bind(&WaitForSwapAck, base::Bind(
+        &VrShellGl::ScheduleNextDrawFrame, weak_ptr_factory_.GetWeakPtr())));
+  } else {
+    surface_->SwapBuffers();
+    ScheduleNextDrawFrame();
+  }
 }
 
 void VrShellGl::DrawVrShell(const gvr::Mat4f& head_pose,
                             gvr::Frame &frame) {
   TRACE_EVENT0("gpu", "VrShellGl::DrawVrShell");
   std::vector<const ContentRectangle*> head_locked_elements;
   std::vector<const ContentRectangle*> world_elements;
   for (const auto& rect : scene_->GetUiElements()) {
     if (!rect->visible) {
       continue;
@@ skipping 211 matching lines @@
 void VrShellGl::OnPause() {
   draw_task_.Cancel();
   controller_->OnPause();
   gvr_api_->PauseTracking();
 }
 
 void VrShellGl::OnResume() {
   gvr_api_->RefreshViewerProfile();
   gvr_api_->ResumeTracking();
   controller_->OnResume();
-  draw_task_.Reset(base::Bind(&VrShellGl::DrawFrame, base::Unretained(this)));
-  ScheduleNextDrawFrame();
+  if (ready_to_draw_) {
+    draw_task_.Reset(base::Bind(&VrShellGl::DrawFrame, base::Unretained(this)));
+    ScheduleNextDrawFrame();
+  }
 }
 
 void VrShellGl::SetWebVrMode(bool enabled) {
   web_vr_mode_ = enabled;
 }
 
 void VrShellGl::UpdateWebVRTextureBounds(const gvr::Rectf& left_bounds,
                                          const gvr::Rectf& right_bounds) {
   webvr_left_viewport_->SetSourceUv(left_bounds);
   webvr_right_viewport_->SetSourceUv(right_bounds);
@@ skipping 56 matching lines @@
 void VrShellGl::ForceExitVr() {
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VrShell::ForceExitVr, weak_vr_shell_));
 }
 
 void VrShellGl::UpdateScene(std::unique_ptr<base::ListValue> commands) {
   scene_->HandleCommands(std::move(commands), TimeInMicroseconds());
 }
 
 }  // namespace vr_shell