WIP: working copy-no-compositor path

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 "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"
 #include "chrome/browser/android/vr_shell/vr_shell_gl.h"
 #include "chrome/browser/android/vr_shell/vr_usage_monitor.h"
 #include "chrome/browser/android/vr_shell/vr_web_contents_observer.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/referrer.h"
 #include "device/vr/android/gvr/gvr_device_provider.h"
+#include "gpu/ipc/common/gpu_surface_tracker.h"
+#include "gpu/ipc/common/surface_handle.h"
 #include "jni/VrShellImpl_jni.h"
 #include "ui/android/view_android.h"
 #include "ui/android/window_android.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 
+#include <android/native_window.h>
+#include <android/native_window_jni.h>
+
 using base::android::JavaParamRef;
 using base::android::JavaRef;
 
 namespace vr_shell {
 
 namespace {
 vr_shell::VrShell* g_instance;
 
 static const char kVrShellUIURL[] = "chrome://vr-shell-ui";
 
@@ skipping 110 matching lines @@
   ui_contents_->GetController().LoadURL(
       url, content::Referrer(),
       ui::PageTransition::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string(""));
 }
 
 bool RegisterVrShell(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 VrShell::~VrShell() {
+  VLOG(1) << __FUNCTION__ << ": Destructor for presenting delegate and its gvr_api";
   {
     // The GvrLayout is, and must always be, used only on the UI thread, and the
     // GvrApi used for rendering should only be used from the GL thread as it's
     // not thread safe. However, the GvrLayout owns the GvrApi instance, and
     // when it gets shut down it deletes the GvrApi instance with it. Therefore,
     // we need to block shutting down the GvrLayout on stopping our GL thread
     // from using the GvrApi instance.
     // base::Thread::Stop, which is called when destroying the thread, asserts
     // that IO is allowed to prevent jank, but there shouldn't be any concerns
     // regarding jank in this case, because we're switching from 3D to 2D,
     // adding/removing a bunch of Java views, and probably changing device
     // orientation here.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     gl_thread_.reset();

[artem.bolgar, 2017/02/28 21:40:22]

gl_thread_.reset() kills VrShellGl instance along with the WebVR SurfaceTexture
(if it was in use). However, the GPU and VRDisplay still use that and therefore,
you most likely will see the similar to 'BufferQueueProducer:
[SurfaceTexture-3-16381-2] dequeueBuffer: BufferQueue has been abandoned' error
message in the logcat each time you exit WebVR. You may destroy the WebVR
SurfaceTexture after the VRDisplay calls
m_renderingContext->setSurfaceHandle(0).

What I did to fix the problem (I hope, there is a better/easier way, though):
1) Added OnExitWebVR() => (); into 'interface VRDisplayClient'
2) Implemented it the following way:

void VRDisplay::OnExitWebVR(const OnExitWebVRCallback& callback) {
  VLOG(1) << __FUNCTION__;
  if (m_surfaceHandle && m_renderingContext) {
    m_renderingContext->setSurfaceHandle(0);
    VLOG(1) << " setSurfaceHandle(0); was just called";
    m_surfaceHandle = 0;
  }
  callback.Run();
}

3) In vr_shell.cc I've changed the dtor by adding creation of the callback (from
VrShellGl and passing it to delegate_->device_provider():

VrShell::~VrShell() {
  VLOG(1) << __FUNCTION__ << ": Destructor for presenting delegate";

  // must be done before killing GL thread, otherwise you'll get "BufferQueue
has been abandoned" error in logcat.
  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
  base::Callback<void()> cleanupCallback =
thread->GetVrShellGlUnsafe()->GetWebVrSurfaceCleanupCallback();

....  gl_thread_.reset();

  if (delegate_->device_provider()) {
    delegate_->device_provider()->OnWebVrCleanup(cleanupCallback);
  }


4) In vr_shell_gl.cc I've implemented a WebVRCleaner callback:

// A class that performs async cleanup of WebVR surface. The Clean method is
called by the VRDisplay class
// once WebVR surface is not used anymore.
class WebVRCleaner {
public:
  WebVRCleaner(scoped_refptr<gl::SurfaceTexture>& webvr_surface_texture) :
webvr_surface_texture_(webvr_surface_texture) {}
  ~WebVRCleaner() { DVLOG(1) << __FUNCTION__; }

  void Clean() {
    DVLOG(1) << __FUNCTION__;
    webvr_surface_texture_ = nullptr;
  }

  scoped_refptr<gl::SurfaceTexture> webvr_surface_texture_;
};

base::Callback<void()> VrShellGl::GetWebVrSurfaceCleanupCallback() {
  VLOG(1) << __FUNCTION__;
  WebVRCleaner* cleaner = new WebVRCleaner(webvr_surface_texture_);
  return base::Bind(&WebVRCleaner::Clean, base::Owned(cleaner));
}

5) Added:
 
void GvrDeviceProvider::OnWebVrCleanup(const WebVrCleanupCallback&
cleanupCallback) {
  VLOG(1) << __FUNCTION__;
  if (!vr_device_) {
    cleanupCallback.Run();
    return;
  }

  vr_device_->OnExitWebVR(cleanupCallback);
}

and 

void VRDevice::OnExitWebVR(const OnExitWebVRCallback& callback) {
  for (const auto& display : displays_) {
    display->client()->OnExitWebVR(callback);
    break; // really need only one display for now //??? @revise
  }
}

