Suffix VrShell calls with which thread they're expected to be run on.

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 "base/metrics/histogram_macros.h"
 #include "chrome/browser/android/vr_shell/ui_elements.h"
 #include "chrome/browser/android/vr_shell/ui_interface.h"
 #include "chrome/browser/android/vr_shell/ui_scene.h"
@@ skipping 159 matching lines @@
   if (for_web_vr)
     metrics_helper_->SetWebVREnabled(true);
   html_interface_.reset(new UiInterface(
       for_web_vr ? UiInterface::Mode::WEB_VR : UiInterface::Mode::STANDARD,
       main_contents_->IsFullscreen()));
   content_compositor_.reset(new VrCompositor(content_window, false));
   ui_compositor_.reset(new VrCompositor(ui_window, true));
   vr_web_contents_observer_.reset(new VrWebContentsObserver(
       main_contents, html_interface_.get(), this));
 
-  LoadUIContent();
+  LoadUIContentOnUI();
 
   gvr::Mat4f identity;
   SetIdentityM(identity);
   webvr_head_pose_.resize(kPoseRingBufferSize, identity);
   webvr_head_pose_valid_.resize(kPoseRingBufferSize, false);
 
   content_input_manager_.reset(new VrInputManager(main_contents_));
   ui_input_manager_.reset(new VrInputManager(ui_contents_));
   weak_content_input_manager_ = content_input_manager_->GetWeakPtr();
   weak_ui_input_manager_ = ui_input_manager_->GetWeakPtr();
 }
 
