Rename RenderLoop to BrowserRenderer

Rename CompositorDelegate to GraphicsDelegate and VrShellGl to
GvrGraphicsDelegate.

Bug: 875291
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:linux_vr;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel
Change-Id: Iecb896daaa47fc3681ca642e4dac4a654536d1c5
Reviewed-on: https://chromium-review.googlesource.com/1208675
Commit-Queue: Aldo Culquicondor <acondor@chromium.org>
Reviewed-by: Michael Thiessen <mthiesse@chromium.org>
Cr-Commit-Position: refs/heads/master@{#589633}

chrome/browser/android/vr/BUILD.gn

@@ -19,9 +19,13 @@ static_library("vr_android") {
     "android_vsync_helper.h",
     "autocomplete_controller.cc",
     "autocomplete_controller.h",
+    "browser_renderer_factory.cc",
+    "browser_renderer_factory.h",
     "gl_browser_interface.h",
     "gvr_controller_delegate.cc",
     "gvr_controller_delegate.h",
+    "gvr_graphics_delegate.cc",
+    "gvr_graphics_delegate.h",
     "gvr_keyboard_delegate.cc",
     "gvr_keyboard_delegate.h",
     "gvr_keyboard_shim.cc",
@@ -34,8 +38,6 @@ static_library("vr_android") {
     "metrics_util_android.cc",
     "metrics_util_android.h",
     "register_jni.h",
-    "render_loop_factory.cc",
-    "render_loop_factory.h",
     "scoped_gpu_trace.cc",
     "scoped_gpu_trace.h",
     "vr_controller.cc",
@@ -51,8 +53,6 @@ static_library("vr_android") {
     "vr_shell.h",
     "vr_shell_delegate.cc",
     "vr_shell_delegate.h",
-    "vr_shell_gl.cc",
-    "vr_shell_gl.h",
     "vr_web_contents_observer.cc",
     "vr_web_contents_observer.h",
     "web_xr_presentation_state.cc",

chrome/browser/android/vr/OWNERS

@@ -4,7 +4,7 @@ mthiesse@chromium.org
 tiborg@chromium.org
 vollick@chromium.org
 
-# WebXR-related, including VrShellGl.
+# WebXR-related, including GvrSchedulerDelegate.
 klausw@chromium.org
 
 # TEAM: xr-dev@chromium.org

chrome/browser/android/vr/arcore_device/ar_image_transport.cc

@@ -29,7 +29,7 @@ constexpr int kSharedBufferSwapChainSize = 3;
 
 }  // namespace
 
-// TODO(klausw): share this with VrShellGl.
+// TODO(klausw): share this with WebXrPresentationState.
 struct SharedFrameBuffer {
   SharedFrameBuffer() = default;
   ~SharedFrameBuffer() = default;

chrome/browser/android/vr/render_loop_factory.cc → chrome/browser/android/vr/browser_renderer_factory.cc

@@ -2,7 +2,7 @@
 // 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/render_loop_factory.h"
+#include "chrome/browser/android/vr/browser_renderer_factory.h"
 
 #include <utility>
 
@@ -11,8 +11,7 @@
 #include "chrome/browser/android/vr/gvr_keyboard_delegate.h"
 #include "chrome/browser/android/vr/gvr_scheduler_delegate.h"
 #include "chrome/browser/android/vr/vr_gl_thread.h"
-#include "chrome/browser/android/vr/vr_shell_gl.h"
-#include "chrome/browser/vr/render_loop.h"
+#include "chrome/browser/vr/browser_renderer.h"
 #include "chrome/browser/vr/sounds_manager_audio_delegate.h"
 #include "chrome/browser/vr/text_input_delegate.h"
 #include "chrome/browser/vr/ui_factory.h"
@@ -25,7 +24,7 @@ constexpr unsigned kSlidingAverageSize = 5;
 
 namespace vr {
 
-RenderLoopFactory::Params::Params(
+BrowserRendererFactory::Params::Params(
     gvr::GvrApi* gvr_api,
     const UiInitialState& ui_initial_state,
     bool reprojected_rendering,
@@ -43,9 +42,9 @@ RenderLoopFactory::Params::Params(
       gl_surface_created_event(gl_surface_created_event),
       surface_callback(std::move(surface_callback)) {}
 
-RenderLoopFactory::Params::~Params() = default;
+BrowserRendererFactory::Params::~Params() = default;
 
-std::unique_ptr<RenderLoop> RenderLoopFactory::Create(
+std::unique_ptr<BrowserRenderer> BrowserRendererFactory::Create(
     VrGLThread* vr_gl_thread,
     UiFactory* ui_factory,
     std::unique_ptr<Params> params) {
@@ -66,28 +65,28 @@ std::unique_ptr<RenderLoop> RenderLoopFactory::Create(
       params->ui_initial_state);
   auto controller_delegate =
       std::make_unique<GvrControllerDelegate>(params->gvr_api, vr_gl_thread);
-  auto compositor_delegate = std::make_unique<VrShellGl>(
+  auto graphics_delegate = std::make_unique<GvrGraphicsDelegate>(
       vr_gl_thread,
       base::BindOnce(&UiInterface::OnGlInitialized, base::Unretained(ui.get())),
       params->gvr_api, params->reprojected_rendering, params->pause_content,
       params->low_density, kSlidingAverageSize);
   auto scheduler_delegate = std::make_unique<GvrSchedulerDelegate>(
-      vr_gl_thread, ui.get(), params->gvr_api, compositor_delegate.get(),
+      vr_gl_thread, ui.get(), params->gvr_api, graphics_delegate.get(),
       params->ui_initial_state.in_web_vr, params->cardboard_gamepad,
       kSlidingAverageSize);
-  compositor_delegate->set_webxr_presentation_state(
-      scheduler_delegate->webxr());
+  graphics_delegate->set_webxr_presentation_state(scheduler_delegate->webxr());
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
-      base::BindOnce(&VrShellGl::Init, compositor_delegate->GetWeakPtr(),
+      base::BindOnce(&GvrGraphicsDelegate::Init,
+                     graphics_delegate->GetWeakPtr(),
                      base::Unretained(params->gl_surface_created_event),
                      base::Passed(std::move(params->surface_callback)),
                      params->ui_initial_state.in_web_vr));
-  auto render_loop = std::make_unique<RenderLoop>(
+  auto browser_renderer = std::make_unique<BrowserRenderer>(
       std::move(ui), std::move(scheduler_delegate),
-      std::move(compositor_delegate), std::move(controller_delegate),
+      std::move(graphics_delegate), std::move(controller_delegate),
       vr_gl_thread, kSlidingAverageSize);
-  return render_loop;
+  return browser_renderer;
 }
 
 }  // namespace vr

chrome/browser/android/vr/render_loop_factory.h → chrome/browser/android/vr/browser_renderer_factory.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_ANDROID_VR_RENDER_LOOP_FACTORY_H_
-#define CHROME_BROWSER_ANDROID_VR_RENDER_LOOP_FACTORY_H_
+#ifndef CHROME_BROWSER_ANDROID_VR_BROWSER_RENDERER_FACTORY_H_
+#define CHROME_BROWSER_ANDROID_VR_BROWSER_RENDERER_FACTORY_H_
 
 #include <memory>
 
@@ -22,11 +22,11 @@ class WaitableEvent;
 
 namespace vr {
 
-class RenderLoop;
+class BrowserRenderer;
 class UiFactory;
 class VrGLThread;
 
-class VR_EXPORT RenderLoopFactory {
+class VR_EXPORT BrowserRendererFactory {
  public:
   struct VR_EXPORT Params {
     Params(gvr::GvrApi* gvr_api,
@@ -48,11 +48,12 @@ class VR_EXPORT RenderLoopFactory {
     base::OnceCallback<gfx::AcceleratedWidget()> surface_callback;
   };
 
-  static std::unique_ptr<RenderLoop> Create(VrGLThread* vr_gl_thread,
-                                            UiFactory* ui_factory,
-                                            std::unique_ptr<Params> params);
+  static std::unique_ptr<BrowserRenderer> Create(
+      VrGLThread* vr_gl_thread,
+      UiFactory* ui_factory,
+      std::unique_ptr<Params> params);
 };
 
 }  // namespace vr
 
-#endif  // CHROME_BROWSER_ANDROID_VR_RENDER_LOOP_FACTORY_H_
+#endif  // CHROME_BROWSER_ANDROID_VR_BROWSER_RENDERER_FACTORY_H_

chrome/browser/android/vr/gl_browser_interface.h

@@ -9,7 +9,6 @@
 
 #include "base/android/jni_weak_ref.h"
 #include "chrome/browser/vr/assets_load_status.h"
-#include "chrome/browser/vr/render_loop_browser_interface.h"
 #include "chrome/browser/vr/ui_test_input.h"
 #include "device/vr/android/gvr/gvr_gamepad_data_provider.h"
 #include "device/vr/public/mojom/vr_service.mojom.h"
@@ -22,8 +21,7 @@ class SurfaceTexture;
 
 namespace vr {
 
-// VrShellGl talks to VrShell through this interface. This could be split up if
-// VrShellGl is refactored into components.
+// BrowserRenderer and its delegates talk to VrShell through this interface.
 class GlBrowserInterface {
  public:
   virtual ~GlBrowserInterface() {}

chrome/browser/android/vr/vr_shell_gl.h → chrome/browser/android/vr/gvr_graphics_delegate.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_ANDROID_VR_VR_SHELL_GL_H_
-#define CHROME_BROWSER_ANDROID_VR_VR_SHELL_GL_H_
+#ifndef CHROME_BROWSER_ANDROID_VR_GVR_GRAPHICS_DELEGATE_H_
+#define CHROME_BROWSER_ANDROID_VR_GVR_GRAPHICS_DELEGATE_H_
 
 #include <memory>
 #include <queue>
@@ -15,7 +15,7 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/android/vr/web_xr_presentation_state.h"
-#include "chrome/browser/vr/base_compositor_delegate.h"
+#include "chrome/browser/vr/base_graphics_delegate.h"
 #include "chrome/browser/vr/fps_meter.h"
 #include "chrome/browser/vr/render_info.h"
 #include "chrome/browser/vr/sliding_average.h"
@@ -70,18 +70,18 @@ struct Viewport {
   }
 };
 
-class VrShellGl : public BaseCompositorDelegate {
+class GvrGraphicsDelegate : public BaseGraphicsDelegate {
  public:
   using WebXrTokenSignaledCallback =
       base::OnceCallback<void(std::unique_ptr<gfx::GpuFence>)>;
-  VrShellGl(GlBrowserInterface* browser,
-            TexturesInitializedCallback textures_initialized_callback,
-            gvr::GvrApi* gvr_api,
-            bool reprojected_rendering,
-            bool pause_content,
-            bool low_density,
-            size_t sliding_time_size);
-  ~VrShellGl() override;
+  GvrGraphicsDelegate(GlBrowserInterface* browser,
+                      TexturesInitializedCallback textures_initialized_callback,
+                      gvr::GvrApi* gvr_api,
+                      bool reprojected_rendering,
+                      bool pause_content,
+                      bool low_density,
+                      size_t sliding_time_size);
+  ~GvrGraphicsDelegate() override;
 
   void set_webxr_presentation_state(WebXrPresentationState* webxr) {
     webxr_ = webxr;
@@ -89,7 +89,7 @@ class VrShellGl : public BaseCompositorDelegate {
   void Init(base::WaitableEvent* gl_surface_created_event,
             base::OnceCallback<gfx::AcceleratedWidget()> callback,
             bool start_in_webxr_mode);
-  base::WeakPtr<VrShellGl> GetWeakPtr();
+  base::WeakPtr<GvrGraphicsDelegate> GetWeakPtr();
 
   // GvrSchedulerDelegate communicates with this class through these functions.
   bool DoesSurfacelessRendering() const;
@@ -114,7 +114,7 @@ class VrShellGl : public BaseCompositorDelegate {
   gfx::Size webxr_surface_size() const { return webxr_surface_size_; }
 
  private:
-  // CompositorDelegate overrides.
+  // GraphicsDelegate overrides.
   void OnResume() override;
   FovRectangles GetRecommendedFovs() override;
   float GetZNear() override;
@@ -137,7 +137,7 @@ class VrShellGl : public BaseCompositorDelegate {
   void BufferBoundsChanged(const gfx::Size& content_buffer_size,
                            const gfx::Size& overlay_buffer_size) override;
   void ResumeContentRendering() override;
-  // End CompositorDelegate overrides.
+  // End GraphicsDelegate overrides.
 
   void UIBoundsChanged(int width, int height);
 
@@ -213,11 +213,11 @@ class VrShellGl : public BaseCompositorDelegate {
 
   std::vector<gvr::BufferSpec> specs_;
 
-  base::WeakPtrFactory<VrShellGl> weak_ptr_factory_;
+  base::WeakPtrFactory<GvrGraphicsDelegate> weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(VrShellGl);
+  DISALLOW_COPY_AND_ASSIGN(GvrGraphicsDelegate);
 };
 
 }  // namespace vr
 
-#endif  // CHROME_BROWSER_ANDROID_VR_VR_SHELL_GL_H_
+#endif  // CHROME_BROWSER_ANDROID_VR_GVR_GRAPHICS_DELEGATE_H_

chrome/browser/android/vr/gvr_scheduler_delegate.cc

@@ -15,7 +15,7 @@
 #include "chrome/browser/android/vr/mailbox_to_surface_bridge.h"
 #include "chrome/browser/android/vr/metrics_util_android.h"
 #include "chrome/browser/android/vr/scoped_gpu_trace.h"
-#include "chrome/browser/vr/scheduler_render_loop_interface.h"
+#include "chrome/browser/vr/scheduler_browser_renderer_interface.h"
 #include "chrome/browser/vr/scheduler_ui_interface.h"
 #include "content/public/common/content_features.h"
 #include "device/vr/android/gvr/gvr_delegate.h"
@@ -63,7 +63,7 @@ namespace vr {
 GvrSchedulerDelegate::GvrSchedulerDelegate(GlBrowserInterface* browser,
                                            SchedulerUiInterface* ui,
                                            gvr::GvrApi* gvr_api,
-                                           VrShellGl* graphics,
+                                           GvrGraphicsDelegate* graphics,
                                            bool start_in_web_xr_mode,
                                            bool cardboard_gamepad,
                                            size_t sliding_time_size)
@@ -93,9 +93,9 @@ GvrSchedulerDelegate::~GvrSchedulerDelegate() {
   webxr_.EndPresentation();
 }
 
-void GvrSchedulerDelegate::SetRenderLoop(
-    SchedulerRenderLoopInterface* render_loop) {
-  render_loop_ = render_loop;
+void GvrSchedulerDelegate::SetBrowserRenderer(
+    SchedulerBrowserRendererInterface* browser_renderer) {
+  browser_renderer_ = browser_renderer;
 }
 
 gfx::Transform GvrSchedulerDelegate::GetHeadPose() {
@@ -445,8 +445,8 @@ void GvrSchedulerDelegate::OnVSync(base::TimeTicks frame_time) {
     // rendering as WebVR uses the gamepad api. To ensure we always handle input
     // like app button presses, process the controller here.
     device::GvrDelegate::GetGvrPoseWithNeckModel(gvr_api_, &head_pose_);
-    DCHECK(render_loop_);
-    render_loop_->ProcessControllerInputForWebXr(frame_time);
+    DCHECK(browser_renderer_);
+    browser_renderer_->ProcessControllerInputForWebXr(frame_time);
   } else {
     DrawFrame(-1, frame_time);
   }
@@ -454,7 +454,7 @@ void GvrSchedulerDelegate::OnVSync(base::TimeTicks frame_time) {
 
 void GvrSchedulerDelegate::DrawFrame(int16_t frame_index,
                                      base::TimeTicks current_time) {
-  // TODO(acondor): Move this logic to RenderLoop::Draw.
+  // TODO(acondor): Move this logic to BrowserRenderer::Draw.
   TRACE_EVENT1("gpu", __func__, "frame", frame_index);
   bool is_webxr_frame = frame_index >= 0;
   if (!webxr_delayed_gvr_submit_.IsCancelled()) {
@@ -464,9 +464,9 @@ void GvrSchedulerDelegate::DrawFrame(int16_t frame_index,
     DCHECK(!is_webxr_frame)
         << "Unexpected WebXR DrawFrame during acquired frame";
     webxr_delayed_gvr_submit_.Cancel();
-    render_loop_->DrawBrowserFrame(current_time);
+    browser_renderer_->DrawBrowserFrame(current_time);
   }
-  DCHECK(render_loop_);
+  DCHECK(browser_renderer_);
 
   if (web_xr_mode_ && !ShouldDrawWebVr()) {
     // We're in a WebVR session, but don't want to draw WebVR frames, i.e.
@@ -520,9 +520,9 @@ void GvrSchedulerDelegate::DrawFrame(int16_t frame_index,
     return;
 
   if (is_webxr_frame)
-    render_loop_->DrawWebXrFrame(current_time);
+    browser_renderer_->DrawWebXrFrame(current_time);
   else
-    render_loop_->DrawBrowserFrame(current_time);
+    browser_renderer_->DrawBrowserFrame(current_time);
 
   SubmitDrawnFrame(is_webxr_frame);
 }
@@ -672,8 +672,8 @@ void GvrSchedulerDelegate::AddWebVrRenderTimeEstimate(
 
 void GvrSchedulerDelegate::DrawFrameSubmitNow(bool is_webxr_frame,
                                               const gfx::Transform& head_pose) {
-  TRACE_EVENT1("gpu", "VrShellGl::DrawFrameSubmitNow", "is_webxr_frame",
-               is_webxr_frame);
+  TRACE_EVENT1("gpu", "GvrSchedulerDelegate::DrawFrameSubmitNow",
+               "is_webxr_frame", is_webxr_frame);
 
   {
     std::unique_ptr<ScopedGpuTrace> browser_gpu_trace;
@@ -685,7 +685,7 @@ void GvrSchedulerDelegate::DrawFrameSubmitNow(bool is_webxr_frame,
       // that was inserted after Submit may not be complete yet when the next
       // Submit finishes.
       browser_gpu_trace = std::make_unique<ScopedGpuTrace>(
-          "gpu", "VrShellGl::PostSubmitDrawOnGpu");
+          "gpu", "GvrSchedulerDelegate::PostSubmitDrawOnGpu");
     }
     graphics_->SubmitToGvr(head_pose);
 
@@ -960,11 +960,11 @@ void GvrSchedulerDelegate::SendVSync() {
   int64_t prediction_nanos = GetPredictedFrameTime().InMicroseconds() * 1000;
 
   gfx::Transform head_mat;
-  TRACE_EVENT_BEGIN0("gpu", "VrShellGl::GetVRPosePtrWithNeckModel");
+  TRACE_EVENT_BEGIN0("gpu", "GvrSchedulerDelegate::GetVRPosePtrWithNeckModel");
   device::mojom::VRPosePtr pose =
       device::GvrDelegate::GetVRPosePtrWithNeckModel(gvr_api_, &head_mat,
                                                      prediction_nanos);
-  TRACE_EVENT_END0("gpu", "VrShellGl::GetVRPosePtrWithNeckModel");
+  TRACE_EVENT_END0("gpu", "GvrSchedulerDelegate::GetVRPosePtrWithNeckModel");
 
   // Process all events. Check for ones we wish to react to.
   gvr::Event last_event;
@@ -972,7 +972,7 @@ void GvrSchedulerDelegate::SendVSync() {
     pose->pose_reset |= last_event.type == GVR_EVENT_RECENTER;
   }
 
-  TRACE_EVENT0("gpu", "VrShellGl::XRInput");
+  TRACE_EVENT0("gpu", "GvrSchedulerDelegate::XRInput");
   if (cardboard_gamepad_) {
     std::vector<device::mojom::XRInputSourceStatePtr> input_states;
     input_states.push_back(GetGazeInputSourceState());
@@ -989,7 +989,7 @@ void GvrSchedulerDelegate::SendVSync() {
 
   frame_data->time_delta = pending_time_ - base::TimeTicks();
 
-  TRACE_EVENT0("gpu", "VrShellGl::RunCallback");
+  TRACE_EVENT0("gpu", "GvrSchedulerDelegate::RunCallback");
   std::move(get_frame_data_callback_).Run(std::move(frame_data));
 }
 
@@ -1162,7 +1162,8 @@ void GvrSchedulerDelegate::GetFrameData(
 void GvrSchedulerDelegate::SubmitFrameMissing(
     int16_t frame_index,
     const gpu::SyncToken& sync_token) {
-  TRACE_EVENT1("gpu", "VrShellGl::SubmitWebVRFrame", "frame", frame_index);
+  TRACE_EVENT1("gpu", "GvrSchedulerDelegate::SubmitWebVRFrame", "frame",
+               frame_index);
 
   if (!IsSubmitFrameExpected(frame_index))
     return;
@@ -1263,7 +1264,8 @@ bool GvrSchedulerDelegate::IsSubmitFrameExpected(int16_t frame_index) {
 
 bool GvrSchedulerDelegate::SubmitFrameCommon(int16_t frame_index,
                                              base::TimeDelta time_waited) {
-  TRACE_EVENT1("gpu", "VrShellGl::SubmitWebVRFrame", "frame", frame_index);
+  TRACE_EVENT1("gpu", "GvrSchedulerDelegate::SubmitWebVRFrame", "frame",
+               frame_index);
   DVLOG(2) << __func__ << ": frame=" << frame_index;
 
   if (!IsSubmitFrameExpected(frame_index))

chrome/browser/android/vr/gvr_scheduler_delegate.h

@@ -15,7 +15,7 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/android/vr/android_vsync_helper.h"
-#include "chrome/browser/android/vr/vr_shell_gl.h"
+#include "chrome/browser/android/vr/gvr_graphics_delegate.h"
 #include "chrome/browser/android/vr/web_xr_presentation_state.h"
 #include "chrome/browser/vr/fps_meter.h"
 #include "chrome/browser/vr/scheduler_delegate.h"
@@ -59,7 +59,7 @@ class GvrSchedulerDelegate : public SchedulerDelegate,
   GvrSchedulerDelegate(GlBrowserInterface* browser,
                        SchedulerUiInterface* ui,
                        gvr::GvrApi* gvr_api,
-                       VrShellGl* graphics,
+                       GvrGraphicsDelegate* graphics,
                        bool start_in_web_xr_mode,
                        bool cardboard_gamepad,
                        size_t sliding_time_size);
@@ -77,7 +77,8 @@ class GvrSchedulerDelegate : public SchedulerDelegate,
   void OnTriggerEvent(bool pressed) override;
   void SetWebXrMode(bool enabled) override;
   void SetShowingVrDialog(bool showing) override;
-  void SetRenderLoop(SchedulerRenderLoopInterface* render_loop) override;
+  void SetBrowserRenderer(
+      SchedulerBrowserRendererInterface* browser_renderer) override;
   void ConnectPresentingService(
       device::mojom::VRDisplayInfoPtr display_info,
       device::mojom::XRRuntimeSessionOptionsPtr options) override;
@@ -179,7 +180,7 @@ class GvrSchedulerDelegate : public SchedulerDelegate,
   gvr::GvrApi* gvr_api_;
 
   SchedulerUiInterface* ui_ = nullptr;
-  SchedulerRenderLoopInterface* render_loop_ = nullptr;
+  SchedulerBrowserRendererInterface* browser_renderer_ = nullptr;
 
   // Set from feature flags.
   const bool webvr_vsync_align_;
@@ -221,7 +222,7 @@ class GvrSchedulerDelegate : public SchedulerDelegate,
 
   int webvr_unstuff_ratelimit_frames_ = 0;
 
-  VrShellGl* graphics_;
+  GvrGraphicsDelegate* graphics_;
 
   // Attributes tracking WebVR rAF/VSync animation loop state. Blink schedules
   // a callback using the GetFrameData mojo call which is stored in

chrome/browser/android/vr/vr_gl_thread.cc

@@ -12,11 +12,11 @@
 #include "chrome/browser/android/vr/vr_input_connection.h"
 #include "chrome/browser/android/vr/vr_shell.h"
 #include "chrome/browser/vr/assets_loader.h"
+#include "chrome/browser/vr/browser_renderer.h"
 #include "chrome/browser/vr/browser_ui_interface.h"
 #include "chrome/browser/vr/model/assets.h"
 #include "chrome/browser/vr/model/omnibox_suggestions.h"
 #include "chrome/browser/vr/model/toolbar_state.h"
-#include "chrome/browser/vr/render_loop.h"
 #include "chrome/browser/vr/sounds_manager_audio_delegate.h"
 #include "chrome/browser/vr/ui_factory.h"
 #include "chrome/browser/vr/ui_test_input.h"
@@ -41,7 +41,7 @@ VrGLThread::VrGLThread(
       weak_vr_shell_(weak_vr_shell),
       main_thread_task_runner_(std::move(main_thread_task_runner)),
       gvr_api_(gvr::GvrApi::WrapNonOwned(gvr_api)),
-      factory_params_(std::make_unique<RenderLoopFactory::Params>(
+      factory_params_(std::make_unique<BrowserRendererFactory::Params>(
           gvr_api_.get(),
           ui_initial_state,
           reprojected_rendering,
@@ -58,8 +58,8 @@ VrGLThread::~VrGLThread() {
   Stop();
 }
 
-base::WeakPtr<RenderLoop> VrGLThread::GetRenderLoop() {
-  return render_loop_->GetWeakPtr();
+base::WeakPtr<BrowserRenderer> VrGLThread::GetBrowserRenderer() {
+  return browser_renderer_->GetWeakPtr();
 }
 
 void VrGLThread::SetInputConnection(VrInputConnection* input_connection) {
@@ -69,13 +69,13 @@ void VrGLThread::SetInputConnection(VrInputConnection* input_connection) {
 
 void VrGLThread::Init() {
   ui_factory_ = std::make_unique<UiFactory>();
-  render_loop_ = RenderLoopFactory::Create(this, ui_factory_.get(),
-                                           std::move(factory_params_));
-  weak_browser_ui_ = render_loop_->GetBrowserUiWeakPtr();
+  browser_renderer_ = BrowserRendererFactory::Create(
+      this, ui_factory_.get(), std::move(factory_params_));
+  weak_browser_ui_ = browser_renderer_->GetBrowserUiWeakPtr();
 }
 
 void VrGLThread::CleanUp() {
-  render_loop_.reset();
+  browser_renderer_.reset();
 }
 
 void VrGLThread::ContentSurfaceCreated(jobject surface,
@@ -173,7 +173,7 @@ void VrGLThread::ExitPresent() {
   DCHECK(OnGlThread());
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::BindOnce(&VrShell::ExitPresent, weak_vr_shell_));
-  render_loop_->OnExitPresent();
+  browser_renderer_->OnExitPresent();
 }
 
 void VrGLThread::ExitFullscreen() {

chrome/browser/android/vr/vr_gl_thread.h

@@ -11,14 +11,14 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
+#include "chrome/browser/android/vr/browser_renderer_factory.h"
 #include "chrome/browser/android/vr/gl_browser_interface.h"
 #include "chrome/browser/android/vr/gvr_keyboard_delegate.h"
-#include "chrome/browser/android/vr/render_loop_factory.h"
+#include "chrome/browser/vr/browser_renderer_browser_interface.h"
 #include "chrome/browser/vr/browser_ui_interface.h"
 #include "chrome/browser/vr/model/omnibox_suggestions.h"
 #include "chrome/browser/vr/model/sound_id.h"
 #include "chrome/browser/vr/platform_input_handler.h"
-#include "chrome/browser/vr/render_loop_browser_interface.h"
 #include "chrome/browser/vr/text_input_delegate.h"
 #include "chrome/browser/vr/ui_browser_interface.h"
 #include "chrome/browser/vr/ui_test_input.h"
@@ -40,7 +40,7 @@ class VrShell;
 
 class VrGLThread : public base::android::JavaHandlerThread,
                    public PlatformInputHandler,
-                   public RenderLoopBrowserInterface,
+                   public BrowserRendererBrowserInterface,
                    public GlBrowserInterface,
                    public UiBrowserInterface,
                    public BrowserUiInterface {
@@ -58,7 +58,7 @@ class VrGLThread : public base::android::JavaHandlerThread,
       base::OnceCallback<gfx::AcceleratedWidget()> surface_callback);
 
   ~VrGLThread() override;
-  base::WeakPtr<RenderLoop> GetRenderLoop();
+  base::WeakPtr<BrowserRenderer> GetBrowserRenderer();
   void SetInputConnection(VrInputConnection* input_connection);
 
   // GlBrowserInterface implementation (GL calling to VrShell).
@@ -72,7 +72,9 @@ class VrGLThread : public base::android::JavaHandlerThread,
                             gl::SurfaceTexture* texture) override;
   void UpdateGamepadData(device::GvrGamepadData) override;
   void ToggleCardboardGamepad(bool enabled) override;
-  // RenderLoopBrowserInterface implementation (RenderLoop calling to VrShell).
+
+  // BrowserRendererBrowserInterface implementation (BrowserRenderer calling to
+  // VrShell).
   void ForceExitVr() override;
   void ReportUiActivityResultForTesting(
       const VrUiTestActivityResult& result) override;
@@ -171,11 +173,11 @@ class VrGLThread : public base::android::JavaHandlerThread,
 
   // Created on GL thread.
   std::unique_ptr<UiFactory> ui_factory_;
-  std::unique_ptr<RenderLoop> render_loop_;
+  std::unique_ptr<BrowserRenderer> browser_renderer_;
   std::unique_ptr<gvr::GvrApi> gvr_api_;
 
-  // This state is used for initializing the RenderLoop.
-  std::unique_ptr<RenderLoopFactory::Params> factory_params_;
+  // This state is used for initializing the BrowserRenderer.
+  std::unique_ptr<BrowserRendererFactory::Params> factory_params_;
 
   DISALLOW_COPY_AND_ASSIGN(VrGLThread);
 };

chrome/browser/vr/BUILD.gn

@@ -196,9 +196,11 @@ component("vr_ui") {
 
 component("vr_common") {
   sources = [
-    "base_compositor_delegate.cc",
-    "base_compositor_delegate.h",
-    "compositor_delegate.h",
+    "base_graphics_delegate.cc",
+    "base_graphics_delegate.h",
+    "browser_renderer.cc",
+    "browser_renderer.h",
+    "browser_renderer_browser_interface.h",
     "controller_delegate.h",
     "controller_delegate_for_testing.cc",
     "controller_delegate_for_testing.h",
@@ -206,14 +208,12 @@ component("vr_common") {
     "fps_meter.h",
     "gesture_detector.cc",
     "gesture_detector.h",
+    "graphics_delegate.h",
     "platform_controller.h",
-    "render_loop.cc",
-    "render_loop.h",
-    "render_loop_browser_interface.h",
     "sample_queue.cc",
     "sample_queue.h",
+    "scheduler_browser_renderer_interface.h",
     "scheduler_delegate.h",
-    "scheduler_render_loop_interface.h",
     "service/browser_xr_runtime.cc",
     "service/browser_xr_runtime.h",
     "service/isolated_device_provider.cc",

chrome/browser/vr/base_compositor_delegate.cc → chrome/browser/vr/base_graphics_delegate.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/vr/base_compositor_delegate.h"
+#include "chrome/browser/vr/base_graphics_delegate.h"
 
 #include <utility>
 
@@ -15,14 +15,14 @@
 
 namespace vr {
 
-BaseCompositorDelegate::BaseCompositorDelegate() {}
+BaseGraphicsDelegate::BaseGraphicsDelegate() {}
 
-BaseCompositorDelegate::~BaseCompositorDelegate() {
+BaseGraphicsDelegate::~BaseGraphicsDelegate() {
   if (curr_context_id_ != kNone)
     contexts_[curr_context_id_]->ReleaseCurrent(surface_.get());
 }
 
-bool BaseCompositorDelegate::Initialize(
+bool BaseGraphicsDelegate::Initialize(
     const scoped_refptr<gl::GLSurface>& surface) {
   surface_ = surface;
   share_group_ = base::MakeRefCounted<gl::GLShareGroup>();
@@ -37,7 +37,7 @@ bool BaseCompositorDelegate::Initialize(
   return MakeContextCurrent(kMainContext);
 }
 
-bool BaseCompositorDelegate::RunInSkiaContext(SkiaContextCallback callback) {
+bool BaseGraphicsDelegate::RunInSkiaContext(SkiaContextCallback callback) {
   DCHECK_EQ(curr_context_id_, kMainContext);
   if (!MakeContextCurrent(kSkiaContext))
     return false;
@@ -45,13 +45,13 @@ bool BaseCompositorDelegate::RunInSkiaContext(SkiaContextCallback callback) {
   return MakeContextCurrent(kMainContext);
 }
 
-void BaseCompositorDelegate::SwapSurfaceBuffers() {
+void BaseGraphicsDelegate::SwapSurfaceBuffers() {
   TRACE_EVENT0("gpu", __func__);
   DCHECK(surface_);
   surface_->SwapBuffers(base::DoNothing());
 }
 
-bool BaseCompositorDelegate::MakeContextCurrent(ContextId context_id) {
+bool BaseGraphicsDelegate::MakeContextCurrent(ContextId context_id) {
   DCHECK(context_id > kNone && context_id < kNumContexts);
   if (curr_context_id_ == context_id)
     return true;

chrome/browser/vr/base_compositor_delegate.h → chrome/browser/vr/base_graphics_delegate.h

@@ -2,12 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_VR_BASE_COMPOSITOR_DELEGATE_H_
-#define CHROME_BROWSER_VR_BASE_COMPOSITOR_DELEGATE_H_
+#ifndef CHROME_BROWSER_VR_BASE_GRAPHICS_DELEGATE_H_
+#define CHROME_BROWSER_VR_BASE_GRAPHICS_DELEGATE_H_
 
 #include "base/macros.h"
 #include "base/memory/scoped_refptr.h"
-#include "chrome/browser/vr/compositor_delegate.h"
+#include "chrome/browser/vr/graphics_delegate.h"
 
 namespace gl {
 class GLContext;
@@ -17,12 +17,12 @@ class GLSurface;
 
 namespace vr {
 
-class VR_EXPORT BaseCompositorDelegate : public CompositorDelegate {
+class VR_EXPORT BaseGraphicsDelegate : public GraphicsDelegate {
  public:
-  BaseCompositorDelegate();
-  ~BaseCompositorDelegate() override;
+  BaseGraphicsDelegate();
+  ~BaseGraphicsDelegate() override;
 
-  // CompositorDelegate implementation.
+  // GraphicsDelegate implementation.
   bool Initialize(const scoped_refptr<gl::GLSurface>& surface) override;
   bool RunInSkiaContext(SkiaContextCallback callback) override;
 
@@ -39,9 +39,9 @@ class VR_EXPORT BaseCompositorDelegate : public CompositorDelegate {
   scoped_refptr<gl::GLContext> contexts_[kNumContexts];
   ContextId curr_context_id_ = kNone;
 
-  DISALLOW_COPY_AND_ASSIGN(BaseCompositorDelegate);
+  DISALLOW_COPY_AND_ASSIGN(BaseGraphicsDelegate);
 };
 
 }  // namespace vr
 
-#endif  // CHROME_BROWSER_VR_BASE_COMPOSITOR_DELEGATE_H_
+#endif  // CHROME_BROWSER_VR_BASE_GRAPHICS_DELEGATE_H_

chrome/browser/vr/render_loop.h → chrome/browser/vr/browser_renderer.h

@@ -2,16 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_VR_RENDER_LOOP_H_
-#define CHROME_BROWSER_VR_RENDER_LOOP_H_
+#ifndef CHROME_BROWSER_VR_BROWSER_RENDERER_H_
+#define CHROME_BROWSER_VR_BROWSER_RENDERER_H_
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
-#include "chrome/browser/vr/compositor_delegate.h"
 #include "chrome/browser/vr/gl_texture_location.h"
-#include "chrome/browser/vr/scheduler_render_loop_interface.h"
+#include "chrome/browser/vr/graphics_delegate.h"
+#include "chrome/browser/vr/scheduler_browser_renderer_interface.h"
 #include "chrome/browser/vr/sliding_average.h"
 #include "chrome/browser/vr/vr_export.h"
 #include "device/vr/public/mojom/isolated_xr_service.mojom.h"
@@ -20,7 +20,7 @@
 namespace base {
 class TimeDelta;
 class TimeTicks;
-}
+}  // namespace base
 
 namespace vr {
 
@@ -29,7 +29,7 @@ class BrowserUiInterface;
 class ControllerDelegate;
 class PlatformInputHandler;
 class PlatformUiInputDelegate;
-class RenderLoopBrowserInterface;
+class BrowserRendererBrowserInterface;
 class SchedulerDelegate;
 class UiInterface;
 struct ControllerTestInput;
@@ -37,19 +37,18 @@ struct RenderInfo;
 struct UiTestActivityExpectation;
 struct UiTestState;
 
-// The RenderLoop handles all input/output activities during a frame.
+// The BrowserRenderer handles all input/output activities during a frame.
 // This includes head movement, controller movement and input, audio output and
 // rendering of the frame.
-// TODO(acondor): Rename to BrowserRenderer.
-class VR_EXPORT RenderLoop : public SchedulerRenderLoopInterface {
+class VR_EXPORT BrowserRenderer : public SchedulerBrowserRendererInterface {
  public:
-  RenderLoop(std::unique_ptr<UiInterface> ui,
-             std::unique_ptr<SchedulerDelegate> scheduler_delegate,
-             std::unique_ptr<CompositorDelegate> compositor_delegate,
-             std::unique_ptr<ControllerDelegate> controller_delegate,
-             RenderLoopBrowserInterface* browser,
-             size_t sliding_time_size);
-  ~RenderLoop() override;
+  BrowserRenderer(std::unique_ptr<UiInterface> ui,
+                  std::unique_ptr<SchedulerDelegate> scheduler_delegate,
+                  std::unique_ptr<GraphicsDelegate> graphics_delegate,
+                  std::unique_ptr<ControllerDelegate> controller_delegate,
+                  BrowserRendererBrowserInterface* browser,
+                  size_t sliding_time_size);
+  ~BrowserRenderer() override;
 
   void OnPause();
   void OnResume();
@@ -72,7 +71,7 @@ class VR_EXPORT RenderLoop : public SchedulerRenderLoopInterface {
   void BufferBoundsChanged(const gfx::Size& content_buffer_size,
                            const gfx::Size& overlay_buffer_size);
 
-  base::WeakPtr<RenderLoop> GetWeakPtr();
+  base::WeakPtr<BrowserRenderer> GetWeakPtr();
   base::WeakPtr<BrowserUiInterface> GetBrowserUiWeakPtr();
 
   void PerformControllerActionForTesting(ControllerTestInput controller_input);
@@ -83,20 +82,20 @@ class VR_EXPORT RenderLoop : public SchedulerRenderLoopInterface {
       device::mojom::VRDisplayInfoPtr display_info,
       device::mojom::XRRuntimeSessionOptionsPtr options);
 
-  // SchedulerRenderLoopInterface implementation.
+  // SchedulerBrowserRendererInterface implementation.
   void DrawBrowserFrame(base::TimeTicks current_time) override;
   void DrawWebXrFrame(base::TimeTicks current_time) override;
   void ProcessControllerInputForWebXr(base::TimeTicks current_time) override;
 
  private:
-  void Draw(CompositorDelegate::FrameType frame_type,
+  void Draw(GraphicsDelegate::FrameType frame_type,
             base::TimeTicks current_time);
 
   // Position, hide and/or show UI elements, process input and update textures.
   // Returns true if the scene changed.
   void UpdateUi(const RenderInfo& render_info,
                 base::TimeTicks currrent_time,
-                CompositorDelegate::FrameType frame_type);
+                GraphicsDelegate::FrameType frame_type);
   void DrawWebXr();
   void DrawWebXrOverlay(const RenderInfo& render_info);
   void DrawContentQuad();
@@ -110,24 +109,24 @@ class VR_EXPORT RenderLoop : public SchedulerRenderLoopInterface {
 
   std::unique_ptr<UiInterface> ui_;
   std::unique_ptr<SchedulerDelegate> scheduler_delegate_;
-  std::unique_ptr<CompositorDelegate> compositor_delegate_;
+  std::unique_ptr<GraphicsDelegate> graphics_delegate_;
   std::unique_ptr<ControllerDelegate> controller_delegate_;
   std::unique_ptr<ControllerDelegate> controller_delegate_for_testing_;
   bool using_controller_delegate_for_testing_ = false;
 
   std::unique_ptr<PlatformUiInputDelegate> vr_dialog_input_delegate_;
 
-  RenderLoopBrowserInterface* browser_;
+  BrowserRendererBrowserInterface* browser_;
 
   std::unique_ptr<UiTestState> ui_test_state_;
   SlidingTimeDeltaAverage ui_processing_time_;
   SlidingTimeDeltaAverage ui_controller_update_time_;
 
-  base::WeakPtrFactory<RenderLoop> weak_ptr_factory_;
+  base::WeakPtrFactory<BrowserRenderer> weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(RenderLoop);
+  DISALLOW_COPY_AND_ASSIGN(BrowserRenderer);
 };
 
 }  // namespace vr
 
-#endif  // CHROME_BROWSER_VR_RENDER_LOOP_H_
+#endif  // CHROME_BROWSER_VR_BROWSER_RENDERER_H_

chrome/browser/vr/render_loop_browser_interface.h → chrome/browser/vr/browser_renderer_browser_interface.h

@@ -2,17 +2,17 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_VR_RENDER_LOOP_BROWSER_INTERFACE_H_
-#define CHROME_BROWSER_VR_RENDER_LOOP_BROWSER_INTERFACE_H_
+#ifndef CHROME_BROWSER_VR_BROWSER_RENDERER_BROWSER_INTERFACE_H_
+#define CHROME_BROWSER_VR_BROWSER_RENDERER_BROWSER_INTERFACE_H_
 
 #include "chrome/browser/vr/ui_test_input.h"
 
 namespace vr {
 
-// RenderLoop talks to the browser main thread through this interface.
-class RenderLoopBrowserInterface {
+// BrowserRenderer talks to the browser main thread through this interface.
+class BrowserRendererBrowserInterface {
  public:
-  virtual ~RenderLoopBrowserInterface() = default;
+  virtual ~BrowserRendererBrowserInterface() = default;
 
   virtual void ForceExitVr() = 0;
   virtual void ReportUiActivityResultForTesting(
@@ -21,4 +21,4 @@ class RenderLoopBrowserInterface {
 
 }  // namespace vr
 
-#endif  // CHROME_BROWSER_VR_RENDER_LOOP_BROWSER_INTERFACE_H_
+#endif  // CHROME_BROWSER_VR_BROWSER_RENDERER_BROWSER_INTERFACE_H_

chrome/browser/vr/compositor_delegate.h → chrome/browser/vr/graphics_delegate.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_VR_COMPOSITOR_DELEGATE_H_
-#define CHROME_BROWSER_VR_COMPOSITOR_DELEGATE_H_
+#ifndef CHROME_BROWSER_VR_GRAPHICS_DELEGATE_H_
+#define CHROME_BROWSER_VR_GRAPHICS_DELEGATE_H_
 
 #include "base/callback.h"
 #include "chrome/browser/vr/fov_rectangle.h"
@@ -13,7 +13,7 @@
 namespace gfx {
 class Size;
 class Transform;
-}
+}  // namespace gfx
 
 namespace gl {
 class GLSurface;
@@ -23,17 +23,17 @@ namespace vr {
 
 struct RenderInfo;
 
-// The CompositorDelegate manages surfaces, buffers and viewports, preparing
+// The GraphicsDelegate manages surfaces, buffers and viewports, preparing
 // them for drawing browser UI. It provides projection and view matrices for the
 // viewports.
-class VR_EXPORT CompositorDelegate {
+class VR_EXPORT GraphicsDelegate {
  public:
   using Transform = float[16];
   enum FrameType { kUiFrame, kWebXrFrame };
   using SkiaContextCallback = base::OnceCallback<void()>;
   using TexturesInitializedCallback = base::OnceCallback<
       void(GlTextureLocation, unsigned int, unsigned int, unsigned int)>;
-  virtual ~CompositorDelegate() {}
+  virtual ~GraphicsDelegate() {}
 
   virtual void OnResume() = 0;
 
@@ -67,4 +67,4 @@ class VR_EXPORT CompositorDelegate {
 
 }  // namespace vr
 
-#endif  // CHROME_BROWSER_VR_COMPOSITOR_DELEGATE_H_
+#endif  // CHROME_BROWSER_VR_GRAPHICS_DELEGATE_H_

chrome/browser/vr/scheduler_render_loop_interface.h → chrome/browser/vr/scheduler_browser_renderer_interface.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_VR_SCHEDULER_RENDER_LOOP_INTERFACE_H_
-#define CHROME_BROWSER_VR_SCHEDULER_RENDER_LOOP_INTERFACE_H_
+#ifndef CHROME_BROWSER_VR_SCHEDULER_BROWSER_RENDERER_INTERFACE_H_
+#define CHROME_BROWSER_VR_SCHEDULER_BROWSER_RENDERER_INTERFACE_H_
 
 namespace base {
 class TimeTicks;
@@ -11,9 +11,9 @@ class TimeTicks;
 
 namespace vr {
 
-class SchedulerRenderLoopInterface {
+class SchedulerBrowserRendererInterface {
  public:
-  virtual ~SchedulerRenderLoopInterface() {}
+  virtual ~SchedulerBrowserRendererInterface() {}
   virtual void DrawBrowserFrame(base::TimeTicks current_time) = 0;
   virtual void DrawWebXrFrame(base::TimeTicks current_time) = 0;
   virtual void ProcessControllerInputForWebXr(base::TimeTicks current_time) = 0;
@@ -21,4 +21,4 @@ class SchedulerRenderLoopInterface {
 
 }  // namespace vr
 
-#endif  // CHROME_BROWSER_VR_SCHEDULER_RENDER_LOOP_INTERFACE_H_
+#endif  // CHROME_BROWSER_VR_SCHEDULER_BROWSER_RENDERER_INTERFACE_H_

chrome/browser/vr/scheduler_delegate.h

@@ -17,11 +17,12 @@ class Transform;
 
 namespace vr {
 
-class SchedulerRenderLoopInterface;
+class SchedulerBrowserRendererInterface;
 
 // The SchedulerDelegate is responsible for starting the draw calls of the
-// RenderLoop, given different signals, such as WebXR frames submitted or VSync
-// events. It also provides head poses, obtained from the underlaying platform.
+// BrowserRenderer, given different signals, such as WebXR frames submitted or
+// VSync events. It also provides head poses, obtained from the underlaying
+// platform.
 // TODO(acondor): Move head pose logic to the ControllerDelegate.
 class VR_EXPORT SchedulerDelegate {
  public:
@@ -35,7 +36,8 @@ class VR_EXPORT SchedulerDelegate {
   virtual void OnTriggerEvent(bool pressed) = 0;
   virtual void SetWebXrMode(bool enabled) = 0;
   virtual void SetShowingVrDialog(bool showing) = 0;
-  virtual void SetRenderLoop(SchedulerRenderLoopInterface* render_loop) = 0;
+  virtual void SetBrowserRenderer(
+      SchedulerBrowserRendererInterface* browser_renderer) = 0;
   virtual void AddInputSourceState(
       device::mojom::XRInputSourceStatePtr state) = 0;
   virtual void ConnectPresentingService(

chrome/browser/vr/testapp/gl_renderer.cc

@@ -9,7 +9,6 @@
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
-#include "chrome/browser/vr/base_compositor_delegate.h"
 #include "chrome/browser/vr/render_info.h"
 #include "chrome/browser/vr/testapp/vr_test_context.h"
 #include "ui/gl/gl_bindings.h"
@@ -35,7 +34,7 @@ GlRenderer::GlRenderer() : weak_ptr_factory_(this) {}
 GlRenderer::~GlRenderer() {}
 
 bool GlRenderer::Initialize(const scoped_refptr<gl::GLSurface>& surface) {
-  if (!BaseCompositorDelegate::Initialize(surface))
+  if (!BaseGraphicsDelegate::Initialize(surface))
     return false;
   PostRenderFrameTask();
   return true;

chrome/browser/vr/testapp/gl_renderer.h

@@ -8,7 +8,7 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
-#include "chrome/browser/vr/base_compositor_delegate.h"
+#include "chrome/browser/vr/base_graphics_delegate.h"
 #include "ui/gfx/swap_result.h"
 
 namespace gl {
@@ -20,12 +20,12 @@ namespace vr {
 class VrTestContext;
 
 // This class manages an OpenGL context and initiates per-frame rendering.
-class GlRenderer : public BaseCompositorDelegate {
+class GlRenderer : public BaseGraphicsDelegate {
  public:
   GlRenderer();
   ~GlRenderer() override;
 
-  // CompositorDelegate implementation.
+  // GraphicsDelegate implementation.
   bool Initialize(const scoped_refptr<gl::GLSurface>& surface) override;
   void OnResume() override;
   FovRectangles GetRecommendedFovs() override;

chrome/browser/vr/testapp/vr_test_context.cc

@@ -15,8 +15,8 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
 #include "chrome/browser/vr/assets_load_status.h"
-#include "chrome/browser/vr/compositor_delegate.h"
 #include "chrome/browser/vr/gl_texture_location.h"
+#include "chrome/browser/vr/graphics_delegate.h"
 #include "chrome/browser/vr/model/assets.h"
 #include "chrome/browser/vr/model/model.h"
 #include "chrome/browser/vr/model/omnibox_suggestions.h"
@@ -102,9 +102,9 @@ InputEventList CreateScrollGestureEventList(InputEvent::Type type,
 
 }  // namespace
 
-VrTestContext::VrTestContext(CompositorDelegate* compositor_delegate)
+VrTestContext::VrTestContext(GraphicsDelegate* graphics_delegate)
     : view_scale_factor_(kDefaultViewScaleFactor),
-      compositor_delegate_(compositor_delegate) {
+      graphics_delegate_(graphics_delegate) {
   base::FilePath pak_path;
   base::PathService::Get(base::DIR_MODULE, &pak_path);
   ui::ResourceBundle::InitSharedInstanceWithPakPath(
@@ -183,7 +183,7 @@ void VrTestContext::DrawFrame() {
 
   UpdateController(render_info, current_time);
 
-  compositor_delegate_->RunInSkiaContext(
+  graphics_delegate_->RunInSkiaContext(
       base::BindOnce(&UiInterface::UpdateSceneTextures, base::Unretained(ui_)));
 
   auto load_progress = (current_time - page_load_start_).InMilliseconds() /

chrome/browser/vr/testapp/vr_test_context.h

@@ -23,7 +23,7 @@ class Event;
 
 namespace vr {
 
-class CompositorDelegate;
+class GraphicsDelegate;
 class TestKeyboardDelegate;
 class Ui;
 struct Model;
@@ -32,11 +32,10 @@ struct Model;
 // manipulates the UI according to user input.
 class VrTestContext : public vr::UiBrowserInterface {
  public:
-  explicit VrTestContext(CompositorDelegate* compositor_delgate);
+  explicit VrTestContext(GraphicsDelegate* compositor_delgate);
   ~VrTestContext() override;
 
-  // TODO(vollick): we should refactor VrShellGl's rendering logic and use it
-  // directly. crbug.com/767282
+  // TODO(acondor): Make use of BrowserRenderer (http://crbug.com/767282).
   void DrawFrame();
   void HandleInput(ui::Event* event);
 
@@ -117,7 +116,7 @@ class VrTestContext : public vr::UiBrowserInterface {
   int tab_id_ = 0;
   bool hosted_ui_enabled_ = false;
 
-  CompositorDelegate* compositor_delegate_;
+  GraphicsDelegate* graphics_delegate_;
   TestKeyboardDelegate* keyboard_delegate_;
 
   ControllerModel::Handedness handedness_ = ControllerModel::kRightHanded;

chrome/browser/vr/testapp/vr_testapp.cc

@@ -12,7 +12,7 @@
 #include "base/task/task_scheduler/task_scheduler.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
-#include "chrome/browser/vr/base_compositor_delegate.h"
+#include "chrome/browser/vr/base_graphics_delegate.h"
 #include "chrome/browser/vr/testapp/gl_renderer.h"
 #include "chrome/browser/vr/testapp/vr_test_context.h"
 #include "third_party/skia/include/core/SkBitmap.h"

device/vr/android/gvr/gvr_gamepad_data_provider.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef DEVICE_VR_ANDROID_GVR_GAMEPAD_DATA_PROVIDER_H
-#define DEVICE_VR_ANDROID_GVR_GAMEPAD_DATA_PROVIDER_H
+#ifndef DEVICE_VR_ANDROID_GVR_GVR_GAMEPAD_DATA_PROVIDER_H_
+#define DEVICE_VR_ANDROID_GVR_GVR_GAMEPAD_DATA_PROVIDER_H_
 
 #include "ui/gfx/geometry/quaternion.h"
 #include "ui/gfx/geometry/vector2d_f.h"
@@ -34,7 +34,7 @@ struct GvrGamepadData {
 };
 
 // This class exposes GVR controller data to the gamepad API. Data is
-// polled by VrShellGl, then pushed from VrShell which implements the
+// polled by GvrSchedulerDelegate, then pushed from VrShell which implements the
 // GvrGamepadDataProvider interface.
 //
 // More specifically, here's the lifecycle, assuming VrShell
@@ -73,4 +73,4 @@ class GvrGamepadDataProvider {
 };
 
 }  // namespace device
-#endif  // DEVICE_VR_ANDROID_GVR_GAMEPAD_DATA_PROVIDER_H
+#endif  // DEVICE_VR_ANDROID_GVR_GVR_GAMEPAD_DATA_PROVIDER_H_