Thus, destruction of the VrShell will cause async call to content process, that
will reset the surface and then will call the callback that holds a last ref to
the corresponding SurfaceHandle and will destroy it with no errors. A bit too
complicated, would be glad to see a better solution.

   }
   delegate_->RemoveDelegate();
   g_instance = nullptr;
 }
 
 void VrShell::PostToGlThreadWhenReady(const base::Closure& task) {
   // TODO(mthiesse): Remove this blocking wait. Queue up events if thread isn't
   // finished starting?
   gl_thread_->WaitUntilThreadStarted();
   gl_thread_->task_runner()->PostTask(FROM_HERE, task);
@@ skipping 43 matching lines @@
 
 void VrShell::OnDomContentsLoaded() {
   html_interface_->SetURL(main_contents_->GetVisibleURL());
   html_interface_->SetLoading(main_contents_->IsLoading());
   html_interface_->OnDomContentsLoaded();
 }
 
 void VrShell::SetWebVrMode(JNIEnv* env,
                            const base::android::JavaParamRef<jobject>& obj,
                            bool enabled) {
+  VLOG(1) << __FUNCTION__ << ": enabled=" << enabled;
   metrics_helper_->SetWebVREnabled(enabled);
   GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   PostToGlThreadWhenReady(
       base::Bind(&VrShellGl::SetWebVrMode, thread->GetVrShellGl(), enabled));
   if (enabled) {
     html_interface_->SetMode(UiInterface::Mode::WEB_VR);
   } else {
     html_interface_->SetMode(UiInterface::Mode::STANDARD);
   }
 }
 
-void VrShell::SetGvrPoseForWebVr(const gvr::Mat4f& pose, uint32_t pose_num) {
+void VrShell::SetWebVRGvrPose(const gvr::Mat4f& pose, uint32_t pose_num, int64_t pose_time_nanos) {
   GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   if (thread->IsRunning()) {
     thread->task_runner()->PostTask(
-        FROM_HERE, base::Bind(&VrShellGl::SetGvrPoseForWebVr,
-                              thread->GetVrShellGl(), pose, pose_num));
+        FROM_HERE, base::Bind(&VrShellGl::SetWebVRGvrPose,
+                              thread->GetVrShellGl(), pose, pose_num, pose_time_nanos));
   }
 }
 
-void VrShell::SetWebVRRenderSurfaceSize(int width, int height) {
-  // TODO(klausw,crbug.com/655722): Change the GVR render size and set the WebVR
-  // render surface size.
-}
-
-gvr::Sizei VrShell::GetWebVRCompositorSurfaceSize() {
-  const gfx::Size& size = content_compositor_->GetWindowBounds();
-  return {size.width(), size.height()};
-}
-
 void VrShell::SetWebVRSecureOrigin(bool secure_origin) {
   // TODO(cjgrant): Align this state with the logic that drives the omnibox.
   html_interface_->SetWebVRSecureOrigin(secure_origin);
 }
 
-void VrShell::SubmitWebVRFrame() {}
+void VrShell::SubmitWebVRFrame(int32_t surface_handle, device::mojom::VRPosePtr pose) {
+  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
+  PostToGlThreadWhenReady(base::Bind(&VrShellGl::SubmitWebVRFrame,
+                                     thread->GetVrShellGl(),
+                                     surface_handle,
+                                     std::move(pose)));
+}
 
-void VrShell::UpdateWebVRTextureBounds(const gvr::Rectf& left_bounds,
+void VrShell::UpdateWebVRTextureBounds(uint32_t for_pose_index,
+                                       const gvr::Rectf& left_bounds,
                                        const gvr::Rectf& right_bounds) {
   GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::UpdateWebVRTextureBounds,
-                                     thread->GetVrShellGl(), left_bounds,
+                                     thread->GetVrShellGl(),
+                                     for_pose_index,
+                                     left_bounds,
                                      right_bounds));
 }
 
+void VrShell::GetWebVRSurfaceHandle(int width, int height, const device::mojom::VRDisplay::GetSurfaceHandleCallback& callback) {
+  GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
+  PostToGlThreadWhenReady(base::Bind(&VrShellGl::GetWebVRSurfaceHandle,
+                                     thread->GetVrShellGl(),
+                                     width,
+                                     height,
+                                     std::move(callback)));
+}
+
 // TODO(mthiesse): Do not expose GVR API outside of GL thread.
 // It's not thread-safe.
 gvr::GvrApi* VrShell::gvr_api() {
   GLThread* thread = static_cast<GLThread*>(gl_thread_.get());
   if (thread->GetVrShellGlUnsafe()) {
     return thread->GetVrShellGlUnsafe()->gvr_api();
   }
   CHECK(false);
   return nullptr;
 }
 
 void VrShell::SurfacesChanged(jobject content_surface, jobject ui_surface) {
   content_compositor_->SurfaceChanged(content_surface);
   ui_compositor_->SurfaceChanged(ui_surface);
 }
 
 void VrShell::GvrDelegateReady() {
   delegate_->SetDelegate(this);
 }
 
+void VrShell::OnWebVRFrameSubmitted(int32_t surface_handle, uint32_t frame_index, double elapsed) {
+  delegate_->device_provider()->OnFrameSubmitted(surface_handle, frame_index, elapsed);
+}
+
 void VrShell::AppButtonPressed() {
 #if defined(ENABLE_VR_SHELL)
   html_interface_->SetMenuMode(!html_interface_->GetMenuMode());
 
   // TODO(mthiesse): The page is no longer visible when in menu mode. We
   // should unfocus or otherwise let it know it's hidden.
   if (html_interface_->GetMode() == UiInterface::Mode::WEB_VR) {
     if (delegate_->device_provider()) {
       if (html_interface_->GetMenuMode()) {
         delegate_->device_provider()->OnDisplayBlur();
@@ skipping 141 matching lines @@
   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)));
 }
 
 }  // namespace vr_shell