-void VrShell::UpdateCompositorLayers(JNIEnv* env,
+void VrShell::UpdateCompositorLayersOnUI(JNIEnv* env,
                                      const JavaParamRef<jobject>& obj) {
   content_compositor_->SetLayer(main_contents_);
   ui_compositor_->SetLayer(ui_contents_);
 }
 
-void VrShell::Destroy(JNIEnv* env, const JavaParamRef<jobject>& obj) {
+void VrShell::DestroyOnUI(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   delete this;
 }
 
-void VrShell::LoadUIContent() {
+void VrShell::LoadUIContentOnUI() {
   GURL url(kVrShellUIURL);
   ui_contents_->GetController().LoadURL(
       url, content::Referrer(),
       ui::PageTransition::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string(""));
 }
 
 bool RegisterVrShell(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 VrShell::~VrShell() {
   if (delegate_ && delegate_->GetDeviceProvider()) {
     delegate_->GetDeviceProvider()->OnGvrDelegateRemoved();
   }
   g_instance = nullptr;
   gl::init::ShutdownGL();
 }
 
-void VrShell::SetDelegate(JNIEnv* env,
+void VrShell::SetDelegateOnUI(JNIEnv* env,
     const base::android::JavaParamRef<jobject>& obj,
     const base::android::JavaParamRef<jobject>& delegate) {
   base::AutoLock lock(gvr_init_lock_);
   delegate_ = VrShellDelegate::GetNativeDelegate(env, delegate);
   if (swap_chain_.get()) {
-    main_thread_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&device::GvrDeviceProvider::OnGvrDelegateReady,
-                              delegate_->GetDeviceProvider(),
-                              weak_ptr_factory_.GetWeakPtr()));
+    delegate_->GetDeviceProvider()->OnGvrDelegateReady(
+        weak_ptr_factory_.GetWeakPtr());
   }
 }
 
 enum class ViewerType {
   UNKNOWN_TYPE = 0,
   CARDBOARD = 1,
   DAYDREAM = 2,
   VIEWER_TYPE_MAX,
 };
 
-void VrShell::GvrInit(JNIEnv* env,
+void VrShell::GvrInitOnGL(JNIEnv* env,
                       const JavaParamRef<jobject>& obj,
                       jlong native_gvr_api) {
   // set the initial webvr state
   metrics_helper_->SetVRActive(true);
 
   gvr_api_ =
       gvr::GvrApi::WrapNonOwned(reinterpret_cast<gvr_context*>(native_gvr_api));
   // TODO(klausw,crbug.com/655722): should report OnGvrDelegateReady here once
   // we switch to using a WebVR render surface. We currently need to wait for
   // the compositor window's size to be known first. See also
@@ skipping 12 matching lines @@
       break;
     default:
       NOTREACHED();
       viewerType = ViewerType::UNKNOWN_TYPE;
       break;
   }
   UMA_HISTOGRAM_ENUMERATION("VRViewerType", static_cast<int>(viewerType),
       static_cast<int>(ViewerType::VIEWER_TYPE_MAX));
 }
 
-void VrShell::InitializeGl(JNIEnv* env,
+void VrShell::InitializeGlOnGL(JNIEnv* env,
                            const JavaParamRef<jobject>& obj,
                            jint content_texture_handle,
                            jint ui_texture_handle) {
   base::AutoLock lock(gvr_init_lock_);
   CHECK(gl::GetGLImplementation() != gl::kGLImplementationNone ||
         gl::init::InitializeGLOneOff());
 
   content_texture_id_ = content_texture_handle;
   ui_texture_id_ = ui_texture_handle;
 
@@ skipping 72 matching lines @@
   webvr_right_viewport_->SetSourceBufferIndex(kFramePrimaryBuffer);
 
   if (delegate_) {
     main_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&device::GvrDeviceProvider::OnGvrDelegateReady,
                               delegate_->GetDeviceProvider(),
                               weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
-void VrShell::UpdateController(const gvr::Vec3f& forward_vector) {
+void VrShell::UpdateControllerOnGL(const gvr::Vec3f& forward_vector) {
   controller_->UpdateState();
 
 #if defined(ENABLE_VR_SHELL)
   // Note that button up/down state is transient, so IsButtonUp only returns
   // true for a single frame (and we're guaranteed not to miss it).
   if (controller_->IsButtonUp(
           gvr::ControllerButton::GVR_CONTROLLER_BUTTON_APP)) {
     html_interface_->SetMenuMode(!html_interface_->GetMenuMode());
 
     // TODO(mthiesse): The page is no longer visible when in menu mode. We
@@ skipping 13 matching lines @@
     if (touch_pending_ || controller_->IsButtonUp(
             gvr::ControllerButton::GVR_CONTROLLER_BUTTON_CLICK)) {
       touch_pending_ = false;
       std::unique_ptr<WebGestureEvent> gesture(new WebGestureEvent());
       gesture->sourceDevice = blink::WebGestureDeviceTouchpad;
       gesture->timeStampSeconds =
           (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
       gesture->type = WebInputEvent::GestureTapDown;
       gesture->data.tapDown.width = 0;
       gesture->data.tapDown.height = 0;
-      SendGesture(CONTENT, std::move(gesture));
+      SendGestureOnGL(CONTENT, std::move(gesture));
     }
 
     return;
   }
 
   gvr::Vec3f ergo_neutral_pose;
   if (!controller_->IsConnected()) {
     // No controller detected, set up a gaze cursor that tracks the
     // forward direction.
     ergo_neutral_pose = {0.0f, 0.0f, -1.0f};
@@ skipping 74 matching lines @@
                       plane->copy_rect.width, plane->copy_rect.height};
       }
       pixel_x = pixel_rect.width * x + pixel_rect.x;
       pixel_y = pixel_rect.height * y + pixel_rect.y;
 
       target_point_ = plane_intersection_point;
       target_element_ = plane.get();
       input_target = plane->content_quad ? CONTENT : UI;
     }
   }
-  SendEventsToTarget(input_target, pixel_x, pixel_y);
+  SendEventsToTargetOnGL(input_target, pixel_x, pixel_y);
 }
 
-void VrShell::SendEventsToTarget(InputTarget input_target,
+void VrShell::SendEventsToTargetOnGL(InputTarget input_target,
                                  int pixel_x,
                                  int pixel_y) {
   std::vector<std::unique_ptr<WebGestureEvent>> gesture_list =
       controller_->DetectGestures();
   std::unique_ptr<WebGestureEvent> gesture = std::move(gesture_list.front());
 
   // TODO(asimjour) for now, scroll is sent to the main content.
   if (gesture->type == WebInputEvent::GestureScrollBegin ||
       gesture->type == WebInputEvent::GestureScrollUpdate ||
       gesture->type == WebInputEvent::GestureScrollEnd ||
       gesture->type == WebInputEvent::GestureFlingCancel) {
-    SendGesture(CONTENT, base::WrapUnique(new WebGestureEvent(*gesture)));
+    SendGestureOnGL(CONTENT, base::WrapUnique(new WebGestureEvent(*gesture)));
   }
 
   if (gesture->type == WebInputEvent::GestureScrollEnd) {
     CHECK(gesture_list.size() == 2);
     if (gesture_list.back()->type == WebInputEvent::GestureTapDown) {
       gesture_list.back()->data.tapDown.width = pixel_x;
       gesture_list.back()->data.tapDown.height = pixel_y;
       if (input_target != NONE)
-        SendGesture(input_target, std::move(gesture_list.back()));
+        SendGestureOnGL(input_target, std::move(gesture_list.back()));
     } else if (gesture_list.back()->type == WebInputEvent::GestureFlingStart) {
-      SendGesture(CONTENT, std::move(gesture_list.back()));
+      SendGestureOnGL(CONTENT, std::move(gesture_list.back()));
     } else {
       NOTREACHED();
     }
   }
 
   WebInputEvent::Type original_type = gesture->type;
 
   bool new_target = input_target != current_input_target_;
   if (new_target && current_input_target_ != NONE) {
     // Send a move event indicating that the pointer moved off of an element.
-    SendGesture(current_input_target_, MakeMouseEvent(
+    SendGestureOnGL(current_input_target_, MakeMouseEvent(
         WebInputEvent::MouseLeave, gesture->timeStampSeconds, 0, 0));
   }
   current_input_target_ = input_target;
   if (current_input_target_ == NONE) {
     return;
   }
   WebInputEvent::Type type =
       new_target ? WebInputEvent::MouseEnter : WebInputEvent::MouseMove;
-  SendGesture(current_input_target_, MakeMouseEvent(
+  SendGestureOnGL(current_input_target_, MakeMouseEvent(
       type, gesture->timeStampSeconds, pixel_x, pixel_y));
 
   if (original_type == WebInputEvent::GestureTapDown || touch_pending_) {
     std::unique_ptr<WebGestureEvent> event(new WebGestureEvent(*gesture));
     if (touch_pending_) {
       touch_pending_ = false;
       event->sourceDevice = blink::WebGestureDeviceTouchpad;
       event->timeStampSeconds =
           (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
     }
     event->type = WebInputEvent::GestureTapDown;
     event->data.tapDown.width = pixel_x;
     event->data.tapDown.height = pixel_y;
-    SendGesture(current_input_target_, std::move(event));
+    SendGestureOnGL(current_input_target_, std::move(event));
   }
 }
 
-void VrShell::SendGesture(InputTarget input_target,
+void VrShell::SendGestureOnGL(InputTarget input_target,
                           std::unique_ptr<blink::WebInputEvent> event) {
   DCHECK(input_target != NONE);
   const base::WeakPtr<VrInputManager>& weak_ptr =
       input_target == CONTENT ? weak_content_input_manager_
                               : weak_ui_input_manager_;
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VrInputManager::ProcessUpdatedGesture, weak_ptr,
                  base::Passed(std::move(event))));
 }
@@ skipping 23 matching lines @@
   if (pixels[1] == kWebVrPosePixelMagicNumbers[0] &&
       pixels[2] == kWebVrPosePixelMagicNumbers[1]) {
     // Pose is good.
     return pixels[0];
   }
   VLOG(1) << "WebVR: reject decoded pose index " << (int)pixels[0] <<
       ", bad magic number " << (int)pixels[1] << ", " << (int)pixels[2];
   return -1;
 }
 
-bool VrShell::WebVrPoseByteIsValid(int pose_index_byte) {
+bool VrShell::WebVrPoseByteIsValidOnGL(int pose_index_byte) {
   if (pose_index_byte < 0) {
     return false;
   }
   if (!webvr_head_pose_valid_[pose_index_byte % kPoseRingBufferSize]) {
     VLOG(1) << "WebVR: reject decoded pose index " << pose_index_byte <<
         ", not a valid pose";
     return false;
   }
   return true;
 }
 
-void VrShell::DrawFrame(JNIEnv* env, const JavaParamRef<jobject>& obj) {
+void VrShell::DrawFrameOnGL(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   TRACE_EVENT0("gpu", "VrShell::DrawFrame");
   // Reset the viewport list to just the pair of viewports for the
   // primary buffer each frame. Head-locked viewports get added by
   // DrawVrShell if needed.
   buffer_viewport_list_->SetToRecommendedBufferViewports();
 
   if (html_interface_->GetMode() == UiInterface::Mode::WEB_VR) {
     // If needed, resize the primary buffer for use with WebVR.
     if (render_size_primary_ != render_size_primary_webvr_) {
       if (!render_size_primary_webvr_.width) {
@@ skipping 23 matching lines @@
     // The head pose has redundant data. Assume we're only using the
     // object_from_reference_matrix, we're not updating position_external.
     // TODO: Not sure what object_from_reference_matrix is. The new api removed
     // it. For now, removing it seems working fine.
     gvr_api_->ApplyNeckModel(head_pose, 1.0f);
   }
 
   // Bind the primary framebuffer.
   frame.BindBuffer(kFramePrimaryBuffer);
 
-  HandleQueuedTasks();
+  HandleQueuedTasksOnGL();
 
   // Update the render position of all UI elements (including desktop).
   const float screen_tilt = kDesktopScreenTiltDefault * M_PI / 180.0f;
   scene_->UpdateTransforms(screen_tilt, UiScene::TimeInMicroseconds());
 
-  UpdateController(GetForwardVector(head_pose));
+  UpdateControllerOnGL(GetForwardVector(head_pose));
 
   if (html_interface_->GetMode() == UiInterface::Mode::WEB_VR) {
-    DrawWebVr();
+    DrawWebVrOnGL();
 
     // When using async reprojection, we need to know which pose was used in
     // the WebVR app for drawing this frame. Due to unknown amounts of
     // buffering in the compositor and SurfaceTexture, we read the pose number
     // from a corner pixel. There's no point in doing this for legacy
     // distortion rendering since that doesn't need a pose, and reading back
     // pixels is an expensive operation. TODO(klausw,crbug.com/655722): stop
     // doing this once we have working no-compositor rendering for WebVR.
     if (gvr_api_->GetAsyncReprojectionEnabled()) {
       int pose_index_byte = GetPixelEncodedPoseIndexByte();
-      if (WebVrPoseByteIsValid(pose_index_byte)) {
+      if (WebVrPoseByteIsValidOnGL(pose_index_byte)) {
         // We have a valid pose, use it for reprojection.
         webvr_left_viewport_->SetReprojection(GVR_REPROJECTION_FULL);
         webvr_right_viewport_->SetReprojection(GVR_REPROJECTION_FULL);
         head_pose = webvr_head_pose_[pose_index_byte % kPoseRingBufferSize];
         // We can't mark the used pose as invalid since unfortunately
         // we have to reuse them. The compositor will re-submit stale
         // frames on vsync, and we can't tell that this has happened
         // until we've read the pose index from it, and at that point
         // it's too late to skip rendering.
       } else {
         // If we don't get a valid frame ID back we shouldn't attempt
         // to reproject by an invalid matrix, so turn off reprojection
         // instead. Invalid poses can permanently break reprojection
         // for this GVR instance: http://crbug.com/667327
         webvr_left_viewport_->SetReprojection(GVR_REPROJECTION_NONE);
         webvr_right_viewport_->SetReprojection(GVR_REPROJECTION_NONE);
       }
     }
   }
 
-  DrawVrShell(head_pose, frame);
+  DrawVrShellOnGL(head_pose, frame);
 
   frame.Unbind();
   frame.Submit(*buffer_viewport_list_, head_pose);
 }
 
-void VrShell::DrawVrShell(const gvr::Mat4f& head_pose,
+void VrShell::DrawVrShellOnGL(const gvr::Mat4f& head_pose,
                           gvr::Frame &frame) {
   TRACE_EVENT0("gpu", "VrShell::DrawVrShell");
   std::vector<const ContentRectangle*> head_locked_elements;
   std::vector<const ContentRectangle*> world_elements;
   for (const auto& rect : scene_->GetUiElements()) {
     if (!rect->visible) {
       continue;
     }
     if (rect->lock_to_fov) {
       head_locked_elements.push_back(rect.get());
@@ skipping 14 matching lines @@
     // Non-WebVR mode, enable depth testing and clear the primary buffers.
     glEnable(GL_CULL_FACE);
     glEnable(GL_DEPTH_TEST);
     glDepthMask(GL_TRUE);
 
     glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   }
 
   if (!world_elements.empty()) {
-    DrawUiView(&head_pose, world_elements, render_size_primary_,
+    DrawUiViewOnGL(&head_pose, world_elements, render_size_primary_,
                kViewportListPrimaryOffset);
   }
 
   if (!head_locked_elements.empty()) {
     // Add head-locked viewports. The list gets reset to just
     // the recommended viewports (for the primary buffer) each frame.
     buffer_viewport_list_->SetBufferViewport(
         kViewportListHeadlockedOffset + GVR_LEFT_EYE,
         *headlocked_left_viewport_);
     buffer_viewport_list_->SetBufferViewport(
         kViewportListHeadlockedOffset + GVR_RIGHT_EYE,
         *headlocked_right_viewport_);
 
     // Bind the headlocked framebuffer.
     frame.BindBuffer(kFrameHeadlockedBuffer);
     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    DrawUiView(nullptr, head_locked_elements, render_size_headlocked_,
+    DrawUiViewOnGL(nullptr, head_locked_elements, render_size_headlocked_,
                kViewportListHeadlockedOffset);
   }
 }
 
 void VrShell::SetWebVRRenderSurfaceSize(int width, int height) {
   render_size_primary_webvr_.width = width;
   render_size_primary_webvr_.height = height;
   // TODO(klausw,crbug.com/655722): set the WebVR render surface size here once
   // we have that.
 }
 
 gvr::Sizei VrShell::GetWebVRCompositorSurfaceSize() {
   // This is a stopgap while we're using the WebVR compositor rendering path.
   // TODO(klausw,crbug.com/655722): Remove this method and member once we're
   // using a separate WebVR render surface.
   return content_tex_physical_size_;
 }
 
 
-void VrShell::DrawUiView(const gvr::Mat4f* head_pose,
+void VrShell::DrawUiViewOnGL(const gvr::Mat4f* head_pose,
                          const std::vector<const ContentRectangle*>& elements,
                          const gvr::Sizei& render_size, int viewport_offset) {
   TRACE_EVENT0("gpu", "VrShell::DrawUiView");
   for (auto eye : {GVR_LEFT_EYE, GVR_RIGHT_EYE}) {
     buffer_viewport_list_->GetBufferViewport(
         eye + viewport_offset, buffer_viewport_.get());
 
     gvr::Mat4f view_matrix = gvr_api_->GetEyeFromHeadMatrix(eye);
     if (head_pose != nullptr) {
       view_matrix = MatrixMul(view_matrix, *head_pose);
     }
 
     gvr::Recti pixel_rect =
         CalculatePixelSpaceRect(render_size, buffer_viewport_->GetSourceUv());
     glViewport(pixel_rect.left, pixel_rect.bottom,
                pixel_rect.right - pixel_rect.left,
                pixel_rect.top - pixel_rect.bottom);
 
     const gvr::Mat4f render_matrix = MatrixMul(
         PerspectiveMatrixFromView(
             buffer_viewport_->GetSourceFov(), kZNear, kZFar),
         view_matrix);
 
-    DrawElements(render_matrix, elements);
+    DrawElementsOnGL(render_matrix, elements);
     if (head_pose != nullptr &&
         html_interface_->GetMode() != UiInterface::Mode::WEB_VR) {
-      DrawCursor(render_matrix);
+      DrawCursorOnGL(render_matrix);
     }
   }
 }
 
-void VrShell::DrawElements(
+void VrShell::DrawElementsOnGL(
     const gvr::Mat4f& render_matrix,
     const std::vector<const ContentRectangle*>& elements) {
   for (const auto& rect : elements) {
     Rectf copy_rect;
     jint texture_handle;
     if (rect->content_quad) {
       copy_rect = {0, 0, 1, 1};
       texture_handle = content_texture_id_;
     } else {
       copy_rect.x = static_cast<float>(rect->copy_rect.x) / ui_tex_css_width_;
       copy_rect.y = static_cast<float>(rect->copy_rect.y) / ui_tex_css_height_;
       copy_rect.width = static_cast<float>(rect->copy_rect.width) /
           ui_tex_css_width_;
       copy_rect.height = static_cast<float>(rect->copy_rect.height) /
           ui_tex_css_height_;
       texture_handle = ui_texture_id_;
     }
     gvr::Mat4f transform = MatrixMul(render_matrix, rect->transform.to_world);
     vr_shell_renderer_->GetTexturedQuadRenderer()->Draw(
         texture_handle, transform, copy_rect);
   }
 }
 
-void VrShell::DrawCursor(const gvr::Mat4f& render_matrix) {
+void VrShell::DrawCursorOnGL(const gvr::Mat4f& render_matrix) {
   gvr::Mat4f mat;
   SetIdentityM(mat);
 
   // Draw the reticle.
 
   // Scale the pointer to have a fixed FOV size at any distance.
   const float eye_to_target = Distance(target_point_, kOrigin);
   ScaleM(mat, mat, kReticleWidth * eye_to_target,
          kReticleHeight * eye_to_target, 1.0f);
 
@@ skipping 32 matching lines @@
   mat = MatrixMul(QuatToMatrix(q), mat);
 
   const gvr::Vec3f beam_direction = {
     target_point_.x - kHandPosition.x,
     target_point_.y - kHandPosition.y,
     target_point_.z - kHandPosition.z
   };
   const gvr::Mat4f beam_direction_mat =
       QuatToMatrix(GetRotationFromZAxis(beam_direction));
 
-
   // Render multiple faces to make the laser appear cylindrical.
   const int faces = 4;
   for (int i = 0; i < faces; i++) {
     // Rotate around Z.
     const float angle = M_PI * 2 * i / faces;
     const gvr::Quatf rot = QuatFromAxisAngle({0.0f, 0.0f, 1.0f}, angle);
     gvr::Mat4f face_transform = MatrixMul(QuatToMatrix(rot), mat);
 
     // Orient according to target direction.
     face_transform = MatrixMul(beam_direction_mat, face_transform);
 
     // Move the beam origin to the hand.
     TranslateM(face_transform, face_transform, kHandPosition.x, kHandPosition.y,
                kHandPosition.z);
 
     transform = MatrixMul(render_matrix, face_transform);
     vr_shell_renderer_->GetLaserRenderer()->Draw(transform);
   }
 }
 
-void VrShell::DrawWebVr() {
+void VrShell::DrawWebVrOnGL() {
   TRACE_EVENT0("gpu", "VrShell::DrawWebVr");
   // Don't need face culling, depth testing, blending, etc. Turn it all off.
   glDisable(GL_CULL_FACE);
   glDepthMask(GL_FALSE);
   glDisable(GL_DEPTH_TEST);
   glDisable(GL_SCISSOR_TEST);
   glDisable(GL_BLEND);
   glDisable(GL_POLYGON_OFFSET_FILL);
 
   glViewport(0, 0, render_size_primary_.width, render_size_primary_.height);
   vr_shell_renderer_->GetWebVrRenderer()->Draw(webvr_texture_id_);
 
   buffer_viewport_list_->SetBufferViewport(GVR_LEFT_EYE,
                                            *webvr_left_viewport_);
   buffer_viewport_list_->SetBufferViewport(GVR_RIGHT_EYE,
                                            *webvr_right_viewport_);
 }
 
-void VrShell::OnTriggerEvent(JNIEnv* env, const JavaParamRef<jobject>& obj) {
+void VrShell::OnTriggerEventOnUI(JNIEnv* env,
+                                 const JavaParamRef<jobject>& obj) {
   // Set a flag to handle this on the render thread at the next frame.
   touch_pending_ = true;
 }
 
-void VrShell::OnPause(JNIEnv* env, const JavaParamRef<jobject>& obj) {
+void VrShell::OnPauseOnUI(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   if (gvr_api_ == nullptr)
     return;
+
+  // TODO(mthiesse): Clean up threading here.
   controller_->OnPause();
   gvr_api_->PauseTracking();
 
   // exit vr session
   metrics_helper_->SetVRActive(false);
 }
 
-void VrShell::OnResume(JNIEnv* env, const JavaParamRef<jobject>& obj) {
+void VrShell::OnResumeOnUI(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   if (gvr_api_ == nullptr)
     return;
 
+  // TODO(mthiesse): Clean up threading here.
   gvr_api_->RefreshViewerProfile();
   gvr_api_->ResumeTracking();
   controller_->OnResume();
 
   // exit vr session
   metrics_helper_->SetVRActive(true);
 }
 
-base::WeakPtr<VrShell> VrShell::GetWeakPtr(
+base::WeakPtr<VrShell> VrShell::GetWeakPtrOnUI(
     const content::WebContents* web_contents) {
   // Ensure that the WebContents requesting the VrShell instance is the one
   // we created.
   if (g_instance != nullptr && g_instance->ui_contents_ == web_contents)
     return g_instance->weak_ptr_factory_.GetWeakPtr();
   return base::WeakPtr<VrShell>(nullptr);
 }
 
-void VrShell::OnDomContentsLoaded() {
+void VrShell::OnDomContentsLoadedOnUI() {
   html_interface_->SetURL(main_contents_->GetVisibleURL());
   html_interface_->SetLoading(main_contents_->IsLoading());
   html_interface_->OnDomContentsLoaded();
 }
 
-void VrShell::SetWebVrMode(JNIEnv* env,
+void VrShell::SetWebVrModeOnUI(JNIEnv* env,
                            const base::android::JavaParamRef<jobject>& obj,
                            bool enabled) {
   metrics_helper_->SetWebVREnabled(enabled);
   if (enabled) {
     html_interface_->SetMode(UiInterface::Mode::WEB_VR);
   } else {
     html_interface_->SetMode(UiInterface::Mode::STANDARD);
   }
 }
 
 void VrShell::SetWebVRSecureOrigin(bool secure_origin) {
   html_interface_->SetSecureOrigin(secure_origin);
 }
 
 void VrShell::SubmitWebVRFrame() {}
 
 void VrShell::UpdateWebVRTextureBounds(const gvr::Rectf& left_bounds,
                                        const gvr::Rectf& right_bounds) {
   webvr_left_viewport_->SetSourceUv(left_bounds);
   webvr_right_viewport_->SetSourceUv(right_bounds);
 }
 
 gvr::GvrApi* VrShell::gvr_api() {
   return gvr_api_.get();
 }
 
-void VrShell::SurfacesChanged(JNIEnv* env,
+void VrShell::SurfacesChangedOnUI(JNIEnv* env,
                               const JavaParamRef<jobject>& object,
                               const JavaParamRef<jobject>& content_surface,
                               const JavaParamRef<jobject>& ui_surface) {
   content_compositor_->SurfaceChanged(content_surface);
   ui_compositor_->SurfaceChanged(ui_surface);
 }
 
-void VrShell::ContentBoundsChanged(JNIEnv* env,
+void VrShell::ContentBoundsChangedOnUI(JNIEnv* env,
                                    const JavaParamRef<jobject>& object,
                                    jint width, jint height, jfloat dpr) {
   TRACE_EVENT0("gpu", "VrShell::ContentBoundsChanged");
   content_tex_physical_size_.width = width;
   content_tex_physical_size_.height = height;
   // TODO(mthiesse): Synchronize with GL thread, and update tex css size in
   // response to MainFrameWasResized, not here.
   content_tex_css_width_ = width / dpr;
   content_tex_css_height_ = height / dpr;
 
   content_compositor_->SetWindowBounds(width, height);
 }
 
-void VrShell::UIBoundsChanged(JNIEnv* env,
+void VrShell::UIBoundsChangedOnUI(JNIEnv* env,
                               const JavaParamRef<jobject>& object,
                               jint width, jint height, jfloat dpr) {
   ui_compositor_->SetWindowBounds(width, height);
 }
 
-UiScene* VrShell::GetScene() {
+UiScene* VrShell::GetSceneOnGL() {
   return scene_.get();
 }
 
-UiInterface* VrShell::GetUiInterface() {
+UiInterface* VrShell::GetUiInterfaceOnGL() {
   return html_interface_.get();
 }
 
-void VrShell::QueueTask(base::Callback<void()>& callback) {
+void VrShell::QueueTaskOnUI(base::Callback<void()>& callback) {
   base::AutoLock lock(task_queue_lock_);
   task_queue_.push(callback);
 }
 
-void VrShell::HandleQueuedTasks() {
+void VrShell::HandleQueuedTasksOnGL() {
   // To protect a stream of tasks from blocking rendering indefinitely,
   // process only the number of tasks present when first checked.
   std::vector<base::Callback<void()>> tasks;
   {
     base::AutoLock lock(task_queue_lock_);
     const size_t count = task_queue_.size();
     for (size_t i = 0; i < count; i++) {
       tasks.push_back(task_queue_.front());
       task_queue_.pop();
     }
   }
   for (auto &task : tasks) {
     task.Run();
   }
 }
 
-void VrShell::DoUiAction(const UiAction action) {
+void VrShell::DoUiActionOnUI(const UiAction action) {
   content::NavigationController& controller = main_contents_->GetController();
   switch (action) {
     case HISTORY_BACK:
       if (main_contents_->IsFullscreen()) {
         main_contents_->ExitFullscreen(true /* will_cause_resize */);
       } else if (controller.CanGoBack()) {
         controller.GoBack();
       }
       break;
     case HISTORY_FORWARD:
@@ skipping 32 matching lines @@
   ui_tex_css_height_ = display.size().height();
 }
 
 void VrShell::WebContentsDestroyed() {
   ui_input_manager_.reset();
   ui_contents_ = nullptr;
   // TODO(mthiesse): Handle web contents being destroyed.
   delegate_->ForceExitVr();
 }
 
-void VrShell::ContentWebContentsDestroyed() {
+void VrShell::ContentWebContentsDestroyedOnUI() {
   content_input_manager_.reset();
   main_contents_ = nullptr;
   // TODO(mthiesse): Handle web contents being destroyed.
   delegate_->ForceExitVr();
 }
 
-void VrShell::ContentWasHidden() {
+void VrShell::ContentWasHiddenOnUI() {
   // Ensure we don't continue sending input to it.
   content_input_manager_.reset();
   // TODO(mthiesse): Handle web contents being hidden.
   delegate_->ForceExitVr();
 }
 
-void VrShell::SetContentCssSize(float width, float height, float dpr) {
+void VrShell::SetContentCssSizeOnUI(float width, float height, float dpr) {
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_VrShellImpl_setContentCssSize(env, j_vr_shell_.obj(), width, height,
-                                     dpr);
+  Java_VrShellImpl_setContentCssSizeOnUI(env, j_vr_shell_.obj(), width, height,
+                                         dpr);
 }
 
-void VrShell::SetUiCssSize(float width, float height, float dpr) {
+void VrShell::SetUiCssSizeOnUI(float width, float height, float dpr) {
   JNIEnv* env = base::android::AttachCurrentThread();
-  Java_VrShellImpl_setUiCssSize(env, j_vr_shell_.obj(), width, height, dpr);
+  Java_VrShellImpl_setUiCssSizeOnUI(env, j_vr_shell_.obj(), width, height, dpr);
 }
 
 // ----------------------------------------------------------------------------
 // Native JNI methods
 // ----------------------------------------------------------------------------
 
-jlong Init(JNIEnv* env,
-           const JavaParamRef<jobject>& obj,
-           const JavaParamRef<jobject>& content_web_contents,
-           jlong content_window_android,
-           const JavaParamRef<jobject>& ui_web_contents,
-           jlong ui_window_android,
-           jboolean for_web_vr) {
+jlong InitOnUI(JNIEnv* env,
+               const JavaParamRef<jobject>& obj,
+               const JavaParamRef<jobject>& content_web_contents,
+               jlong content_window_android,
+               const JavaParamRef<jobject>& ui_web_contents,
+               jlong ui_window_android,
+               jboolean for_web_vr) {
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, content::WebContents::FromJavaWebContents(content_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(content_window_android),
       content::WebContents::FromJavaWebContents(ui_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(ui_window_android),
       for_web_vr));
 }
 
 }  // namespace vr_shell