Refactor GvrDelegate ownership into GvrDelegateProvider and fix more threading violations.

chrome/browser/android/vr_shell/vr_shell_delegate.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_delegate.h"
 
 #include "base/android/jni_android.h"
 #include "chrome/browser/android/vr_shell/non_presenting_gvr_delegate.h"
+#include "device/vr/android/gvr/gvr_device.h"
 #include "device/vr/android/gvr/gvr_device_provider.h"
+#include "device/vr/android/gvr/gvr_gamepad_data_fetcher.h"
 #include "jni/VrShellDelegate_jni.h"
 
 using base::android::JavaParamRef;
 using base::android::AttachCurrentThread;
 
 namespace vr_shell {
 
 VrShellDelegate::VrShellDelegate(JNIEnv* env, jobject obj)
     : weak_ptr_factory_(this) {
   j_vr_shell_delegate_.Reset(env, obj);
   GvrDelegateProvider::SetInstance(this);
 }
 
 VrShellDelegate::~VrShellDelegate() {
   GvrDelegateProvider::SetInstance(nullptr);
   if (device_provider_) {
-    device_provider_->OnNonPresentingDelegateRemoved();
+    device_provider_->Device()->OnDelegateChanged();
   }
 }
 
-VrShellDelegate* VrShellDelegate::GetNativeDelegate(
+VrShellDelegate* VrShellDelegate::GetNativeVrShellDelegate(
     JNIEnv* env, jobject jdelegate) {
   long native_delegate = Java_VrShellDelegate_getNativePointer(env, jdelegate);
   return reinterpret_cast<VrShellDelegate*>(native_delegate);
 }
 
-void VrShellDelegate::SetDelegate(device::GvrDelegate* delegate) {
+void VrShellDelegate::SetDelegate(device::GvrDelegate* delegate,
+                                  gvr_context* context) {
+  context_ = context;
   delegate_ = delegate;
+  // Clean up the non-presenting delegate.
   if (non_presenting_delegate_) {
     device::mojom::VRVSyncProviderRequest request =
         non_presenting_delegate_->OnSwitchToPresentingDelegate();
     if (request.is_pending())
       delegate->OnVRVsyncProviderRequest(std::move(request));
+    non_presenting_delegate_ = nullptr;
+    JNIEnv* env = AttachCurrentThread();
+    Java_VrShellDelegate_shutdownNonPresentingNativeContext(
+        env, j_vr_shell_delegate_.obj());
   }
   if (device_provider_) {
-    device_provider_->OnGvrDelegateReady(delegate_);
+    device::GvrDevice* device = device_provider_->Device();
+    device::GamepadDataFetcherManager::GetInstance()->AddFactory(
+        new device::GvrGamepadDataFetcher::Factory(context, device->id()));
+    device->OnDelegateChanged();
   }
+
   delegate_->UpdateVSyncInterval(timebase_nanos_, interval_seconds_);
 }
 
 void VrShellDelegate::RemoveDelegate() {
+  delegate_ = nullptr;
+  device::GamepadDataFetcherManager::GetInstance()->RemoveSourceFactory(
+        device::GAMEPAD_SOURCE_GVR);
   if (device_provider_) {
-    device_provider_->OnGvrDelegateRemoved();
+    CreateNonPresentingDelegate();
+    device_provider_->Device()->OnDelegateChanged();
   }
-  delegate_ = nullptr;
 }
 
 void VrShellDelegate::SetPresentResult(JNIEnv* env,
                                        const JavaParamRef<jobject>& obj,
                                        jboolean result) {
   CHECK(!present_callback_.is_null());
   present_callback_.Run(result);
   present_callback_.Reset();
 }
 
 void VrShellDelegate::DisplayActivate(JNIEnv* env,
                                       const JavaParamRef<jobject>& obj) {
   if (device_provider_) {
-    device_provider_->OnDisplayActivate();
+    device_provider_->Device()->OnActivate(
+        device::mojom::VRDisplayEventReason::MOUNTED);
   }
 }
 
 void VrShellDelegate::UpdateVSyncInterval(JNIEnv* env,
                                           const JavaParamRef<jobject>& obj,
                                           jlong timebase_nanos,
                                           jdouble interval_seconds) {
   timebase_nanos_ = timebase_nanos;
   interval_seconds_ = interval_seconds;
   if (delegate_) {
@@ skipping 15 matching lines @@
 
 void VrShellDelegate::OnResume(JNIEnv* env,
                                const JavaParamRef<jobject>& obj) {
   if (non_presenting_delegate_) {
     non_presenting_delegate_->Resume();
   }
 }
 
 void VrShellDelegate::SetDeviceProvider(
     device::GvrDeviceProvider* device_provider) {
+  CHECK(!device_provider_);
   device_provider_ = device_provider;
-  if (device_provider_ && delegate_) {
-    device_provider_->OnGvrDelegateReady(delegate_);
-  }
+  if (!delegate_)
+    CreateNonPresentingDelegate();
+  device_provider_->Device()->OnDelegateChanged();
+}
+
+void VrShellDelegate::ClearDeviceProvider() {
+  non_presenting_delegate_ = nullptr;
+  JNIEnv* env = AttachCurrentThread();
+  Java_VrShellDelegate_shutdownNonPresentingNativeContext(
+      env, j_vr_shell_delegate_.obj());
+  device_provider_->Device()->OnDelegateChanged();
+  device_provider_ = nullptr;
 }
 
 void VrShellDelegate::RequestWebVRPresent(
     const base::Callback<void(bool)>& callback) {
   if (!present_callback_.is_null()) {
     // Can only handle one request at a time. This is also extremely unlikely to
     // happen in practice.
     callback.Run(false);
     return;
   }
@@ skipping 16 matching lines @@
   JNIEnv* env = AttachCurrentThread();
   Java_VrShellDelegate_forceExitVr(env, j_vr_shell_delegate_.obj());
 }
 
 base::WeakPtr<VrShellDelegate> VrShellDelegate::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void VrShellDelegate::OnVRVsyncProviderRequest(
     device::mojom::VRVSyncProviderRequest request) {
-  GetNonPresentingDelegate()->OnVRVsyncProviderRequest(std::move(request));
+  GetDelegate()->OnVRVsyncProviderRequest(std::move(request));
 }
 
-device::GvrDelegate* VrShellDelegate::GetNonPresentingDelegate() {
-  if (!non_presenting_delegate_) {
-    JNIEnv* env = AttachCurrentThread();
-    jlong context = Java_VrShellDelegate_createNonPresentingNativeContext(
-        env, j_vr_shell_delegate_.obj());
-    if (!context)
-      return nullptr;
+void VrShellDelegate::CreateNonPresentingDelegate() {
+  JNIEnv* env = AttachCurrentThread();
+  gvr_context* context = reinterpret_cast<gvr_context*>(
+      Java_VrShellDelegate_createNonPresentingNativeContext(
+          env, j_vr_shell_delegate_.obj()));
+  if (!context)
+    return;
+  context_ = context;
+  non_presenting_delegate_ =
+      base::MakeUnique<NonPresentingGvrDelegate>(context);
+  non_presenting_delegate_->UpdateVSyncInterval(timebase_nanos_,
+                                                interval_seconds_);
+}
 
-    non_presenting_delegate_.reset(new NonPresentingGvrDelegate(context));
-    non_presenting_delegate_->UpdateVSyncInterval(timebase_nanos_,
-                                                  interval_seconds_);
-  }
+device::GvrDelegate* VrShellDelegate::GetDelegate() {
+  if (delegate_)
+    return delegate_;
   return non_presenting_delegate_.get();
 }
 
-void VrShellDelegate::DestroyNonPresentingDelegate() {
-  if (non_presenting_delegate_) {
-    non_presenting_delegate_.reset(nullptr);
-    JNIEnv* env = AttachCurrentThread();
-    Java_VrShellDelegate_shutdownNonPresentingNativeContext(
-        env, j_vr_shell_delegate_.obj());
-  }
-}
-
 void VrShellDelegate::SetListeningForActivate(bool listening) {
   JNIEnv* env = AttachCurrentThread();
   Java_VrShellDelegate_setListeningForWebVrActivate(
       env, j_vr_shell_delegate_.obj(), listening);
 }
 
 // ----------------------------------------------------------------------------
 // Native JNI methods
 // ----------------------------------------------------------------------------
 
 bool RegisterVrShellDelegate(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   return reinterpret_cast<intptr_t>(new VrShellDelegate(env, obj));
 }
 
 }  // namespace vr_shell