[vr] Only load assets if component is available when entering VR

Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: Ibd5db704d11782a5fc4d53f1eef772d3236db497
Reviewed-on: https://chromium-review.googlesource.com/827984
Commit-Queue: Tibor Goldschwendt <tiborg@chromium.org>
Reviewed-by: Ian Vollick <vollick@chromium.org>
Cr-Commit-Position: refs/heads/master@{#524394}

chrome/browser/android/vr_shell/vr_gl_thread.cc

@@ -69,7 +69,7 @@ void VrGLThread::Init() {
 
   vr_shell_gl_ = base::MakeUnique<VrShellGl>(
       this, std::move(ui), gvr_api_, reprojected_rendering_, daydream_support_,
-      ui_initial_state_.in_web_vr);
+      ui_initial_state_.in_web_vr, ui_initial_state_.assets_available);
 
   browser_ui_ = vr_shell_gl_->GetBrowserUiWeakPtr();
 

chrome/browser/android/vr_shell/vr_shell.cc

@@ -987,6 +987,8 @@ jlong JNI_VrShellImpl_Init(JNIEnv* env,
       has_or_can_request_audio_permission;
   ui_initial_state.skips_redraw_when_not_dirty =
       base::FeatureList::IsEnabled(features::kVrBrowsingExperimentalRendering);
+  ui_initial_state.assets_available =
+      vr::Assets::GetInstance()->ComponentReady();
 
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, reinterpret_cast<ui::WindowAndroid*>(window_android),

chrome/browser/android/vr_shell/vr_shell_gl.cc

@@ -162,7 +162,8 @@ VrShellGl::VrShellGl(GlBrowserInterface* browser_interface,
                      gvr_context* gvr_api,
                      bool reprojected_rendering,
                      bool daydream_support,
-                     bool start_in_web_vr_mode)
+                     bool start_in_web_vr_mode,
+                     bool assets_available)
     : ui_(std::move(ui)),
       web_vr_mode_(start_in_web_vr_mode),
       surfaceless_rendering_(reprojected_rendering),
@@ -176,6 +177,7 @@ VrShellGl::VrShellGl(GlBrowserInterface* browser_interface,
       webvr_js_wait_time_(kWebVRSlidingAverageSize),
       webvr_acquire_time_(kWebVRSlidingAverageSize),
       webvr_submit_time_(kWebVRSlidingAverageSize),
+      assets_available_(assets_available),
       weak_ptr_factory_(this) {
   GvrInit(gvr_api);
 }
@@ -253,8 +255,10 @@ void VrShellGl::InitializeGl(gfx::AcceleratedWidget window) {
   ui_->OnGlInitialized(content_texture_id,
                        vr::UiElementRenderer::kTextureLocationExternal, true);
 
-  vr::Assets::GetInstance()->LoadWhenComponentReady(base::BindOnce(
-      &VrShellGl::OnAssetsLoaded, weak_ptr_factory_.GetWeakPtr()));
+  if (assets_available_) {
+    vr::Assets::GetInstance()->Load(base::BindOnce(
+        &VrShellGl::OnAssetsLoaded, weak_ptr_factory_.GetWeakPtr()));
+  }
 
   webvr_vsync_align_ = base::FeatureList::IsEnabled(features::kWebVrVsyncAlign);
 

chrome/browser/android/vr_shell/vr_shell_gl.h

@@ -83,7 +83,8 @@ class VrShellGl : public device::mojom::VRPresentationProvider {
             gvr_context* gvr_api,
             bool reprojected_rendering,
             bool daydream_support,
-            bool start_in_web_vr_mode);
+            bool start_in_web_vr_mode,
+            bool assets_available);
   ~VrShellGl() override;
 
   void Initialize();
@@ -292,6 +293,8 @@ class VrShellGl : public device::mojom::VRPresentationProvider {
 
   vr::ControllerModel controller_model_;
 
+  bool assets_available_;
+
   base::WeakPtrFactory<VrShellGl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VrShellGl);

chrome/browser/vr/assets.cc

@@ -47,12 +47,12 @@ void Assets::OnComponentReady(const base::Version& version,
                      weak_ptr_factory_.GetWeakPtr(), version, install_dir));
 }
 
