VR: Add a native UI element scene manager

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>
 
@@ skipping 122 matching lines @@
   callback.Run(std::move(info));
 }
 
 }  // namespace
 
 VrShellGl::VrShellGl(
     const base::WeakPtr<VrShell>& weak_vr_shell,
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
     gvr_context* gvr_api,
     bool initially_web_vr,
-    bool reprojected_rendering)
-    : web_vr_mode_(initially_web_vr),
+    bool reprojected_rendering,
+    UiScene* scene)
+    : scene_(scene),
+      web_vr_mode_(initially_web_vr),
       surfaceless_rendering_(reprojected_rendering),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       binding_(this),
       weak_vr_shell_(weak_vr_shell),
       main_thread_task_runner_(std::move(main_thread_task_runner)),
       weak_ptr_factory_(this) {
   GvrInit(gvr_api);
 }
 
 VrShellGl::~VrShellGl() {
   vsync_task_.Cancel();
   // TODO(mthiesse): Can we omit the Close() here? Concern is that if
   // both ends of the connection ever live in the same process for
   // some reason, we could receive another VSync request in response
   // to the closing message in the destructor but fail to respond to
   // the callback.
   binding_.Close();
   if (!callback_.is_null()) {
     // When this VSync provider is going away we have to respond to pending
     // callbacks, so instead of providing a VSync, tell the requester to try
     // again. A VSyncProvider is guaranteed to exist, so the request in response
     // to this message will go through some other VSyncProvider.
     base::ResetAndReturn(&callback_)
         .Run(nullptr, base::TimeDelta(), -1,
              device::mojom::VRVSyncProvider::Status::CLOSING);
   }
 }
 
 void VrShellGl::Initialize() {
-  scene_ = base::MakeUnique<UiScene>();
-
   if (surfaceless_rendering_) {
     // If we're rendering surfaceless, we'll never get a java surface to render
     // into, so we can initialize GL right away.
     InitializeGl(nullptr);
   }
 }
 
 void VrShellGl::InitializeGl(gfx::AcceleratedWidget window) {
   CHECK(!ready_to_draw_);
   if (gl::GetGLImplementation() == gl::kGLImplementationNone &&
@@ skipping 1054 matching lines @@
   vsync_interval_ = base::TimeDelta::FromSecondsD(interval_seconds);
   vsync_task_.Reset(base::Bind(&VrShellGl::OnVSync, base::Unretained(this)));
   OnVSync();
 }
 
 void VrShellGl::ForceExitVr() {
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VrShell::ForceExitVr, weak_vr_shell_));
 }
 
-void VrShellGl::UpdateScene(std::unique_ptr<base::ListValue> commands) {
-  scene_->HandleCommands(std::move(commands), base::TimeTicks::Now());
-}
-
 void VrShellGl::SendVSync(base::TimeDelta time,
                           const GetVSyncCallback& callback) {
   uint8_t frame_index = frame_index_++;
 
   TRACE_EVENT1("input", "VrShellGl::SendVSync", "frame", frame_index);
 
   gvr::Mat4f head_mat;
   device::mojom::VRPosePtr pose =
       device::GvrDelegate::GetVRPosePtrWithNeckModel(gvr_api_.get(), &head_mat);
 
@@ skipping 11 matching lines @@
   // InitializeGl. Revisit if the initialization order changes.
   device::mojom::VRDisplayInfoPtr info =
       device::GvrDelegate::CreateVRDisplayInfo(gvr_api_.get(),
                                                webvr_surface_size_, device_id);
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RunVRDisplayInfoCallback, callback, base::Passed(&info)));
 }
 
 }  // namespace vr_shell