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;
+
+static constexpr int kVrOutOfDate = 2;

[ddorwin, 2017/05/16 00:15:51]

Is this a constant defined in Java? If so, we should be explicit about that and
maybe have some sort of compile-time assert. Follow whatever the pattern for
that is.

[tiborg, 2017/05/23 15:47:24]

It's gone in favor of the native VrCoreCompatibility.

 
 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;
   }
+
+  auto gvr_version = GetGvrVersion(env);
+  VrMetricsUtil::LogGvrVersionForVrViewerType(context, gvr_version.first,
+                                              gvr_version.second);
 }
 
 void VrShellDelegate::RemoveDelegate() {
   presenting_delegate_ = nullptr;
   if (device_provider_) {
     CreateNonPresentingDelegate();
     device_provider_->Device()->OnExitPresent();
     device_provider_->Device()->OnDelegateChanged();
   }
 }
@@ skipping 103 matching lines @@
   // 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())) {
     if (device_provider_) {
       device_provider_->Device()->OnExitPresent();
     }
   }
 }
 
+std::pair<GvrVersionStatus, 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 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");

[mthiesse, 2017/05/16 01:15:12]

The canonical way of doing what you're doing here is to instead make VrCoreInfo
a native class. Then add a method similar to 'nativeInit' for vr_shell that lets
you create it from java. The java getter function would return the native
pointer to the object it just created and you would just cast it to the native
object, rather than doing all of this hard to maintain and understand parsing.

[tiborg, 2017/05/23 15:47:24]

That tip is golden. Made it much better!

+    version.major = env->GetIntField(j_version_object, j_field_id);
+    j_field_id = env->GetFieldID(j_vr_core_info_class, "minorVersion", "I");
+    version.minor = env->GetIntField(j_version_object, j_field_id);
+    j_field_id = env->GetFieldID(j_vr_core_info_class, "patchVersion", "I");
+    version.patch = env->GetIntField(j_version_object, j_field_id);
+    return std::make_pair(GvrVersionStatus::PRECISE, version);
+  } 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 == kVrOutOfDate) {
+      return std::make_pair(GvrVersionStatus::OLDER, version);
+    } else {
+      return std::make_pair(GvrVersionStatus::UNKNOWN, version);

[ddorwin, 2017/05/16 00:15:51]

It seems that VR_NOT_AVAILABLE would be important to track too. Really, there
are just four values. Why don't we handle all of them? Convert one enum to
another and log it. We could also report that instead of PRECISE.

[tiborg, 2017/05/23 15:47:25]

Done. All of them are handled.

+    }
+  }
+}
+
 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_);
+  auto gvr_version = GetGvrVersion(env);
+  VrMetricsUtil::LogGvrVersionForVrViewerType(context, gvr_version.first,
+                                              gvr_version.second);
 }
 
 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