Added WebVR Render path to VrShell

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 "chrome/browser/android/vr_shell/vr_shell_renderer.h"
 #include "chrome/browser/android/vr_shell/vr_util.h"
 #include "jni/VrShell_jni.h"
 #include "ui/gl/gl_bindings.h"
@@ skipping 38 matching lines @@
   transfrom_to_world.m[3][2] = 0;
   transfrom_to_world.m[3][3] = 1;
 }
 
 void ContentRect::Translate(float x, float y, float z) {
   transfrom_to_world.m[0][3] += x;
   transfrom_to_world.m[1][3] += y;
   transfrom_to_world.m[2][3] += z;
 }
 
-VrShell::VrShell(JNIEnv* env, jobject obj) {
+VrShell::VrShell(JNIEnv* env, jobject obj) :
+    webvr_mode_(false) {
   j_vr_shell_.Reset(env, obj);
 }
 
 void VrShell::Destroy(JNIEnv* env,
                       const base::android::JavaParamRef<jobject>& obj) {
   delete this;
 }
 
 bool RegisterVrShell(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
-VrShell::~VrShell() {}
+VrShell::~VrShell() {
+  device::GvrDelegateManager::GetInstance()->Shutdown();

[David Trainor- moved to gerrit, 2016/09/08 06:16:05]

Just making sure, but we're ok if we call Shutdown with no Initialize call
right?

+}
 
 void VrShell::GvrInit(JNIEnv* env,
                       const base::android::JavaParamRef<jobject>& obj,
                       jlong native_gvr_api) {
   gvr_api_ =
       gvr::GvrApi::WrapNonOwned(reinterpret_cast<gvr_context*>(native_gvr_api));
+
+  device::GvrDelegateManager::GetInstance()->Initialize(this);
 }
 
 void VrShell::InitializeGl(JNIEnv* env,
                            const base::android::JavaParamRef<jobject>& obj,
                            jint texture_data_handle) {
   gl::init::InitializeGLOneOff();
   gvr_api_->InitializeGl();
   std::vector<gvr::BufferSpec> specs;
   specs.push_back(gvr_api_->CreateBufferSpec());
   render_size_ = specs[0].GetSize();
   swap_chain_.reset(new gvr::SwapChain(gvr_api_->CreateSwapchain(specs)));
   content_rect_.reset(new ContentRect());
   content_rect_->content_texture_handle =
       reinterpret_cast<int>(texture_data_handle);
   vr_shell_renderer_.reset(new VrShellRenderer());
   buffer_viewport_list_.reset(
       new gvr::BufferViewportList(gvr_api_->CreateEmptyBufferViewportList()));
   buffer_viewport_.reset(
       new gvr::BufferViewport(gvr_api_->CreateBufferViewport()));
 }
 
 void VrShell::DrawFrame(JNIEnv* env,
                         const base::android::JavaParamRef<jobject>& obj) {
   buffer_viewport_list_->SetToRecommendedBufferViewports();
   gvr::Frame frame = swap_chain_->AcquireFrame();
   gvr::ClockTimePoint target_time = gvr::GvrApi::GetTimePointNow();
   target_time.monotonic_system_time_nanos += kPredictionTimeWithoutVsyncNanos;
   head_pose_ = gvr_api_->GetHeadPoseInStartSpace(target_time);
 
+  // Bind back to the default framebuffer.
+  frame.BindBuffer(0);
+
+  if (webvr_mode_) {
+    DrawWebVr();
+  } else {
+    DrawVrShell();
+  }
+
+  frame.Unbind();
+  frame.Submit(*buffer_viewport_list_, head_pose_);
+}
+
+void VrShell::DrawVrShell() {
   // Content area positioning.
   content_rect_->SetIdentity();
   content_rect_->Translate(kContentRectPositionDefault.x,
                            kContentRectPositionDefault.y,
                            kContentRectPositionDefault.z);
 
   gvr::Mat4f left_eye_view_matrix =
-      MatrixMul(gvr_api_->GetEyeFromHeadMatrix(GVR_LEFT_EYE), head_pose_);
+    MatrixMul(gvr_api_->GetEyeFromHeadMatrix(GVR_LEFT_EYE), head_pose_);
   gvr::Mat4f right_eye_view_matrix =
       MatrixMul(gvr_api_->GetEyeFromHeadMatrix(GVR_RIGHT_EYE), head_pose_);
 
-  // Bind back to the default framebuffer.
-  frame.BindBuffer(0);
-
   // Use culling to remove back faces.
   glEnable(GL_CULL_FACE);
 
   // Enable depth testing.
   glEnable(GL_DEPTH_TEST);
   glEnable(GL_SCISSOR_TEST);
 
   glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
 
   // Enable transparency.
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
   buffer_viewport_list_->GetBufferViewport(GVR_LEFT_EYE,
                                            buffer_viewport_.get());
   DrawEye(left_eye_view_matrix, *buffer_viewport_);
   buffer_viewport_list_->GetBufferViewport(GVR_RIGHT_EYE,
                                            buffer_viewport_.get());
   DrawEye(right_eye_view_matrix, *buffer_viewport_);
-
-  frame.Unbind();
-  frame.Submit(*buffer_viewport_list_, head_pose_);
 }
 
 void VrShell::DrawEye(const gvr::Mat4f& view_matrix,
                       const gvr::BufferViewport& params) {
   gvr::Recti pixel_rect =
       CalculatePixelSpaceRect(render_size_, params.GetSourceUv());
   glViewport(pixel_rect.left, pixel_rect.bottom,
              pixel_rect.right - pixel_rect.left,
              pixel_rect.top - pixel_rect.bottom);
   glScissor(pixel_rect.left, pixel_rect.bottom,
@@ skipping 11 matching lines @@
 
 void VrShell::DrawContentRect() {
   gvr::Mat4f content_rect_combined_matrix =
       MatrixMul(view_matrix_, content_rect_->transfrom_to_world);
   content_rect_combined_matrix =
       MatrixMul(projection_matrix_, content_rect_combined_matrix);
   vr_shell_renderer_->GetTexturedQuadRenderer()->Draw(
       content_rect_->content_texture_handle, content_rect_combined_matrix);
 }
 
+void VrShell::DrawWebVr() {
+  // Don't need face culling, depth testing, blending, etc. Turn it all off.
+  glDisable(GL_CULL_FACE);
+  glDepthMask(GL_FALSE);
+  glDisable(GL_DEPTH_TEST);
+  glDisable(GL_SCISSOR_TEST);
+  glDisable(GL_BLEND);
+  glDisable(GL_POLYGON_OFFSET_FILL);
+
+  // Don't need to clear, since we're drawing over the entire render target.
+
+  glViewport(0, 0, render_size_.width, render_size_.height);
+  vr_shell_renderer_->GetWebVrRenderer()->Draw(
+      reinterpret_cast<int>(content_rect_->content_texture_handle));
+}
+
 void VrShell::OnPause(JNIEnv* env,
                       const base::android::JavaParamRef<jobject>& obj) {
   if (gvr_api_ == nullptr)
     return;
   gvr_api_->PauseTracking();
 }
 
 void VrShell::OnResume(JNIEnv* env,
                        const base::android::JavaParamRef<jobject>& obj) {
   if (gvr_api_ == nullptr)
     return;
   gvr_api_->RefreshViewerProfile();
   gvr_api_->ResumeTracking();
 }
 
+void VrShell::RequestWebVRPresent() {
+  webvr_mode_ = true;
+}
+
+void VrShell::ExitWebVRPresent() {
+  webvr_mode_ = false;
+}
+
+void VrShell::SubmitWebVRFrame() {
+}
+
+void VrShell::UpdateWebVRTextureBounds(
+    int eye, float left, float top, float width, float height) {
+  gvr::Rectf bounds = { left, top, width, height };
+  vr_shell_renderer_->GetWebVrRenderer()->UpdateTextureBounds(eye, bounds);
+}
+
+gvr::GvrApi* VrShell::gvr_api() {
+  return gvr_api_.get();
+}
+
 // ----------------------------------------------------------------------------
 // Native JNI methods
 // ----------------------------------------------------------------------------
 
 jlong Init(JNIEnv* env, const base::android::JavaParamRef<jobject>& obj) {
   VrShell* vrShell = new VrShell(env, obj);
   return reinterpret_cast<intptr_t>(vrShell);
 }
 
 }  // namespace vr_shell