Add WebAPK installation metrics.

chrome/browser/android/banners/app_banner_infobar_delegate_android.cc

 // Copyright 2015 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/banners/app_banner_infobar_delegate_android.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/guid.h"
 #include "base/location.h"
@@ skipping 25 matching lines @@
 using base::android::ConvertUTF16ToJavaString;
 using base::android::JavaParamRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace {
 
 bool IsInfoEmpty(const ShortcutInfo* info) {
   return !info || info->url.is_empty();
 }
 
+void TrackWebApkInstallationDismissEvents(webapk::InstallState install_state) {
+  if (install_state == webapk::WAIT_FOR_START)
+    webapk::TrackInstallEvent(webapk::INSTALL_EVENT_ADD_TO_HOME_SCREEN_DISMISS);
+  else if (install_state == webapk::INSTALLING)
+    webapk::TrackInstallEvent(webapk::INSTALL_EVENT_ADDING_DISMISS);

[dominickn, 2016/09/09 08:14:11]

Why is this method recording metrics in two different histograms based on the
install state? That seems like it could be a source of bugs.

[Xi Han, 2016/09/09 15:37:32]

Because the first two are recorded in the INSTALL_EVENT, which contains every
possible results of the installation process. The third one belongs to the
scenario of INSTALL_COMPELETE, but a user action whether the "open" button is
clicked or not.

+  else if (install_state == webapk::INSTALLED)
+    webapk::TrackUserAction(webapk::USER_ACTION_INSTALLED_OPEN_DISMISS);
+}
+
 }  // anonymous namespace
 
 namespace banners {
 
 // static
 bool AppBannerInfoBarDelegateAndroid::Create(
     content::WebContents* web_contents,
     base::WeakPtr<AppBannerManager> weak_manager,
     const base::string16& app_title,
     std::unique_ptr<ShortcutInfo> shortcut_info,
     std::unique_ptr<SkBitmap> icon,
     int event_request_id,
     bool is_webapk,
     bool start_install_webapk) {
   const GURL& url = shortcut_info->url;
   auto infobar_delegate =
       base::WrapUnique(new banners::AppBannerInfoBarDelegateAndroid(
           weak_manager, app_title, std::move(shortcut_info), std::move(icon),
           event_request_id, is_webapk));
   auto raw_delegate = infobar_delegate.get();
 
   auto infobar = base::MakeUnique<AppBannerInfoBarAndroid>(
       std::move(infobar_delegate), url, is_webapk);
 
   if (!InfoBarService::FromWebContents(web_contents)
            ->AddInfoBar(std::move(infobar)))
     return false;
 
-  if (is_webapk && start_install_webapk)
-    raw_delegate->AcceptWebApk(web_contents);
+  if (is_webapk) {
+    if (start_install_webapk) {
+      raw_delegate->AcceptWebApk(web_contents);
+      webapk::TrackStartType(webapk::STARTED_FROM_ADD_TO_HOME_SCREEN_MENU);
+    } else {
+      webapk::TrackStartType(webapk::TRIGGERED_FROM_BANNER);
+    }
+  }
   return true;
 }
 
 // static
 bool AppBannerInfoBarDelegateAndroid::Create(
     content::WebContents* web_contents,
     const base::string16& app_title,
     const base::android::ScopedJavaGlobalRef<jobject>& native_app_data,
     std::unique_ptr<SkBitmap> icon,
     const std::string& native_app_package,
     const std::string& referrer,
     int event_request_id) {
   auto infobar_delegate = base::WrapUnique(new AppBannerInfoBarDelegateAndroid(
       app_title, native_app_data, std::move(icon), native_app_package, referrer,
       event_request_id));
   auto infobar = base::MakeUnique<AppBannerInfoBarAndroid>(
       std::move(infobar_delegate), native_app_data);
 
   return InfoBarService::FromWebContents(web_contents)
       ->AddInfoBar(std::move(infobar));
 }
 
 AppBannerInfoBarDelegateAndroid::~AppBannerInfoBarDelegateAndroid() {
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   if (!has_user_interaction_) {
-    if (!native_app_data_.is_null())
+    if (!native_app_data_.is_null()) {
       TrackUserResponse(USER_RESPONSE_NATIVE_APP_IGNORED);
-    else if (!IsInfoEmpty(shortcut_info_.get()))
+    } else if (!IsInfoEmpty(shortcut_info_.get())) {
       TrackUserResponse(USER_RESPONSE_WEB_APP_IGNORED);
+      if (is_webapk_)
+        webapk::TrackInstallEvent(webapk::INSTALL_EVENT_BANNER_IGNORED);
+    }
   }
 
   TrackDismissEvent(DISMISS_EVENT_DISMISSED);
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_AppBannerInfoBarDelegateAndroid_destroy(env, java_delegate_);
   java_delegate_.Reset();
 }
 
 void AppBannerInfoBarDelegateAndroid::UpdateInstallState(
     JNIEnv* env,
@@ skipping 57 matching lines @@
   if (IsInfoEmpty(shortcut_info_.get()))
     return true;
 
   JNIEnv* env = base::android::AttachCurrentThread();
   // |webapk_package_name_| is set when the WebAPK has finished installing.
   // If the |webapk_package_name_| is empty, it means the "Add to Homescreen"
   // button is pressed, so request WebAPK installation. Otherwise, it means
   // the "Open" button is pressed, then open the installed WebAPK.
   if (webapk_package_name_.empty()) {
     // Request install the WebAPK.
+    install_state_ = webapk::INSTALLING;
     TrackUserResponse(USER_RESPONSE_WEB_APP_ACCEPTED);
 
     AppBannerSettingsHelper::RecordBannerInstallEvent(
         web_contents, shortcut_info_->url.spec(), AppBannerSettingsHelper::WEB);
 
     Java_AppBannerInfoBarDelegateAndroid_setWebApkInstallingState(
         env, java_delegate_, true);
     UpdateInstallState(env, nullptr);
 
     WebApkInstaller::FinishCallback callback =
         base::Bind(&AppBannerInfoBarDelegateAndroid::OnWebApkInstallFinished,
                    weak_ptr_factory_.GetWeakPtr());
     DVLOG(1) << "Trigger the installation of the WebAPK.";
     ShortcutHelper::InstallWebApkWithSkBitmap(web_contents->GetBrowserContext(),
                                               *shortcut_info_.get(),
                                               *icon_.get(), callback);
 
     SendBannerAccepted(web_contents, "web");
     // Returns false to prevent the infobar from disappearing.
     return false;
   }
 
   // Open the WebAPK.
   ScopedJavaLocalRef<jstring> java_webapk_package_name =
       base::android::ConvertUTF8ToJavaString(env, webapk_package_name_);
   Java_AppBannerInfoBarDelegateAndroid_openWebApk(env, java_delegate_,
                                                   java_webapk_package_name);
 
   SendBannerAccepted(web_contents, "web");
+  webapk::TrackUserAction(webapk::USER_ACTION_INSTALLED_OPEN);
   return true;
 }
 
 AppBannerInfoBarDelegateAndroid::AppBannerInfoBarDelegateAndroid(
     base::WeakPtr<AppBannerManager> weak_manager,
     const base::string16& app_title,
     std::unique_ptr<ShortcutInfo> shortcut_info,
     std::unique_ptr<SkBitmap> icon,
     int event_request_id,
     bool is_webapk)
@@ skipping 65 matching lines @@
   web_contents->GetMainFrame()->Send(
       new ChromeViewMsg_AppBannerDismissed(
           web_contents->GetMainFrame()->GetRoutingID(),
           event_request_id_));
 
   if (!native_app_data_.is_null()) {
     TrackUserResponse(USER_RESPONSE_NATIVE_APP_DISMISSED);
     AppBannerSettingsHelper::RecordBannerDismissEvent(
         web_contents, native_app_package_, AppBannerSettingsHelper::NATIVE);
   } else if (!IsInfoEmpty(shortcut_info_.get())) {
+    if (is_webapk_)
+      TrackWebApkInstallationDismissEvents(install_state_);
     TrackUserResponse(USER_RESPONSE_WEB_APP_DISMISSED);
     AppBannerSettingsHelper::RecordBannerDismissEvent(
         web_contents, shortcut_info_->url.spec(), AppBannerSettingsHelper::WEB);
   }
 }
 
 base::string16 AppBannerInfoBarDelegateAndroid::GetMessageText() const {
   return app_title_;
 }
 
 int AppBannerInfoBarDelegateAndroid::GetButtons() const {
   return BUTTON_OK;
 }
 
 bool AppBannerInfoBarDelegateAndroid::Accept() {
   has_user_interaction_ = true;
 
   content::WebContents* web_contents =
       InfoBarService::WebContentsFromInfoBar(infobar());
   if (!web_contents) {
     TrackDismissEvent(DISMISS_EVENT_ERROR);
     return true;
   }
 
-  if (!native_app_data_.is_null())
+  if (!native_app_data_.is_null()) {
     return AcceptNativeApp(web_contents);
-  else if (is_webapk_)
+  } else if (is_webapk_) {
+    webapk::TrackStartType(webapk::STARTED_FROM_BANNER);
     return AcceptWebApk(web_contents);
-  else
+  } else {
     return AcceptWebApp(web_contents);
+  }
 }
 
 bool AppBannerInfoBarDelegateAndroid::AcceptNativeApp(
     content::WebContents* web_contents) {
   TrackUserResponse(USER_RESPONSE_NATIVE_APP_ACCEPTED);
   JNIEnv* env = base::android::AttachCurrentThread();
 
   TabAndroid* tab = TabAndroid::FromWebContents(web_contents);
   if (tab == nullptr) {
     TrackDismissEvent(DISMISS_EVENT_ERROR);
@@ skipping 39 matching lines @@
 void AppBannerInfoBarDelegateAndroid::OnWebApkInstallFinished(
     bool success,
     const std::string& webapk_package_name) {
   JNIEnv* env = base::android::AttachCurrentThread();
   if (!success) {
     // The installation failed.
     if (infobar())
       infobar()->RemoveSelf();
     Java_AppBannerInfoBarDelegateAndroid_showWebApkInstallFailureToast(env);
     DVLOG(1) << "The WebAPK installation failed.";
+    webapk::TrackInstallEvent(webapk::INSTALL_EVENT_FAILED);
     return;
   }
 
   webapk_package_name_ = webapk_package_name;
   ScopedJavaLocalRef<jstring> java_webapk_package_name =
       base::android::ConvertUTF8ToJavaString(env, webapk_package_name);
   Java_AppBannerInfoBarDelegateAndroid_setWebApkInstallingState(
       env, java_delegate_, false);
   Java_AppBannerInfoBarDelegateAndroid_setWebApkPackageName(
       env, java_delegate_, java_webapk_package_name);
   UpdateInstallState(env, nullptr);
+  install_state_ = webapk::INSTALLED;
+  webapk::TrackInstallEvent(webapk::INSTALL_EVENT_COMPLETED);
 }
 
 bool AppBannerInfoBarDelegateAndroid::LinkClicked(
     WindowOpenDisposition disposition) {
   if (native_app_data_.is_null())
     return false;
 
   // Try to show the details for the native app.
   JNIEnv* env = base::android::AttachCurrentThread();
 
@@ skipping 11 matching lines @@
 
   TrackDismissEvent(DISMISS_EVENT_BANNER_CLICK);
   return true;
 }
 
 bool RegisterAppBannerInfoBarDelegateAndroid(JNIEnv* env) {
  return RegisterNativesImpl(env);
 }
 
 }  // namespace banners