Add new app banner metrics using InstallableStatusCode.

chrome/browser/android/banners/app_banner_manager_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 <utility>
 
 #include "chrome/browser/android/banners/app_banner_manager_android.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 133 matching lines @@
   // Check if the manifest prefers that we show a native app banner. If so, call
   // to Java to verify the details.
   if (manifest_.prefer_related_applications &&
       manifest_.related_applications.size()) {
     for (const auto& application : manifest_.related_applications) {
       std::string platform = base::UTF16ToUTF8(application.platform.string());
       std::string id = base::UTF16ToUTF8(application.id.string());
       if (CanHandleNonWebApp(platform, application.url, id))
         return;
     }
+    Stop();
   }
 
   // No native app banner was requested. Continue checking for a web app banner.
   AppBannerManager::PerformInstallableCheck();
 }
 
 void AppBannerManagerAndroid::OnAppIconFetched(const SkBitmap& bitmap) {
   if (bitmap.drawsNothing()) {
-    ReportError(web_contents(), NO_ICON_AVAILABLE);
+    ReportStatus(web_contents(), NO_ICON_AVAILABLE);
     Stop();
   }
 
   if (!is_active())
     return;
 
   icon_.reset(new SkBitmap(bitmap));
   SendBannerPromptRequest();
 }
 
 void AppBannerManagerAndroid::ShowBanner() {
   content::WebContents* contents = web_contents();
   DCHECK(contents);
 
   infobars::InfoBar* infobar = nullptr;
   if (native_app_data_.is_null()) {
     std::unique_ptr<AppBannerInfoBarDelegateAndroid> delegate(
         new AppBannerInfoBarDelegateAndroid(
             GetWeakPtr(), app_title_, manifest_url_, manifest_, icon_url_,
             std::move(icon_), event_request_id()));
 
     infobar = new AppBannerInfoBarAndroid(std::move(delegate),
                                           manifest_.start_url);
     if (infobar) {
       RecordDidShowBanner("AppBanner.WebApp.Shown");
       TrackDisplayEvent(DISPLAY_EVENT_WEB_APP_BANNER_CREATED);
+      ReportStatus(contents, SHOWING_WEB_APP_BANNER);
+    } else {
+      ReportStatus(contents, FAILED_TO_CREATE_BANNER);
     }
   } else {
     std::unique_ptr<AppBannerInfoBarDelegateAndroid> delegate(
         new AppBannerInfoBarDelegateAndroid(
             app_title_, native_app_data_, std::move(icon_), native_app_package_,
             referrer_, event_request_id()));
     infobar =
         new AppBannerInfoBarAndroid(std::move(delegate), native_app_data_);
     if (infobar) {
       RecordDidShowBanner("AppBanner.NativeApp.Shown");
       TrackDisplayEvent(DISPLAY_EVENT_NATIVE_APP_BANNER_CREATED);
+      ReportStatus(contents, SHOWING_NATIVE_APP_BANNER);
+    } else {
+      ReportStatus(contents, FAILED_TO_CREATE_BANNER);
     }
   }
 
   if (infobar) {
     InfoBarService::FromWebContents(contents)->AddInfoBar(
         base::WrapUnique(infobar));
   }
 }
 
 bool AppBannerManagerAndroid::CanHandleNonWebApp(const std::string& platform,
-                                              const GURL& url,
-                                              const std::string& id) {
+                                                 const GURL& url,
+                                                 const std::string& id) {
   if (!CheckPlatformAndId(platform, id))
     return false;
 
   banners::TrackDisplayEvent(DISPLAY_EVENT_NATIVE_APP_BANNER_REQUESTED);
 
   // Send the info to the Java side to get info about the app.
   JNIEnv* env = base::android::AttachCurrentThread();
   if (java_banner_manager_.is_null())
     return false;
 
   std::string id_from_app_url = ExtractQueryValueForName(url, kIdName);
   if (id_from_app_url.size() && id != id_from_app_url) {
-    ReportError(web_contents(), IDS_DO_NOT_MATCH);
+    ReportStatus(web_contents(), IDS_DO_NOT_MATCH);
     return false;
   }
 
   std::string referrer = ExtractQueryValueForName(url, kReferrerName);
 
   // Attach the chrome_inline referrer value, prefixed with "&" if the referrer
   // is non empty.
   if (referrer.empty())
     referrer = kPlayInlineReferrer;
   else
@@ skipping 11 matching lines @@
 
 void AppBannerManagerAndroid::CreateJavaBannerManager() {
   JNIEnv* env = base::android::AttachCurrentThread();
   java_banner_manager_.Reset(
       Java_AppBannerManager_create(env, reinterpret_cast<intptr_t>(this)));
 }
 
 bool AppBannerManagerAndroid::CheckPlatformAndId(const std::string& platform,
                                                  const std::string& id) {
   if (platform != kPlayPlatform) {
-    ReportError(web_contents(), PLATFORM_NOT_SUPPORTED_ON_ANDROID);
+    ReportStatus(web_contents(), PLATFORM_NOT_SUPPORTED_ON_ANDROID);
     return false;
   }
   if (id.empty()) {
-    ReportError(web_contents(), NO_ID_SPECIFIED);
+    ReportStatus(web_contents(), NO_ID_SPECIFIED);
     return false;
   }
   return true;
 }
 
 std::string AppBannerManagerAndroid::ExtractQueryValueForName(
     const GURL& url,
     const std::string& name) {
   url::Component query = url.parsed_for_possibly_invalid_spec().query;
   url::Component key, value;
@@ skipping 42 matching lines @@
 }
 
 // static
 void SetTimeDeltaForTesting(JNIEnv* env,
                             const JavaParamRef<jclass>& clazz,
                             jint days) {
   AppBannerManager::SetTimeDeltaForTesting(days);
 }
 
 }  // namespace banners