VR: Loading DD controller model after GL is initialized

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 67 matching lines @@
     // should add a flag for disabling specific UI such as the keyboard (see
     // VrTabHelper for details).
     contents->GetRenderWidgetHostView()->SetIsInVR(is_in_vr);
 
     VrTabHelper* vr_tab_helper = VrTabHelper::FromWebContents(contents);
     DCHECK(vr_tab_helper);
     vr_tab_helper->SetIsInVr(is_in_vr);
   }
 }
 
-void LoadControllerModelTask(
-    base::WeakPtr<VrShell> weak_vr_shell,
-    scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner) {
-  auto controller_model = VrControllerModel::LoadFromComponent();
-  if (controller_model) {
-    main_thread_task_runner->PostTask(
-        FROM_HERE, base::Bind(&VrShell::SubmitControllerModel, weak_vr_shell,
-                              base::Passed(&controller_model)));
-  }
-}
-
 }  // namespace
 
 VrShell::VrShell(JNIEnv* env,
                  jobject obj,
                  ui::WindowAndroid* window,
                  bool for_web_vr,
                  bool in_cct,
                  VrShellDelegate* delegate,
                  gvr_context* gvr_api,
                  bool reprojected_rendering)
     : vr_shell_enabled_(base::FeatureList::IsEnabled(features::kVrShell)),
       window_(window),
       compositor_(base::MakeUnique<VrCompositor>(window_)),
       delegate_provider_(delegate),
       main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       reprojected_rendering_(reprojected_rendering),
       gvr_api_(gvr_api),
       weak_ptr_factory_(this) {
   DVLOG(1) << __FUNCTION__ << "=" << this;
   DCHECK(g_instance == nullptr);
   g_instance = this;
   j_vr_shell_.Reset(env, obj);
 
   gl_thread_ = base::MakeUnique<VrGLThread>(
       weak_ptr_factory_.GetWeakPtr(), main_thread_task_runner_, gvr_api,
-      for_web_vr, in_cct, reprojected_rendering_);
+      for_web_vr, in_cct, reprojected_rendering_, HasDaydreamSupport(env));
   ui_ = gl_thread_.get();
 
   base::Thread::Options options(base::MessageLoop::TYPE_DEFAULT, 0);
   options.priority = base::ThreadPriority::DISPLAY;
   gl_thread_->StartWithOptions(options);
-
-
-  content::BrowserThread::PostTask(
-      content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(LoadControllerModelTask, weak_ptr_factory_.GetWeakPtr(),
-                 main_thread_task_runner_));
 }
 
 void VrShell::Destroy(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   delete this;
 }
 
 void VrShell::SwapContents(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jobject>& web_contents,
@@ skipping 221 matching lines @@
 
 void VrShell::SubmitWebVRFrame(int16_t frame_index,
                                const gpu::MailboxHolder& mailbox) {
   TRACE_EVENT1("gpu", "SubmitWebVRFrame", "frame", frame_index);
   WaitForGlThread();
   PostToGlThread(FROM_HERE,
                  base::Bind(&VrShellGl::SubmitWebVRFrame,
                             gl_thread_->GetVrShellGl(), frame_index, mailbox));
 }
 
-void VrShell::SubmitControllerModel(std::unique_ptr<VrControllerModel> 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) {
   WaitForGlThread();
   PostToGlThread(FROM_HERE, base::Bind(&VrShellGl::UpdateWebVRTextureBounds,
                                        gl_thread_->GetVrShellGl(), frame_index,
                                        left_bounds, right_bounds, source_size));
 }
 
@@ skipping 236 matching lines @@
     gamepad_data_fetcher_->SetGamepadData(pad);
   }
 }
 
 void VrShell::RegisterGamepadDataFetcher(
     device::GvrGamepadDataFetcher* fetcher) {
   DVLOG(1) << __FUNCTION__ << "(" << fetcher << ")";
   gamepad_data_fetcher_ = fetcher;
 }
 
+bool VrShell::HasDaydreamSupport(JNIEnv* env) {
+  return Java_VrShellImpl_hasDaydreamSupport(env, j_vr_shell_.obj());
+}
+
 // ----------------------------------------------------------------------------
 // Native JNI methods
 // ----------------------------------------------------------------------------
 
 jlong Init(JNIEnv* env,
            const JavaParamRef<jobject>& obj,
            const JavaParamRef<jobject>& delegate,
            jlong window_android,
            jboolean for_web_vr,
            jboolean in_cct,
            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