Fix some thread safety violations in device::GvrDelegate implementation.

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 "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/android/vr_shell/ui_elements.h"
@@ skipping 196 matching lines @@
   InitializeRenderer();
 
   ScheduleNextDrawFrame();
   return true;
 }
 
 bool VrShellGl::InitializeGl() {
   if (gl::GetGLImplementation() == gl::kGLImplementationNone &&
       !gl::init::InitializeGLOneOff()) {
     LOG(ERROR) << "gl::init::InitializeGLOneOff failed";
-    ForceExitVR();
+    ForceExitVr();
     return false;
   }
   surface_ = gl::init::CreateOffscreenGLSurface(gfx::Size());
   if (!surface_.get()) {
     LOG(ERROR) << "gl::init::CreateOffscreenGLSurface failed";
-    ForceExitVR();
+    ForceExitVr();
     return false;
   }
   context_ = gl::init::CreateGLContext(nullptr, surface_.get(),
                                        gl::GLContextAttribs());
   if (!context_.get()) {
     LOG(ERROR) << "gl::init::CreateGLContext failed";
-    ForceExitVR();
+    ForceExitVr();
     return false;
   }
   if (!context_->MakeCurrent(surface_.get())) {
     LOG(ERROR) << "gl::GLContext::MakeCurrent() failed";
-    ForceExitVR();
+    ForceExitVr();
     return false;
   }
 
   // TODO(mthiesse): We don't appear to have a VSync provider ever here. This is
   // sort of okay, because the GVR swap chain will block if we render too fast,
   // but we should address this properly.
   if (surface_->GetVSyncProvider()) {
     surface_->GetVSyncProvider()->GetVSyncParameters(base::Bind(
         &VrShellGl::UpdateVSyncParameters, weak_ptr_factory_.GetWeakPtr()));
   } else {
@@ skipping 64 matching lines @@
   // Out of paranoia, explicitly reset the "pose valid" flags to false
   // from the GL thread. The constructor ran in the UI thread.
   // TODO(klausw,crbug.com/655722): remove this.
   webvr_head_pose_valid_.assign(kPoseRingBufferSize, false);
 
   gvr_api_->InitializeGl();
   std::vector<gvr::BufferSpec> specs;
   // For kFramePrimaryBuffer (primary VrShell and WebVR content)
   specs.push_back(gvr_api_->CreateBufferSpec());
   render_size_primary_ = specs[kFramePrimaryBuffer].GetSize();
-  render_size_primary_vrshell_ = render_size_primary_;
 
   // 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);
   render_size_headlocked_ = specs[kFrameHeadlockedBuffer].GetSize();
 
   swap_chain_.reset(new gvr::SwapChain(gvr_api_->CreateSwapChain(specs)));
 
   vr_shell_renderer_.reset(new VrShellRenderer());
@@ skipping 272 matching lines @@
   return true;
 }
 
 void VrShellGl::DrawFrame() {
   TRACE_EVENT0("gpu", "VrShellGl::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();
 
-  // TODO(klausw): Fix this. Resizing buffers here leads to webVR mode showing
-  // nothing but a black screen.
-//  if (vr_shell_->GetUiInterface()->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) {
-//        VLOG(2) << "WebVR rendering size not known yet, dropping frame";
-//        return;
-//      }
-//      render_size_primary_ = render_size_primary_webvr_;
-//      swap_chain_->ResizeBuffer(kFramePrimaryBuffer, render_size_primary_);
-//    }
-//  } else {
-//    if (render_size_primary_ != render_size_primary_vrshell_) {
-//      render_size_primary_ = render_size_primary_vrshell_;
-//      swap_chain_->ResizeBuffer(kFramePrimaryBuffer, render_size_primary_);
-//    }
-//  }
-
   gvr::Frame frame = swap_chain_->AcquireFrame();
   gvr::ClockTimePoint target_time = gvr::GvrApi::GetTimePointNow();
   target_time.monotonic_system_time_nanos += kPredictionTimeWithoutVsyncNanos;
 
   gvr::Mat4f head_pose =
       gvr_api_->GetHeadSpaceFromStartSpaceRotation(target_time);
 
   gvr::Vec3f position = GetTranslation(head_pose);
   if (position.x == 0.0f && position.y == 0.0f && position.z == 0.0f) {
     // This appears to be a 3DOF pose without a neck model. Add one.
@@ skipping 106 matching lines @@
     // TODO(mthiesse): We don't unbind this? Maybe some cleanup is in order
     // here.
     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_,
                kViewportListHeadlockedOffset);
   }
 }
 
-void VrShellGl::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 VrShellGl::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 VrShellGl::DrawUiView(const gvr::Mat4f* head_pose,
                            const std::vector<const ContentRectangle*>& elements,
                            const gvr::Sizei& render_size,
@@ skipping 223 matching lines @@
     target = now;
   } else {
     target = now + vsync_interval_;
     int64_t intervals = (target - vsync_timebase_) / vsync_interval_;
     target = vsync_timebase_ + intervals * vsync_interval_;
   }
 
   task_runner_->PostDelayedTask(FROM_HERE, draw_task_.callback(), target - now);
 }
 
-void VrShellGl::ForceExitVR() {
+void VrShellGl::ForceExitVr() {
   main_thread_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&VrShell::ForceExitVR, weak_vr_shell_));
+      FROM_HERE, base::Bind(&VrShell::ForceExitVr, weak_vr_shell_));
 }
 
 }  // namespace vr_shell