VR: Loading DD controller model after GL is initialized

chrome/browser/android/vr_shell/vr_shell_gl.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_gl.h"
 
 #include <chrono>
 #include <limits>
 #include <utility>
 
 #include "base/android/jni_android.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/android/vr_shell/fps_meter.h"
 #include "chrome/browser/android/vr_shell/mailbox_to_surface_bridge.h"
 #include "chrome/browser/android/vr_shell/ui_elements/ui_element.h"
 #include "chrome/browser/android/vr_shell/ui_interface.h"
 #include "chrome/browser/android/vr_shell/ui_scene.h"
 #include "chrome/browser/android/vr_shell/ui_scene_manager.h"
 #include "chrome/browser/android/vr_shell/vr_controller.h"
 #include "chrome/browser/android/vr_shell/vr_gl_thread.h"
 #include "chrome/browser/android/vr_shell/vr_gl_util.h"
@@ skipping 165 matching lines @@
 
 gfx::RectF GfxRectFromUV(gvr::Rectf rect) {
   return gfx::RectF(rect.left, 1.0 - rect.top, rect.right - rect.left,
                     rect.top - rect.bottom);
 }
 
 double NowSeconds() {
   return (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
 }
 
+void LoadControllerModelTask(
+    base::WeakPtr<VrShellGl> weak_vr_shell_gl,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  auto controller_model = VrControllerModel::LoadFromResources();
+  if (controller_model) {
+    task_runner->PostTask(
+        FROM_HERE, base::Bind(&VrShellGl::SetControllerModel, weak_vr_shell_gl,

[mthiesse, 2017/05/19 14:32:42]

You said SetControllerModel was slow too, right? Should we also post this to a
background priority taskrunner?

[acondor_, 2017/05/19 16:06:49]

As discussed offline, I reduced the runtime of SetControllerModel by computing
the textures in the background task.

+                              base::Passed(&controller_model)));
+  }
+}
+
 }  // namespace
 
 VrShellGl::VrShellGl(VrBrowserInterface* browser,
                      gvr_context* gvr_api,
                      bool initially_web_vr,
                      bool reprojected_rendering,
+                     bool daydream_support,
                      UiScene* scene)
     : web_vr_mode_(initially_web_vr),
       surfaceless_rendering_(reprojected_rendering),
+      daydream_support_(daydream_support),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       binding_(this),
       browser_(browser),
       scene_(scene),
 #if DCHECK_IS_ON()
       fps_meter_(new FPSMeter()),
 #endif
       weak_ptr_factory_(this) {
   GvrInit(gvr_api);
 }
@@ skipping 80 matching lines @@
       device::GvrDelegate::GetRecommendedWebVrSize(gvr_api_.get());
   DVLOG(1) << __FUNCTION__ << ": resize initial to " << webvr_size.width()
            << "x" << webvr_size.height();
 
   CreateOrResizeWebVRSurface(webvr_size);
 
   vsync_task_.Reset(base::Bind(&VrShellGl::OnVSync, base::Unretained(this)));
   OnVSync();
 
   ready_to_draw_ = true;
+
+  if (daydream_support_) {
+    base::PostTaskWithTraits(
+        FROM_HERE, {base::TaskPriority::BACKGROUND},
+        base::Bind(LoadControllerModelTask, weak_ptr_factory_.GetWeakPtr(),
+                   task_runner_));
+  }
 }
 
 void VrShellGl::CreateContentSurface() {
   content_surface_ =
       base::MakeUnique<gl::ScopedJavaSurface>(content_surface_texture_.get());
   browser_->ContentSurfaceChanged(content_surface_->j_surface().obj());
 }
 
 void VrShellGl::CreateOrResizeWebVRSurface(const gfx::Size& size) {
   if (!webvr_surface_texture_) {
@@ skipping 133 matching lines @@
 
   // For kFrameHeadlockedBuffer (for WebVR insecure content warning).
   // Set this up at fixed resolution, the (smaller) FOV gets set below.
   specs.push_back(gvr_api_->CreateBufferSpec());
   specs.back().SetSize({kHeadlockedBufferDimensions.width(),
                         kHeadlockedBufferDimensions.height()});
   gvr::Sizei render_size_headlocked = specs[kFrameHeadlockedBuffer].GetSize();
   render_size_headlocked_ = {render_size_headlocked.width,
                              render_size_headlocked.height};
 
-  swap_chain_.reset(new gvr::SwapChain(gvr_api_->CreateSwapChain(specs)));
+  swap_chain_ =
+      base::MakeUnique<gvr::SwapChain>(gvr_api_->CreateSwapChain(specs));
 
-  vr_shell_renderer_.reset(new VrShellRenderer());
+  vr_shell_renderer_ = base::MakeUnique<VrShellRenderer>();
 
   // Allocate a buffer viewport for use in UI drawing. This isn't
   // initialized at this point, it'll be set from other viewport list
   // entries as needed.
   buffer_viewport_.reset(
       new gvr::BufferViewport(gvr_api_->CreateBufferViewport()));
 
   // Set up main content viewports. The list has two elements, 0=left
   // eye and 1=right eye.
   buffer_viewport_list_.reset(
@@ skipping 992 matching lines @@
   // This assumes that the initial webvr_surface_size_ was set to the
   // appropriate recommended render resolution as the default size during
   // InitializeGl. Revisit if the initialization order changes.
   device::mojom::VRDisplayInfoPtr info =
       device::GvrDelegate::CreateVRDisplayInfo(gvr_api_.get(),
                                                webvr_surface_size_, device_id);
   browser_->RunVRDisplayInfoCallback(callback, &info);
 }
 
 }  // namespace vr_shell