WebView: Add channel info for UMA

android_webview/browser/aw_metrics_service_client.cc

 // Copyright 2017 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 "android_webview/browser/aw_metrics_service_client.h"
 
 #include "android_webview/browser/aw_metrics_log_uploader.h"
 #include "android_webview/common/aw_version_info_values.h"
 #include "android_webview/jni/AwMetricsServiceClient_jni.h"
 #include "base/android/build_info.h"
+#include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/guid.h"
 #include "base/i18n/rtl.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/metrics/call_stack_profile_metrics_provider.h"
 #include "components/metrics/enabled_state_provider.h"
 #include "components/metrics/gpu/gpu_metrics_provider.h"
 #include "components/metrics/metrics_log_uploader.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_service.h"
 #include "components/metrics/metrics_state_manager.h"
 #include "components/metrics/profiler/profiler_metrics_provider.h"
 #include "components/metrics/ui/screen_info_metrics_provider.h"
 #include "components/metrics/url_constants.h"
+#include "components/metrics/version_utils.h"
 #include "components/prefs/pref_service.h"
+#include "components/version_info/channel_android.h"
+#include "components/version_info/version_info.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace android_webview {
 
 base::LazyInstance<AwMetricsServiceClient>::Leaky g_lazy_instance_;
 
 namespace {
 
 const int kUploadIntervalMinutes = 30;
 
@@ skipping 24 matching lines @@
   // We must write a new GUID.
   *guid = base::GenerateGUID();
   if (!base::WriteFile(guid_file_path, guid->c_str(), guid->size())) {
     // If writing fails, proceed anyway with the new GUID. It won't be persisted
     // to the next run, but we can still collect metrics with this 1-time GUID.
     LOG(ERROR) << "Failed to write new GUID";
   }
   return;
 }
 
+version_info::Channel GetChannelFromPackageName() {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  std::string package_name = base::android::ConvertJavaStringToUTF8(
+      env, Java_AwMetricsServiceClient_getWebViewPackageName(env));
+  // We can't determine the channel for stand-alone WebView, since it has the
+  // same package name across channels. It will always be "unknown".
+  return version_info::ChannelFromPackageName(package_name.c_str());
+}
+
 }  // namespace
 
 // static
 AwMetricsServiceClient* AwMetricsServiceClient::GetInstance() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return g_lazy_instance_.Pointer();
 }
 
 void AwMetricsServiceClient::Initialize(
     PrefService* pref_service,
     net::URLRequestContextGetter* request_context,
     const base::FilePath guid_file_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   DCHECK(pref_service_ == nullptr);  // Initialize should only happen once.
   DCHECK(request_context_ == nullptr);
   pref_service_ = pref_service;
   request_context_ = request_context;
+  channel_ = GetChannelFromPackageName();
 
   std::string* guid = new std::string;
   // Initialization happens on the UI thread, but getting the GUID should happen
   // on the file I/O thread. So we start to initialize, then post to get the
   // GUID, and then pick up where we left off, back on the UI thread, in
   // InitializeWithGUID.
   content::BrowserThread::PostTaskAndReply(
       content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&GetOrCreateGUID, guid_file_path, guid),
       base::Bind(&AwMetricsServiceClient::InitializeWithGUID,
@@ skipping 80 matching lines @@
 std::string AwMetricsServiceClient::GetApplicationLocale() {
   return base::i18n::GetConfiguredLocale();
 }
 
 bool AwMetricsServiceClient::GetBrand(std::string* brand_code) {
   // WebView doesn't use brand codes.
   return false;
 }
 
 metrics::SystemProfileProto::Channel AwMetricsServiceClient::GetChannel() {
-  // "Channel" means stable, beta, etc. WebView doesn't have channel info yet.
-  // TODO(paulmiller) Update this once we have channel info.
-  return metrics::SystemProfileProto::CHANNEL_UNKNOWN;
+  return metrics::AsProtobufChannel(channel_);
 }
 
 std::string AwMetricsServiceClient::GetVersionString() {
   return PRODUCT_VERSION;
 }
 
 void AwMetricsServiceClient::InitializeSystemProfileMetrics(
     const base::Closure& done_callback) {
   done_callback.Run();
 }
@@ skipping 15 matching lines @@
       new AwMetricsLogUploader(on_upload_complete));
 }
 
 base::TimeDelta AwMetricsServiceClient::GetStandardUploadInterval() {
   // The platform logging mechanism is responsible for upload frequency; this
   // just specifies how frequently to provide logs to the platform.
   return base::TimeDelta::FromMinutes(kUploadIntervalMinutes);
 }
 
 AwMetricsServiceClient::AwMetricsServiceClient()
-    : is_enabled_(false), pref_service_(nullptr), request_context_(nullptr) {}
+    : is_enabled_(false),
+      pref_service_(nullptr),
+      request_context_(nullptr),
+      channel_(version_info::Channel::UNKNOWN) {}
 
 AwMetricsServiceClient::~AwMetricsServiceClient() {}
 
 // static
 void SetMetricsEnabled(JNIEnv* env,
                        const base::android::JavaParamRef<jclass>& jcaller,
                        jboolean enabled) {
   g_lazy_instance_.Pointer()->SetMetricsEnabled(enabled);
 }
 
 bool RegisterAwMetricsServiceClient(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace android_webview