Tracks GVR version crossed with headset type using UMA.

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 <utility>
 
 #include "base/android/jni_android.h"
 #include "base/callback_helpers.h"
 #include "chrome/browser/android/vr_shell/non_presenting_gvr_delegate.h"
+#include "chrome/browser/android/vr_shell/vr_usage_monitor.h"
 #include "device/vr/android/gvr/gvr_delegate.h"
 #include "device/vr/android/gvr/gvr_device.h"
 #include "device/vr/android/gvr/gvr_device_provider.h"
 #include "jni/VrShellDelegate_jni.h"
 
 using base::android::JavaParamRef;
 using base::android::AttachCurrentThread;
+using base::android::ScopedJavaLocalRef;
 
 namespace vr_shell {
 
 VrShellDelegate::VrShellDelegate(JNIEnv* env, jobject obj)
     : weak_ptr_factory_(this) {
   DVLOG(1) << __FUNCTION__ << "=" << this;
   j_vr_shell_delegate_.Reset(env, obj);
 }
 
 VrShellDelegate::~VrShellDelegate() {
   DVLOG(1) << __FUNCTION__ << "=" << this;
   if (device_provider_) {
     device_provider_->Device()->OnExitPresent();
     device_provider_->Device()->OnDelegateChanged();
   }
   if (!present_callback_.is_null()) {
     base::ResetAndReturn(&present_callback_).Run(false);
   }
 }
 
 device::GvrDelegateProvider* VrShellDelegate::CreateVrShellDelegate() {
   JNIEnv* env = AttachCurrentThread();
-  base::android::ScopedJavaLocalRef<jobject> jdelegate =
-      Java_VrShellDelegate_getInstance(env);
+  ScopedJavaLocalRef<jobject> jdelegate = Java_VrShellDelegate_getInstance(env);
   if (!jdelegate.is_null())
     return GetNativeVrShellDelegate(env, jdelegate.obj());
   return nullptr;
 }
 
 VrShellDelegate* VrShellDelegate::GetNativeVrShellDelegate(JNIEnv* env,
                                                            jobject jdelegate) {
   return reinterpret_cast<VrShellDelegate*>(
       Java_VrShellDelegate_getNativePointer(env, jdelegate));
 }
 
 void VrShellDelegate::SetPresentingDelegate(
     device::PresentingGvrDelegate* delegate,
     gvr_context* context) {
   presenting_delegate_ = delegate;
   // Clean up the non-presenting delegate.
+  JNIEnv* env = AttachCurrentThread();
   if (presenting_delegate_ && non_presenting_delegate_) {
     non_presenting_delegate_ = nullptr;
-    JNIEnv* env = AttachCurrentThread();
     Java_VrShellDelegate_shutdownNonPresentingNativeContext(
         env, j_vr_shell_delegate_.obj());
   }
   if (device_provider_) {
     device::GvrDevice* device = device_provider_->Device();
     device->OnDelegateChanged();
   }
 
   presenting_delegate_->UpdateVSyncInterval(timebase_nanos_, interval_seconds_);
 
   if (pending_successful_present_request_) {
     presenting_delegate_->SetSubmitClient(std::move(submit_client_));
     base::ResetAndReturn(&present_callback_).Run(true);
     pending_successful_present_request_ = false;
   }
+
+  VrMetricsHelper::LogGvrVersionAndVrViewerType(context, GetGvrVersion(env));
 }
 
 void VrShellDelegate::RemoveDelegate() {
   presenting_delegate_ = nullptr;
   if (device_provider_) {
     CreateNonPresentingDelegate();
     device_provider_->Device()->OnExitPresent();
     device_provider_->Device()->OnDelegateChanged();
   }
 }
@@ skipping 101 matching lines @@
 
 void VrShellDelegate::ExitWebVRPresent() {
   // VRShell is no longer needed by WebVR, allow it to shut down if it's not
   // being used elsewhere.
   JNIEnv* env = AttachCurrentThread();
   if (Java_VrShellDelegate_exitWebVRPresent(env, j_vr_shell_delegate_.obj())) {
     device_provider_->Device()->OnExitPresent();
   }
 }
 
+gvr_version VrShellDelegate::GetGvrVersion(JNIEnv* env) {
+  ScopedJavaLocalRef<jobject> j_vr_core_info =
+      Java_VrShellDelegate_getVrCoreInfo(env, j_vr_shell_delegate_.obj());
+  jclass j_vr_core_info_class = env->GetObjectClass(j_vr_core_info.obj());
+  jfieldID j_field_id = env->GetFieldID(j_vr_core_info_class, "version",
+                                        "Lcom/google/vr/ndk/base/Version;");
+  jobject j_version_object =
+      env->GetObjectField(j_vr_core_info.obj(), j_field_id);
+  gvr_version gvr_version;
+  if (j_version_object) {
+    j_vr_core_info_class = env->GetObjectClass(j_version_object);
+    j_field_id = env->GetFieldID(j_vr_core_info_class, "majorVersion", "I");

[ddorwin, 2017/05/05 20:29:59]

Aren't these members on a member of this class?

[tiborg, 2017/05/10 20:39:51]

Yep, pretty much. Are you aware of an easier way to get those?

+    gvr_version.major = env->GetIntField(j_version_object, j_field_id);
+    j_field_id = env->GetFieldID(j_vr_core_info_class, "minorVersion", "I");
+    gvr_version.minor = env->GetIntField(j_version_object, j_field_id);
+    j_field_id = env->GetFieldID(j_vr_core_info_class, "patchVersion", "I");
+    gvr_version.patch = env->GetIntField(j_version_object, j_field_id);
+  } else {
+    j_field_id = env->GetFieldID(j_vr_core_info_class, "compatibility", "I");
+    jint compatibility = env->GetIntField(j_vr_core_info.obj(), j_field_id);
+
+    if (compatibility == 2) {

[ddorwin, 2017/05/05 20:29:59]

s/2/constant?

[tiborg, 2017/05/10 20:39:52]

Done.

+      gvr_version.major = 0;
+      gvr_version.minor = 0;
+      gvr_version.patch = 0;
+    } else {
+      gvr_version.major = -1;
+      gvr_version.minor = -1;
+      gvr_version.patch = -1;
+    }
+  }
+  return gvr_version;
+}
+
 void VrShellDelegate::CreateNonPresentingDelegate() {
   JNIEnv* env = AttachCurrentThread();
   gvr_context* context = reinterpret_cast<gvr_context*>(
       Java_VrShellDelegate_createNonPresentingNativeContext(
           env, j_vr_shell_delegate_.obj()));
   non_presenting_delegate_ =
       base::MakeUnique<NonPresentingGvrDelegate>(context);
   non_presenting_delegate_->UpdateVSyncInterval(timebase_nanos_,
                                                 interval_seconds_);
+  VrMetricsHelper::LogGvrVersionAndVrViewerType(context, GetGvrVersion(env));
 }
 
 void VrShellDelegate::OnActivateDisplayHandled(bool present_requested) {
   if (!present_requested) {
     // WebVR page didn't request presentation in the vrdisplayactivate handler.
     // Tell VrShell that we are in VR Browsing Mode.
     ExitWebVRPresent();
   }
 }
 
@@ skipping 20 matching lines @@
 jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   return reinterpret_cast<intptr_t>(new VrShellDelegate(env, obj));
 }
 
 static void OnLibraryAvailable(JNIEnv* env, const JavaParamRef<jclass>& clazz) {
   device::GvrDelegateProvider::SetInstance(
       base::Bind(&VrShellDelegate::CreateVrShellDelegate));
 }
 
 }  // namespace vr_shell