VR: Make sure GL thread is started before binding callbacks to it.

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 <string>
 #include <utility>
@@ skipping 201 matching lines @@
     // 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();
   }
   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?
+void VrShell::WaitForGlThread() {
+  if (thread_started_)
+    return;
+  // TODO(mthiesse): Remove this blocking wait. Queue up events on the thread
+  // object, rather than on the weak ptr initialized after the thread is
+  // started.
   gl_thread_->WaitUntilThreadStarted();
-  gl_thread_->task_runner()->PostTask(FROM_HERE, task);
+  thread_started_ = true;
+}
+
+void VrShell::PostToGlThread(const tracked_objects::Location& from_here,
+                             const base::Closure& task) {
+  DCHECK(thread_started_);
+  gl_thread_->task_runner()->PostTask(from_here, task);
 }
 
 void VrShell::OnContentPaused(bool paused) {
   if (!vr_shell_enabled_)
     return;
 
   if (!delegate_provider_->device_provider())
     return;
 
   // TODO(mthiesse): The page is no longer visible when in menu mode. We
   // should unfocus or otherwise let it know it's hidden.
   if (paused)
     delegate_provider_->device_provider()->Device()->OnBlur();
   else
     delegate_provider_->device_provider()->Device()->OnFocus();
 }
 
 void VrShell::NavigateBack() {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_VrShellImpl_navigateBack(env, j_vr_shell_.obj());
 }
 
 void VrShell::OnTriggerEvent(JNIEnv* env, const JavaParamRef<jobject>& obj) {
-  gl_thread_->task_runner()->PostTask(
-      FROM_HERE,
-      base::Bind(&VrShellGl::OnTriggerEvent, gl_thread_->GetVrShellGl()));
+  WaitForGlThread();
+  PostToGlThread(FROM_HERE, base::Bind(&VrShellGl::OnTriggerEvent,
+                                       gl_thread_->GetVrShellGl()));
 }
 
 void VrShell::OnPause(JNIEnv* env, const JavaParamRef<jobject>& obj) {
-  gl_thread_->task_runner()->PostTask(
-      FROM_HERE, base::Bind(&VrShellGl::OnPause, gl_thread_->GetVrShellGl()));
+  WaitForGlThread();
+  PostToGlThread(FROM_HERE,
+                 base::Bind(&VrShellGl::OnPause, gl_thread_->GetVrShellGl()));
 
   // exit vr session
   if (metrics_helper_)
     metrics_helper_->SetVRActive(false);
   SetIsInVR(web_contents_, false);
 }
 
 void VrShell::OnResume(JNIEnv* env, const JavaParamRef<jobject>& obj) {
-  gl_thread_->task_runner()->PostTask(
-      FROM_HERE, base::Bind(&VrShellGl::OnResume, gl_thread_->GetVrShellGl()));
+  WaitForGlThread();
+  PostToGlThread(FROM_HERE,
+                 base::Bind(&VrShellGl::OnResume, gl_thread_->GetVrShellGl()));
 
   if (metrics_helper_)
     metrics_helper_->SetVRActive(true);
   SetIsInVR(web_contents_, true);
 }
 
 void VrShell::SetSurface(JNIEnv* env,
                          const JavaParamRef<jobject>& obj,
                          const JavaParamRef<jobject>& surface) {
   CHECK(!reprojected_rendering_);
   gfx::AcceleratedWidget window =
       ANativeWindow_fromSurface(base::android::AttachCurrentThread(), surface);
-  PostToGlThreadWhenReady(base::Bind(&VrShellGl::InitializeGl,
-                                     gl_thread_->GetVrShellGl(),
-                                     base::Unretained(window)));
+  WaitForGlThread();
+  PostToGlThread(FROM_HERE, base::Bind(&VrShellGl::InitializeGl,
+                                       gl_thread_->GetVrShellGl(),
+                                       base::Unretained(window)));
 }
 
 void VrShell::SetWebVrMode(JNIEnv* env,
                            const JavaParamRef<jobject>& obj,
                            bool enabled) {
   webvr_mode_ = enabled;
   if (metrics_helper_)
     metrics_helper_->SetWebVREnabled(enabled);
-  PostToGlThreadWhenReady(base::Bind(&VrShellGl::SetWebVrMode,
-                                     gl_thread_->GetVrShellGl(), enabled));
+  WaitForGlThread();
+  PostToGlThread(FROM_HERE, base::Bind(&VrShellGl::SetWebVrMode,
+                                       gl_thread_->GetVrShellGl(), enabled));
   ui_->SetWebVrMode(enabled);
 }
 
 void VrShell::OnFullscreenChanged(bool enabled) {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_VrShellImpl_onFullscreenChanged(env, j_vr_shell_.obj(), enabled);
   ui_->SetFullscreen(enabled);
 }
 
 bool VrShell::GetWebVrMode(JNIEnv* env, const JavaParamRef<jobject>& obj) {
@@ skipping 42 matching lines @@
   ui_->RemoveTab(incognito, id);
 }
 
 void VrShell::SetWebVRSecureOrigin(bool secure_origin) {
   ui_->SetWebVrSecureOrigin(secure_origin);
 }
 
 void VrShell::SubmitWebVRFrame(int16_t frame_index,
                                const gpu::MailboxHolder& mailbox) {
   TRACE_EVENT1("gpu", "SubmitWebVRFrame", "frame", frame_index);
-
-  PostToGlThreadWhenReady(base::Bind(&VrShellGl::SubmitWebVRFrame,
-                                     gl_thread_->GetVrShellGl(), frame_index,
-                                     mailbox));
+  WaitForGlThread();
+  PostToGlThread(FROM_HERE,
+                 base::Bind(&VrShellGl::SubmitWebVRFrame,
+                            gl_thread_->GetVrShellGl(), frame_index, mailbox));
 }
 
 void VrShell::SubmitControllerModel(std::unique_ptr<VrControllerModel> model) {
-  PostToGlThreadWhenReady(base::Bind(&VrShellGl::SetControllerModel,
-                                     gl_thread_->GetVrShellGl(),
-                                     base::Passed(&model)));
+  WaitForGlThread();
+  PostToGlThread(FROM_HERE,
+                 base::Bind(&VrShellGl::SetControllerModel,
+                            gl_thread_->GetVrShellGl(), base::Passed(&model)));
 }
 
 void VrShell::UpdateWebVRTextureBounds(int16_t frame_index,
                                        const gfx::RectF& left_bounds,
                                        const gfx::RectF& right_bounds,
                                        const gfx::Size& source_size) {
-  PostToGlThreadWhenReady(base::Bind(&VrShellGl::UpdateWebVRTextureBounds,
-                                     gl_thread_->GetVrShellGl(), frame_index,
-                                     left_bounds, right_bounds, source_size));
+  WaitForGlThread();
+  PostToGlThread(FROM_HERE, base::Bind(&VrShellGl::UpdateWebVRTextureBounds,
+                                       gl_thread_->GetVrShellGl(), frame_index,
+                                       left_bounds, right_bounds, source_size));
 }
 
 void VrShell::CreateVRDisplayInfo(
     const base::Callback<void(device::mojom::VRDisplayInfoPtr)>& callback,
     uint32_t device_id) {
-  PostToGlThreadWhenReady(base::Bind(&VrShellGl::CreateVRDisplayInfo,
-                                     gl_thread_->GetVrShellGl(), callback,
-                                     device_id));
+  WaitForGlThread();
+  PostToGlThread(FROM_HERE,
+                 base::Bind(&VrShellGl::CreateVRDisplayInfo,
+                            gl_thread_->GetVrShellGl(), callback, device_id));
 }
 
 void VrShell::SetSubmitClient(
     device::mojom::VRSubmitFrameClientPtr submit_client) {
-  PostToGlThreadWhenReady(
+  WaitForGlThread();
+  PostToGlThread(
+      FROM_HERE,
       base::Bind(&VrShellGl::SetSubmitClient, gl_thread_->GetVrShellGl(),
                  base::Passed(submit_client.PassInterface())));
 }
 
 base::android::ScopedJavaGlobalRef<jobject> VrShell::TakeContentSurface(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj) {
   compositor_->SurfaceChanged(nullptr);
   base::android::ScopedJavaGlobalRef<jobject> surface(env, content_surface_);
   content_surface_ = nullptr;
   return surface;
 }
 
 void VrShell::RestoreContentSurface(JNIEnv* env,
                                     const JavaParamRef<jobject>& obj) {
-  PostToGlThreadWhenReady(
-      base::Bind(&VrShellGl::CreateContentSurface, gl_thread_->GetVrShellGl()));
+  WaitForGlThread();
+  PostToGlThread(FROM_HERE, base::Bind(&VrShellGl::CreateContentSurface,
+                                       gl_thread_->GetVrShellGl()));
 }
 
 void VrShell::SetHistoryButtonsEnabled(JNIEnv* env,
                                        const JavaParamRef<jobject>& obj,
                                        jboolean can_go_back,
                                        jboolean can_go_forward) {
   ui_->SetHistoryButtonsEnabled(can_go_back, can_go_forward);
 }
 
 void VrShell::ContentSurfaceChanged(jobject surface) {
@@ skipping 18 matching lines @@
   gfx::Size size(width, height);
   web_contents->GetNativeView()->OnPhysicalBackingSizeChanged(size);
 }
 
 void VrShell::ContentPhysicalBoundsChanged(JNIEnv* env,
                                            const JavaParamRef<jobject>& object,
                                            jint width,
                                            jint height,
                                            jfloat dpr) {
   TRACE_EVENT0("gpu", "VrShell::ContentPhysicalBoundsChanged");
+  WaitForGlThread();
   // TODO(acondor): Set the device scale factor for font rendering on the
   // VR Shell textures.
-  PostToGlThreadWhenReady(base::Bind(&VrShellGl::ContentPhysicalBoundsChanged,
-                                     gl_thread_->GetVrShellGl(), width,
-                                     height));
+  PostToGlThread(FROM_HERE,
+                 base::Bind(&VrShellGl::ContentPhysicalBoundsChanged,
+                            gl_thread_->GetVrShellGl(), width, height));
   compositor_->SetWindowBounds(gfx::Size(width, height));
 }
 
 // Note that the following code is obsolete and is here as reference for the
 // actions that need to be implemented natively.
 void VrShell::DoUiAction(const UiAction action,
                          const base::DictionaryValue* arguments) {
   // Actions that can be handled natively.
   switch (action) {
     default:
@@ skipping 21 matching lines @@
       Java_VrShellImpl_reload(env, j_vr_shell_.obj());
       break;
     default:
       NOTREACHED();
   }
 }
 
 void VrShell::ContentFrameWasResized(bool width_changed) {
   display::Display display =
       display::Screen::GetScreen()->GetDisplayNearestWindow(window_);
-  PostToGlThreadWhenReady(
+  WaitForGlThread();
+  PostToGlThread(
+      FROM_HERE,
       base::Bind(&VrShellGl::ContentBoundsChanged, gl_thread_->GetVrShellGl(),
                  display.size().width(), display.size().height()));
 }
 
 void VrShell::ContentWebContentsDestroyed() {
   input_manager_.reset();
   web_contents_ = nullptr;
   // TODO(mthiesse): Handle web contents being destroyed.
   ForceExitVr();
 }
@@ skipping 18 matching lines @@
 }
 
 void VrShell::ExitFullscreen() {
   if (web_contents_ && web_contents_->IsFullscreen()) {
     web_contents_->ExitFullscreen(false);
   }
 }
 
 void VrShell::OnVRVsyncProviderRequest(
     device::mojom::VRVSyncProviderRequest request) {
-  PostToGlThreadWhenReady(base::Bind(&VrShellGl::OnRequest,
-                                     gl_thread_->GetVrShellGl(),
-                                     base::Passed(&request)));
+  WaitForGlThread();
+  PostToGlThread(FROM_HERE,
+                 base::Bind(&VrShellGl::OnRequest, gl_thread_->GetVrShellGl(),
+                            base::Passed(&request)));
 }
 
 void VrShell::UpdateVSyncInterval(int64_t timebase_nanos,
                                   double interval_seconds) {
   PollMediaAccessFlag();
-  PostToGlThreadWhenReady(base::Bind(&VrShellGl::UpdateVSyncInterval,
-                                     gl_thread_->GetVrShellGl(), timebase_nanos,
-                                     interval_seconds));
+  WaitForGlThread();
+  PostToGlThread(FROM_HERE, base::Bind(&VrShellGl::UpdateVSyncInterval,
+                                       gl_thread_->GetVrShellGl(),
+                                       timebase_nanos, interval_seconds));
 }
 
 void VrShell::PollMediaAccessFlag() {
   poll_capturing_media_task_.Cancel();
 
   poll_capturing_media_task_.Reset(
       base::Bind(&VrShell::PollMediaAccessFlag, base::Unretained(this)));
   main_thread_task_runner_->PostDelayedTask(
       FROM_HERE, poll_capturing_media_task_.callback(),
       poll_media_access_interval_);
 
   scoped_refptr<MediaStreamCaptureIndicator> indicator =
       MediaCaptureDevicesDispatcher::GetInstance()
           ->GetMediaStreamCaptureIndicator();
   bool is_capturing_audio = indicator->IsCapturingAudio(web_contents_);
-  if (is_capturing_audio != is_capturing_audio_)
-    PostToGlThreadWhenReady(base::Bind(&VrShellGl::SetAudioCapturingWarning,
-                                       gl_thread_->GetVrShellGl(),
-                                       is_capturing_audio));
+  if (is_capturing_audio != is_capturing_audio_) {
+    WaitForGlThread();
+    PostToGlThread(FROM_HERE,
+                   base::Bind(&VrShellGl::SetAudioCapturingWarning,
+                              gl_thread_->GetVrShellGl(), is_capturing_audio));
+  }
   is_capturing_audio_ = is_capturing_audio;
 
   bool is_capturing_video = indicator->IsCapturingVideo(web_contents_);
-  if (is_capturing_video != is_capturing_video_)
-    PostToGlThreadWhenReady(base::Bind(&VrShellGl::SetVideoCapturingWarning,
-                                       gl_thread_->GetVrShellGl(),
-                                       is_capturing_video));
+  if (is_capturing_video != is_capturing_video_) {
+    WaitForGlThread();
+    PostToGlThread(FROM_HERE,
+                   base::Bind(&VrShellGl::SetVideoCapturingWarning,
+                              gl_thread_->GetVrShellGl(), is_capturing_video));
+  }
   is_capturing_video_ = is_capturing_video;
 
   bool is_capturing_screen = indicator->IsBeingMirrored(web_contents_);
-  if (is_capturing_screen != is_capturing_screen_)
-    PostToGlThreadWhenReady(base::Bind(&VrShellGl::SetScreenCapturingWarning,
-                                       gl_thread_->GetVrShellGl(),
-                                       is_capturing_screen));
+  if (is_capturing_screen != is_capturing_screen_) {
+    WaitForGlThread();
+    PostToGlThread(FROM_HERE,
+                   base::Bind(&VrShellGl::SetScreenCapturingWarning,
+                              gl_thread_->GetVrShellGl(), is_capturing_screen));
+  }
   is_capturing_screen_ = is_capturing_screen;
 }
 
 void VrShell::SetContentCssSize(float width, float height, float dpr) {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_VrShellImpl_setContentCssSize(env, j_vr_shell_.obj(), width, height,
                                      dpr);
 }
 
 void VrShell::ProcessContentGesture(
@@ skipping 40 matching lines @@
            jlong gvr_api,
            jboolean reprojected_rendering) {
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, reinterpret_cast<ui::WindowAndroid*>(window_android),
       for_web_vr, in_cct,
       VrShellDelegate::GetNativeVrShellDelegate(env, delegate),
       reinterpret_cast<gvr_context*>(gvr_api), reprojected_rendering));
 }
 
 }  // namespace vr_shell