-void Assets::LoadWhenComponentReady(OnAssetsLoadedCallback on_loaded) {
+void Assets::Load(OnAssetsLoadedCallback on_loaded) {
   main_thread_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&Assets::LoadWhenComponentReadyInternal,
-                                weak_ptr_factory_.GetWeakPtr(),
-                                base::ThreadTaskRunnerHandle::Get(),
-                                std::move(on_loaded)));
+      FROM_HERE,
+      base::BindOnce(&Assets::LoadInternal, weak_ptr_factory_.GetWeakPtr(),
+                     base::ThreadTaskRunnerHandle::Get(),
+                     std::move(on_loaded)));
 }
 
 MetricsHelper* Assets::GetMetricsHelper() {
@@ -68,6 +68,11 @@ MetricsHelper* Assets::GetMetricsHelper() {
   return metrics_helper_.get();
 }
 
+bool Assets::ComponentReady() {
+  DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
+  return component_ready_;
+}
+
 // static
 void Assets::LoadAssetsTask(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
@@ -141,29 +146,22 @@ Assets::~Assets() = default;
 
 void Assets::OnComponentReadyInternal(const base::Version& version,
                                       const base::FilePath& install_dir) {
+  DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   component_version_ = version;
   component_install_dir_ = install_dir;
   component_ready_ = true;
   GetMetricsHelper()->OnComponentReady(version);
-  if (on_assets_loaded_) {
-    LoadWhenComponentReadyInternal(on_assets_loaded_task_runner_,
-                                   std::move(on_assets_loaded_));
-    on_assets_loaded_task_runner_ = nullptr;
-  }
 }
 
-void Assets::LoadWhenComponentReadyInternal(
+void Assets::LoadInternal(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     OnAssetsLoadedCallback on_loaded) {
-  if (component_ready_) {
-    base::PostTaskWithTraits(
-        FROM_HERE, {base::TaskPriority::BACKGROUND, base::MayBlock()},
-        base::BindOnce(&Assets::LoadAssetsTask, task_runner, component_version_,
-                       component_install_dir_, std::move(on_loaded)));
-  } else {
-    on_assets_loaded_ = std::move(on_loaded);
-    on_assets_loaded_task_runner_ = task_runner;
-  }
+  DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
+  DCHECK(component_ready_);
+  base::PostTaskWithTraits(
+      FROM_HERE, {base::TaskPriority::BACKGROUND, base::MayBlock()},
+      base::BindOnce(&Assets::LoadAssetsTask, task_runner, component_version_,
+                     component_install_dir_, std::move(on_loaded)));
 }
 
 }  // namespace vr

chrome/browser/vr/assets.h

@@ -32,10 +32,10 @@ struct AssetsSingletonTrait;
 // Manages VR assets such as the environment. Gets updated by the VR assets
 // component.
 //
-// All function are thread-safe. The reason is that the component will be made
-// available on a different thread than the asset load request. Internally, the
-// function calls will be posted on the main thread. The asset load may be
-// performed on a worker thread.
+// If not noted otherwise the functions are thread-safe. The reason is that the
+// component will be made available on a different thread than the asset load
+// request. Internally, the function calls will be posted on the main thread.
+// The asset load may be performed on a worker thread.
 class Assets {
  public:
   typedef base::OnceCallback<void(AssetsLoadStatus status,
@@ -51,12 +51,17 @@ class Assets {
                         const base::FilePath& install_dir,
                         std::unique_ptr<base::DictionaryValue> manifest);
 
-  // Calls |on_loaded| when a component version is ready and the containing
-  // assets are loaded. |on_loaded| will be called on the caller's thread.
-  void LoadWhenComponentReady(OnAssetsLoadedCallback on_loaded);
+  // Loads asset files and calls |on_loaded| passing the loaded asset files.
+  // |on_loaded| will be called on the caller's thread. Component must be ready
+  // when calling this function.
+  void Load(OnAssetsLoadedCallback on_loaded);
 
   MetricsHelper* GetMetricsHelper();
 
+  // Returns true if the component is ready.
+  // Must be called on the main thread.
+  bool ComponentReady();
+
  private:
   static void LoadAssetsTask(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
@@ -68,15 +73,12 @@ class Assets {
   ~Assets();
   void OnComponentReadyInternal(const base::Version& version,
                                 const base::FilePath& install_dir);
-  void LoadWhenComponentReadyInternal(
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-      OnAssetsLoadedCallback on_loaded);
+  void LoadInternal(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+                    OnAssetsLoadedCallback on_loaded);
 
   bool component_ready_ = false;
   base::Version component_version_;
   base::FilePath component_install_dir_;
-  OnAssetsLoadedCallback on_assets_loaded_;
-  scoped_refptr<base::SingleThreadTaskRunner> on_assets_loaded_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
   std::unique_ptr<MetricsHelper> metrics_helper_;
 

chrome/browser/vr/ui.h

@@ -37,6 +37,7 @@ struct UiInitialState {
   bool browsing_disabled = false;
   bool has_or_can_request_audio_permission = true;
   bool skips_redraw_when_not_dirty = false;
+  bool assets_available = false;
 };
 
 // This class manages all GLThread owned objects and GL rendering for VrShell.