Fix WebVR support for devices without Async Reprojection.

chrome/browser/android/vr_shell/vr_shell.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.h"
 
+#include <android/native_window_jni.h>
+
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/android/vr_shell/ui_interface.h"
 #include "chrome/browser/android/vr_shell/vr_compositor.h"
 #include "chrome/browser/android/vr_shell/vr_input_manager.h"
 #include "chrome/browser/android/vr_shell/vr_shell_delegate.h"
@@ skipping 24 matching lines @@
 
 static const char kVrShellUIURL[] = "chrome://vr-shell-ui";
 
 class GLThread : public base::Thread {
  public:
   GLThread(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)
       : base::Thread("VrShellGL"),
         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)),
         gvr_api_(gvr_api),
-        initially_web_vr_(initially_web_vr) {}
+        initially_web_vr_(initially_web_vr),
+        reprojected_rendering_(reprojected_rendering) {}
 
   ~GLThread() override {
     Stop();
   }
   base::WeakPtr<VrShellGl> GetVrShellGl() { return weak_vr_shell_gl_; }
   VrShellGl* GetVrShellGlUnsafe() { return vr_shell_gl_.get(); }
 
  protected:
   void Init() override {
     vr_shell_gl_.reset(new VrShellGl(std::move(weak_vr_shell_),
                                      std::move(content_input_manager_),
                                      std::move(ui_input_manager_),
                                      std::move(main_thread_task_runner_),
                                      gvr_api_,
-                                     initially_web_vr_));
+                                     initially_web_vr_,
+                                     reprojected_rendering_));
     weak_vr_shell_gl_ = vr_shell_gl_->GetWeakPtr();
-    if (!vr_shell_gl_->Initialize()) {
-      vr_shell_gl_.reset();
-    }
+    vr_shell_gl_->Initialize();
   }
   void CleanUp() override {
     vr_shell_gl_.reset();
   }
 
  private:
   // Created on GL thread.
   std::unique_ptr<VrShellGl> vr_shell_gl_;
   base::WeakPtr<VrShellGl> weak_vr_shell_gl_;
 
   base::WeakPtr<VrShell> weak_vr_shell_;
   base::WeakPtr<VrInputManager> content_input_manager_;
   base::WeakPtr<VrInputManager> ui_input_manager_;
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
   gvr_context* gvr_api_;
   bool initially_web_vr_;
+  bool reprojected_rendering_;
 };
 
 }  // namespace
 
 VrShell::VrShell(JNIEnv* env,
                  jobject obj,
                  content::WebContents* main_contents,
                  ui::WindowAndroid* content_window,
                  content::WebContents* ui_contents,
                  ui::WindowAndroid* ui_window,
                  bool for_web_vr,
                  VrShellDelegate* delegate,
-                 gvr_context* gvr_api)
+                 gvr_context* gvr_api,
+                 bool reprojected_rendering)
     : WebContentsObserver(ui_contents),
       main_contents_(main_contents),
       content_compositor_(new VrCompositor(content_window, false)),
       ui_contents_(ui_contents),
       ui_compositor_(new VrCompositor(ui_window, true)),
       delegate_(delegate),
       metrics_helper_(new VrMetricsHelper(main_contents_)),
       main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      reprojected_rendering_(reprojected_rendering),
       weak_ptr_factory_(this) {
   DCHECK(g_instance == nullptr);
   g_instance = this;
   j_vr_shell_.Reset(env, obj);
 
   content_input_manager_.reset(new VrInputManager(main_contents_));
   ui_input_manager_.reset(new VrInputManager(ui_contents_));
 
   content_compositor_->SetLayer(main_contents_);
   ui_compositor_->SetLayer(ui_contents_);
 
   gl_thread_.reset(new GLThread(weak_ptr_factory_.GetWeakPtr(),
                                 content_input_manager_->GetWeakPtr(),
                                 ui_input_manager_->GetWeakPtr(),
                                 main_thread_task_runner_,
                                 gvr_api,
-                                for_web_vr));
+                                for_web_vr,
+                                reprojected_rendering_));
 
   base::Thread::Options options(base::MessageLoop::TYPE_DEFAULT, 0);
   options.priority = base::ThreadPriority::DISPLAY;
   gl_thread_->StartWithOptions(options);
 
   if (for_web_vr)
     metrics_helper_->SetWebVREnabled(true);
   html_interface_.reset(new UiInterface(
       for_web_vr ? UiInterface::Mode::WEB_VR : UiInterface::Mode::STANDARD,
       main_contents_->IsFullscreen()));
@@ skipping 66 matching lines @@
 void VrShell::OnResume(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   thread->task_runner()->PostTask(
       FROM_HERE, base::Bind(&VrShellGl::OnResume, thread->GetVrShellGl()));
 
   // exit vr session
   metrics_helper_->SetVRActive(true);
   SetShowingOverscrollGlow(false);
 }
 
+void VrShell::SetSurface(JNIEnv* env,
+                         const JavaParamRef<jobject>& obj,
+                         const JavaParamRef<jobject>& surface) {
+  CHECK(!reprojected_rendering_);
+  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
+  gfx::AcceleratedWidget window =
+      ANativeWindow_fromSurface(base::android::AttachCurrentThread(), surface);
+  PostToGlThreadWhenReady(base::Bind(&VrShellGl::InitializeGl,
+                                     thread->GetVrShellGl(),
+                                     base::Unretained(window)));
+}
+
 void VrShell::SetShowingOverscrollGlow(bool showing_glow) {
   main_contents_->GetRenderWidgetHostView()->SetShowingOverscrollGlow(
       showing_glow);
 }
 
 base::WeakPtr<VrShell> VrShell::GetWeakPtr(
     const content::WebContents* web_contents) {
   // Ensure that the WebContents requesting the VrShell instance is the one
   // we created.
   if (g_instance != nullptr && g_instance->ui_contents_ == web_contents)
@@ skipping 218 matching lines @@
 // ----------------------------------------------------------------------------
 // Native JNI methods
 // ----------------------------------------------------------------------------
 
 jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj,
            const JavaParamRef<jobject>& content_web_contents,
            jlong content_window_android,
            const JavaParamRef<jobject>& ui_web_contents,
            jlong ui_window_android, jboolean for_web_vr,
            const base::android::JavaParamRef<jobject>& delegate,
-           jlong gvr_api) {
+           jlong gvr_api, jboolean reprojected_rendering) {
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, content::WebContents::FromJavaWebContents(content_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(content_window_android),
       content::WebContents::FromJavaWebContents(ui_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(ui_window_android),
       for_web_vr, VrShellDelegate::GetNativeDelegate(env, delegate),
-      reinterpret_cast<gvr_context*>(gvr_api)));
+      reinterpret_cast<gvr_context*>(gvr_api), reprojected_rendering));
 }
 
 }  // namespace vr_shell