Decouple app banner installation logic from UI on Android.

This CL extracts the UI-independent logic from
AppBannerInfoBarDelegateAndroid, and moves it to a new class,
AppBannerUiDelegateAndroid. This will allow a new modal UI surface to be
introduced for banners that uses the same app installation logic.

BUG=811578

Change-Id: I0998b0086783d4c78f25c966917c40adb9638f7f
Reviewed-on: https://chromium-review.googlesource.com/915442
Commit-Queue: Dominick Ng <dominickn@chromium.org>
Reviewed-by: Dominick Ng <dominickn@chromium.org>
Reviewed-by: Ben Wells <benwells@chromium.org>
Reviewed-by: Ted Choc <tedchoc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#537915}

chrome/android/java/src/org/chromium/chrome/browser/banners/AppBannerUiDelegateAndroid.java

+// Copyright 2018 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.
+
+package org.chromium.chrome.browser.banners;
+
+import android.os.Looper;
+
+import org.chromium.base.annotations.CalledByNative;
+import org.chromium.base.annotations.JNIAdditionalImport;
+import org.chromium.base.annotations.JNINamespace;
+import org.chromium.chrome.browser.tab.Tab;
+
+/**
+ * Handles the promotion and installation of an app specified by the current web page. This object
+ * is created by and owned by the native AppBannerUiDelegate.
+ */
+@JNINamespace("banners")
+@JNIAdditionalImport(InstallerDelegate.class)
+public class AppBannerUiDelegateAndroid {
+    /** Pointer to the native AppBannerUiDelegateAndroid. */
+    private long mNativePointer;
+
+    /** Delegate which does the actual monitoring of an in-progress installation. */
+    private InstallerDelegate mInstallerDelegate;
+
+    private AppBannerUiDelegateAndroid(long nativePtr) {
+        mNativePointer = nativePtr;
+    }
+
+    /**
+     * Creates the installer delegate with the specified observer. Must be called prior to using
+     * this object */
+    @CalledByNative
+    public void createInstallerDelegate(InstallerDelegate.Observer observer) {
+        mInstallerDelegate = new InstallerDelegate(Looper.getMainLooper(), observer);
+    }
+
+    @CalledByNative
+    private void destroy() {
+        mInstallerDelegate.destroy();
+        mInstallerDelegate = null;
+        mNativePointer = 0;
+    }
+
+    @CalledByNative
+    private boolean installOrOpenNativeApp(Tab tab, AppData appData, String referrer) {
+        return mInstallerDelegate.installOrOpenNativeApp(tab, appData, referrer);
+    }
+
+    @CalledByNative
+    private void showAppDetails(Tab tab, AppData appData) {
+        tab.getWindowAndroid().showIntent(appData.detailsIntent(), null, null);
+    }
+
+    @CalledByNative
+    private int determineInstallState(String packageName) {
+        return mInstallerDelegate.determineInstallState(packageName);
+    }
+
+    @CalledByNative
+    private static AppBannerUiDelegateAndroid create(long nativePtr) {
+        return new AppBannerUiDelegateAndroid(nativePtr);
+    }
+}

chrome/android/java/src/org/chromium/chrome/browser/infobar/AppBannerInfoBarDelegateAndroid.java

@@ -4,13 +4,9 @@
 
 package org.chromium.chrome.browser.infobar;
 
-import android.os.Looper;
-
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
-import org.chromium.chrome.browser.banners.AppData;
 import org.chromium.chrome.browser.banners.InstallerDelegate;
-import org.chromium.chrome.browser.tab.Tab;
 
 /**
  * Handles the promotion and installation of an app specified by the current web page. This object
@@ -18,57 +14,33 @@ import org.chromium.chrome.browser.tab.Tab;
  */
 @JNINamespace("banners")
 public class AppBannerInfoBarDelegateAndroid implements InstallerDelegate.Observer {
-    /** Weak pointer to the native AppBannerInfoBarDelegateAndroid. */
+    /** Pointer to the native AppBannerInfoBarDelegateAndroid. */
     private long mNativePointer;
 
-    /** Delegate which does the actual monitoring of an in-progress installation. */
-    private InstallerDelegate mInstallerDelegate;
-
     private AppBannerInfoBarDelegateAndroid(long nativePtr) {
         mNativePointer = nativePtr;
-        mInstallerDelegate = new InstallerDelegate(Looper.getMainLooper(), this);
     }
 
     @Override
     public void onInstallIntentCompleted(InstallerDelegate delegate, boolean isInstalling) {
-        if (mInstallerDelegate != delegate) return;
         nativeOnInstallIntentReturned(mNativePointer, isInstalling);
     }
 
     @Override
     public void onInstallFinished(InstallerDelegate delegate, boolean success) {
-        if (mInstallerDelegate != delegate) return;
         nativeOnInstallFinished(mNativePointer, success);
     }
 
     @Override
     public void onApplicationStateChanged(InstallerDelegate delegate, int newState) {
-        if (mInstallerDelegate != delegate) return;
         nativeUpdateInstallState(mNativePointer);
     }
 
     @CalledByNative
     private void destroy() {
-        mInstallerDelegate.destroy();
-        mInstallerDelegate = null;
         mNativePointer = 0;
     }
 
-    @CalledByNative
-    private boolean installOrOpenNativeApp(Tab tab, AppData appData, String referrer) {
-        return mInstallerDelegate.installOrOpenNativeApp(tab, appData, referrer);
-    }
-
-    @CalledByNative
-    private void showAppDetails(Tab tab, AppData appData) {
-        tab.getWindowAndroid().showIntent(appData.detailsIntent(), null, null);
-    }
-
-    @CalledByNative
-    private int determineInstallState(String packageName) {
-        return mInstallerDelegate.determineInstallState(packageName);
-    }
-
     @CalledByNative
     private static AppBannerInfoBarDelegateAndroid create(long nativePtr) {
         return new AppBannerInfoBarDelegateAndroid(nativePtr);

chrome/android/java_sources.gni

@@ -97,6 +97,7 @@ chrome_java_sources = [
   "java/src/org/chromium/chrome/browser/autofill/PhoneNumberUtil.java",
   "java/src/org/chromium/chrome/browser/background_task_scheduler/NativeBackgroundTask.java",
   "java/src/org/chromium/chrome/browser/banners/AppBannerManager.java",
+  "java/src/org/chromium/chrome/browser/banners/AppBannerUiDelegateAndroid.java",
   "java/src/org/chromium/chrome/browser/banners/AppData.java",
   "java/src/org/chromium/chrome/browser/banners/AppDetailsDelegate.java",
   "java/src/org/chromium/chrome/browser/banners/InstallerDelegate.java",

chrome/browser/BUILD.gn

@@ -2216,6 +2216,8 @@ jumbo_split_static_library("browser") {
       "banners/app_banner_infobar_delegate_android.h",
       "banners/app_banner_manager_android.cc",
       "banners/app_banner_manager_android.h",
+      "banners/app_banner_ui_delegate_android.cc",
+      "banners/app_banner_ui_delegate_android.h",
       "chrome_browser_field_trials_mobile.cc",
       "chrome_browser_field_trials_mobile.h",
       "dom_distiller/dom_distiller_service_factory_android.cc",
@@ -4228,6 +4230,7 @@ if (is_android) {
       "../android/java/src/org/chromium/chrome/browser/autofill/PersonalDataManager.java",
       "../android/java/src/org/chromium/chrome/browser/autofill/PhoneNumberUtil.java",
       "../android/java/src/org/chromium/chrome/browser/banners/AppBannerManager.java",
+      "../android/java/src/org/chromium/chrome/browser/banners/AppBannerUiDelegateAndroid.java",
       "../android/java/src/org/chromium/chrome/browser/bookmarks/BookmarkBridge.java",
       "../android/java/src/org/chromium/chrome/browser/browserservices/OriginVerifier.java",
       "../android/java/src/org/chromium/chrome/browser/browsing_data/UrlFilterBridge.java",

chrome/browser/banners/app_banner_infobar_delegate_android.cc

@@ -7,288 +7,94 @@
 #include <utility>
 
 #include "base/android/jni_android.h"
-#include "base/android/jni_string.h"
-#include "base/memory/ptr_util.h"
-#include "chrome/browser/android/shortcut_helper.h"
-#include "chrome/browser/android/shortcut_info.h"
-#include "chrome/browser/android/tab_android.h"
-#include "chrome/browser/android/webapk/webapk_install_service.h"
-#include "chrome/browser/android/webapk/webapk_metrics.h"
-#include "chrome/browser/banners/app_banner_manager.h"
-#include "chrome/browser/banners/app_banner_metrics.h"
-#include "chrome/browser/banners/app_banner_settings_helper.h"
-#include "chrome/browser/browser_process.h"
+#include "chrome/browser/banners/app_banner_ui_delegate_android.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/ui/android/infobars/app_banner_infobar_android.h"
-#include "components/rappor/public/rappor_utils.h"
-#include "components/rappor/rappor_service_impl.h"
 #include "content/public/browser/web_contents.h"
-#include "content/public/common/manifest.h"
 #include "jni/AppBannerInfoBarDelegateAndroid_jni.h"
-#include "ui/gfx/android/java_bitmap.h"
-#include "url/gurl.h"
-
-using base::android::ConvertJavaStringToUTF8;
-using base::android::ConvertJavaStringToUTF16;
-using base::android::ConvertUTF8ToJavaString;
-using base::android::ConvertUTF16ToJavaString;
-using base::android::JavaParamRef;
-using base::android::ScopedJavaLocalRef;
 
 namespace banners {
 
 // static
 bool AppBannerInfoBarDelegateAndroid::Create(
     content::WebContents* web_contents,
-    base::WeakPtr<AppBannerManager> weak_manager,
-    std::unique_ptr<ShortcutInfo> shortcut_info,
-    const SkBitmap& primary_icon,
-    const SkBitmap& badge_icon,
-    WebappInstallSource install_source,
-    bool is_webapk) {
-  DCHECK(shortcut_info);
-  const GURL url = shortcut_info->url;
-  if (url.is_empty())
-    return false;
-
-  auto infobar_delegate =
-      base::WrapUnique(new banners::AppBannerInfoBarDelegateAndroid(
-          weak_manager, std::move(shortcut_info), primary_icon, badge_icon,
-          install_source, is_webapk));
-  auto infobar = base::MakeUnique<AppBannerInfoBarAndroid>(
-      std::move(infobar_delegate), url);
-  if (!InfoBarService::FromWebContents(web_contents)
-           ->AddInfoBar(std::move(infobar)))
-    return false;
-
-  return true;
-}
-
-// static
-bool AppBannerInfoBarDelegateAndroid::Create(
-    content::WebContents* web_contents,
-    base::WeakPtr<AppBannerManager> weak_manager,
-    const base::string16& app_title,
-    const base::android::ScopedJavaGlobalRef<jobject>& native_app_data,
-    const SkBitmap& icon,
-    const std::string& native_app_package_name,
-    const std::string& referrer) {
-  auto infobar_delegate = base::WrapUnique(new AppBannerInfoBarDelegateAndroid(
-      weak_manager, app_title, native_app_data, icon, native_app_package_name,
-      referrer));
+    std::unique_ptr<AppBannerUiDelegateAndroid> ui_delegate) {
   return InfoBarService::FromWebContents(web_contents)
-      ->AddInfoBar(base::MakeUnique<AppBannerInfoBarAndroid>(
-          std::move(infobar_delegate), native_app_data));
+      ->AddInfoBar(std::make_unique<AppBannerInfoBarAndroid>(
+          std::unique_ptr<AppBannerInfoBarDelegateAndroid>(
+              new AppBannerInfoBarDelegateAndroid(std::move(ui_delegate)))));
 }
 
 AppBannerInfoBarDelegateAndroid::~AppBannerInfoBarDelegateAndroid() {
-  if (!has_user_interaction_) {
-    if (!native_app_data_.is_null()) {
-      TrackUserResponse(USER_RESPONSE_NATIVE_APP_IGNORED);
-    } else {
-      TrackUserResponse(USER_RESPONSE_WEB_APP_IGNORED);
-      if (is_webapk_)
-        webapk::TrackInstallEvent(webapk::INFOBAR_IGNORED);
-    }
-  }
-
-  TrackDismissEvent(DISMISS_EVENT_DISMISSED);
   Java_AppBannerInfoBarDelegateAndroid_destroy(
       base::android::AttachCurrentThread(), java_delegate_);
   java_delegate_.Reset();
 }
 
+const AppBannerUiDelegateAndroid*
+AppBannerInfoBarDelegateAndroid::GetUiDelegate() const {
+  return ui_delegate_.get();
+}
+
 void AppBannerInfoBarDelegateAndroid::UpdateInstallState(
     JNIEnv* env,
-    const JavaParamRef<jobject>& obj) {
-  if (native_app_data_.is_null() && !is_webapk_)
+    const base::android::JavaParamRef<jobject>& obj) {
+  if (ui_delegate_->GetType() != AppBannerUiDelegateAndroid::AppType::NATIVE)
     return;
 
-  ScopedJavaLocalRef<jstring> jpackage_name(
-      ConvertUTF8ToJavaString(env, package_name_));
-  int newState = Java_AppBannerInfoBarDelegateAndroid_determineInstallState(
-      env, java_delegate_, jpackage_name);
   static_cast<AppBannerInfoBarAndroid*>(infobar())->OnInstallStateChanged(
-      newState);
+      ui_delegate_->GetInstallState());
 }
 
 void AppBannerInfoBarDelegateAndroid::OnInstallIntentReturned(
     JNIEnv* env,
-    const JavaParamRef<jobject>& obj,
+    const base::android::JavaParamRef<jobject>& obj,
     jboolean jis_installing) {
   DCHECK(infobar());
-  DCHECK(!package_name_.empty());
 
   content::WebContents* web_contents =
       InfoBarService::WebContentsFromInfoBar(infobar());
-  if (jis_installing) {
-    AppBannerSettingsHelper::RecordBannerEvent(
-        web_contents, web_contents->GetURL(), package_name_,
-        AppBannerSettingsHelper::APP_BANNER_EVENT_DID_ADD_TO_HOMESCREEN,
-        AppBannerManager::GetCurrentTime());
-
-    TrackInstallEvent(INSTALL_EVENT_NATIVE_APP_INSTALL_STARTED);
-    rappor::SampleDomainAndRegistryFromGURL(g_browser_process->rappor_service(),
-                                            "AppBanner.NativeApp.Installed",
-                                            web_contents->GetURL());
-  }
+  if (jis_installing)
+    ui_delegate_->OnNativeAppInstallStarted(web_contents);
 
   UpdateInstallState(env, obj);
 }
 
 void AppBannerInfoBarDelegateAndroid::OnInstallFinished(
     JNIEnv* env,
-    const JavaParamRef<jobject>& obj,
+    const base::android::JavaParamRef<jobject>& obj,
     jboolean success) {
   DCHECK(infobar());
 
-  if (success) {
-    TrackInstallEvent(INSTALL_EVENT_NATIVE_APP_INSTALL_COMPLETED);
+  ui_delegate_->OnNativeAppInstallFinished(success);
+  if (success)
     UpdateInstallState(env, obj);
-  } else if (infobar()->owner()) {
-    TrackDismissEvent(DISMISS_EVENT_INSTALL_TIMEOUT);
-    infobar()->owner()->RemoveInfoBar(infobar());
-  }
-}
-
-const SkBitmap& AppBannerInfoBarDelegateAndroid::GetPrimaryIcon() const {
-  return primary_icon_;
+  else
+    infobar()->RemoveSelf();
 }
 
 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())
-    return AcceptNativeApp(web_contents);
-
-  if (is_webapk_)
-    return AcceptWebApk(web_contents);
-
-  return AcceptWebApp(web_contents);
+  return ui_delegate_->InstallApp(
+      InfoBarService::WebContentsFromInfoBar(infobar()));
 }
 
 base::string16 AppBannerInfoBarDelegateAndroid::GetMessageText() const {
-  return app_title_;
+  // The message text for the infobar is fetched directly from |ui_delegate_| by
+  // the infobar.
+  return base::string16();
 }
 
 AppBannerInfoBarDelegateAndroid::AppBannerInfoBarDelegateAndroid(
-    base::WeakPtr<AppBannerManager> weak_manager,
-    std::unique_ptr<ShortcutInfo> shortcut_info,
-    const SkBitmap& primary_icon,
-    const SkBitmap& badge_icon,
-    WebappInstallSource install_source,
-    bool is_webapk)
-    : weak_manager_(weak_manager),
-      app_title_(shortcut_info->name),
-      shortcut_info_(std::move(shortcut_info)),
-      primary_icon_(primary_icon),
-      badge_icon_(badge_icon),
-      has_user_interaction_(false),
-      is_webapk_(is_webapk),
-      install_source_(install_source) {
-  if (is_webapk_)
-    shortcut_info_->UpdateSource(ShortcutInfo::SOURCE_APP_BANNER_WEBAPK);
-  else
-    shortcut_info_->UpdateSource(ShortcutInfo::SOURCE_APP_BANNER);
-
-  CreateJavaDelegate();
+    std::unique_ptr<AppBannerUiDelegateAndroid> ui_delegate)
+    : ui_delegate_(std::move(ui_delegate)) {
+  CreateJavaDelegate(base::android::AttachCurrentThread());
+  ui_delegate_->CreateInstallerDelegate(
+      base::android::ScopedJavaLocalRef<jobject>(java_delegate_));
 }
 
-AppBannerInfoBarDelegateAndroid::AppBannerInfoBarDelegateAndroid(
-    base::WeakPtr<AppBannerManager> weak_manager,
-    const base::string16& app_title,
-    const base::android::ScopedJavaGlobalRef<jobject>& native_app_data,
-    const SkBitmap& icon,
-    const std::string& native_app_package_name,
-    const std::string& referrer)
-    : weak_manager_(weak_manager),
-      app_title_(app_title),
-      native_app_data_(native_app_data),
-      primary_icon_(icon),
-      package_name_(native_app_package_name),
-      referrer_(referrer),
-      has_user_interaction_(false),
-      is_webapk_(false) {
-  DCHECK(!native_app_data_.is_null());
-  DCHECK(!package_name_.empty());
-  CreateJavaDelegate();
-}
-
-void AppBannerInfoBarDelegateAndroid::CreateJavaDelegate() {
+void AppBannerInfoBarDelegateAndroid::CreateJavaDelegate(JNIEnv* env) {
   java_delegate_.Reset(Java_AppBannerInfoBarDelegateAndroid_create(
-      base::android::AttachCurrentThread(), reinterpret_cast<intptr_t>(this)));
-}
-
-bool AppBannerInfoBarDelegateAndroid::AcceptNativeApp(
-    content::WebContents* web_contents) {
-  TrackUserResponse(USER_RESPONSE_NATIVE_APP_ACCEPTED);
-  JNIEnv* env = base::android::AttachCurrentThread();
-
-  TabAndroid* tab = TabAndroid::FromWebContents(web_contents);
-  DCHECK(tab);
-  ScopedJavaLocalRef<jstring> jreferrer(
-      ConvertUTF8ToJavaString(env, referrer_));
-
-  bool was_opened = Java_AppBannerInfoBarDelegateAndroid_installOrOpenNativeApp(
-      env, java_delegate_, tab->GetJavaObject(), native_app_data_, jreferrer);
-
-  if (was_opened)
-    TrackDismissEvent(DISMISS_EVENT_APP_OPEN);
-  else
-    TrackInstallEvent(INSTALL_EVENT_NATIVE_APP_INSTALL_TRIGGERED);
-
-  SendBannerAccepted();
-  return was_opened;
-}
-
-bool AppBannerInfoBarDelegateAndroid::AcceptWebApp(
-    content::WebContents* web_contents) {
-  TrackUserResponse(USER_RESPONSE_WEB_APP_ACCEPTED);
-
-  AppBannerSettingsHelper::RecordBannerInstallEvent(
-      web_contents, shortcut_info_->url.spec(), AppBannerSettingsHelper::WEB);
-
-  ShortcutHelper::AddToLauncherWithSkBitmap(web_contents, *shortcut_info_,
-                                            primary_icon_);
-
-  SendBannerAccepted();
-  return true;
-}
-
-bool AppBannerInfoBarDelegateAndroid::AcceptWebApk(
-    content::WebContents* web_contents) {
-  TrackUserResponse(USER_RESPONSE_WEB_APP_ACCEPTED);
-  AppBannerSettingsHelper::RecordBannerInstallEvent(
-      web_contents, shortcut_info_->url.spec(), AppBannerSettingsHelper::WEB);
-
-  WebApkInstallService::Get(web_contents->GetBrowserContext())
-      ->InstallAsync(web_contents, *shortcut_info_, primary_icon_, badge_icon_,
-                     install_source_);
-  SendBannerAccepted();
-  return true;
-}
-
-void AppBannerInfoBarDelegateAndroid::SendBannerAccepted() {
-  if (!weak_manager_)
-    return;
-
-  weak_manager_->SendBannerAccepted();
-
-  // Send the appinstalled event and perform install time logging. Note that
-  // this is fired *before* the installation actually takes place (which can be
-  // a significant amount of time later, especially if using WebAPKs).
-  // TODO(mgiuca): Fire the event *after* the installation is completed.
-  weak_manager_->OnInstall(!native_app_data_.is_null() /* is_native */,
-                           native_app_data_.is_null()
-                               ? shortcut_info_->display
-                               : blink::kWebDisplayModeUndefined);
+      env, reinterpret_cast<intptr_t>(this)));
 }
 
 infobars::InfoBarDelegate::InfoBarIdentifier
@@ -297,26 +103,8 @@ AppBannerInfoBarDelegateAndroid::GetIdentifier() const {
 }
 
 void AppBannerInfoBarDelegateAndroid::InfoBarDismissed() {
-  has_user_interaction_ = true;
-
-  content::WebContents* web_contents =
-      InfoBarService::WebContentsFromInfoBar(infobar());
-
-  if (weak_manager_)
-    weak_manager_->SendBannerDismissed();
-
-  if (native_app_data_.is_null()) {
-    if (is_webapk_)
-      webapk::TrackInstallEvent(webapk::INFOBAR_DISMISSED_BEFORE_INSTALLATION);
-    TrackUserResponse(USER_RESPONSE_WEB_APP_DISMISSED);
-    AppBannerSettingsHelper::RecordBannerDismissEvent(
-        web_contents, shortcut_info_->url.spec(), AppBannerSettingsHelper::WEB);
-  } else {
-    DCHECK(!package_name_.empty());
-    TrackUserResponse(USER_RESPONSE_NATIVE_APP_DISMISSED);
-    AppBannerSettingsHelper::RecordBannerDismissEvent(
-        web_contents, package_name_, AppBannerSettingsHelper::NATIVE);
-  }
+  ui_delegate_->OnUiDismissed(
+      InfoBarService::WebContentsFromInfoBar(infobar()));
 }
 
 int AppBannerInfoBarDelegateAndroid::GetButtons() const {
@@ -325,20 +113,12 @@ int AppBannerInfoBarDelegateAndroid::GetButtons() const {
 
 bool AppBannerInfoBarDelegateAndroid::LinkClicked(
     WindowOpenDisposition disposition) {
-  if (native_app_data_.is_null())
-    return false;
-
-  // Try to show the details for the native app.
   content::WebContents* web_contents =
       InfoBarService::WebContentsFromInfoBar(infobar());
-  TabAndroid* tab = TabAndroid::FromWebContents(web_contents);
-  DCHECK(tab);
 
-  Java_AppBannerInfoBarDelegateAndroid_showAppDetails(
-      base::android::AttachCurrentThread(), java_delegate_,
-      tab->GetJavaObject(), native_app_data_);
+  if (web_contents)
+    ui_delegate_->ShowNativeAppDetails(web_contents);
 
-  TrackDismissEvent(DISMISS_EVENT_BANNER_CLICK);
   return true;
 }
 

chrome/browser/banners/app_banner_infobar_delegate_android.h

@@ -6,57 +6,32 @@
 #define CHROME_BROWSER_BANNERS_APP_BANNER_INFOBAR_DELEGATE_ANDROID_H_
 
 #include <memory>
-#include <string>
 
 #include "base/android/scoped_java_ref.h"
 #include "base/macros.h"
-#include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
-#include "chrome/browser/installable/installable_metrics.h"
 #include "components/infobars/core/confirm_infobar_delegate.h"
-#include "third_party/skia/include/core/SkBitmap.h"
 
 namespace content {
 class WebContents;
 }
 
-namespace infobars {
-class InfoBarManager;
-}
-
-enum class WebApkInstallResult;
-struct ShortcutInfo;
-
 namespace banners {
 
-class AppBannerManager;
+class AppBannerUiDelegateAndroid;
 
 // Manages installation of an app being promoted by a page.
 class AppBannerInfoBarDelegateAndroid : public ConfirmInfoBarDelegate {
  public:
-  // Creates an infobar and delegate for promoting the installation of a web
-  // app, and adds the infobar to the InfoBarManager for |web_contents|.
+  // Creates an infobar and delegate for promoting the installation of an app,
+  // and displays the infobar for |web_contents|.
   static bool Create(content::WebContents* web_contents,
-                     base::WeakPtr<AppBannerManager> weak_manager,
-                     std::unique_ptr<ShortcutInfo> info,
-                     const SkBitmap& primary_icon,
-                     const SkBitmap& badge_icon,
-                     WebappInstallSource install_source,
-                     bool is_webapk);
-
-  // Creates an infobar and delegate for promoting the installation of an
-  // Android app, and adds the infobar to the InfoBarManager for |web_contents|.
-  static bool Create(
-      content::WebContents* web_contents,
-      base::WeakPtr<AppBannerManager> weak_manager,
-      const base::string16& app_title,
-      const base::android::ScopedJavaGlobalRef<jobject>& native_app_data,
-      const SkBitmap& icon,
-      const std::string& native_app_package_name,
-      const std::string& referrer);
+                     std::unique_ptr<AppBannerUiDelegateAndroid> ui_delegate);
 
   ~AppBannerInfoBarDelegateAndroid() override;
 
+  const AppBannerUiDelegateAndroid* GetUiDelegate() const;
+
   // Called when the AppBannerInfoBarAndroid's button needs to be updated.
   void UpdateInstallState(JNIEnv* env,
                           const base::android::JavaParamRef<jobject>& obj);
@@ -72,43 +47,15 @@ class AppBannerInfoBarDelegateAndroid : public ConfirmInfoBarDelegate {
                          const base::android::JavaParamRef<jobject>& obj,
                          jboolean success);
 
-  const SkBitmap& GetPrimaryIcon() const;
-
   // ConfirmInfoBarDelegate:
   bool Accept() override;
   base::string16 GetMessageText() const override;
 
  private:
-  // Delegate for promoting a web app.
-  AppBannerInfoBarDelegateAndroid(base::WeakPtr<AppBannerManager> weak_manager,
-                                  std::unique_ptr<ShortcutInfo> info,
-                                  const SkBitmap& primary_icon,
-                                  const SkBitmap& badge_icon,
-                                  WebappInstallSource install_source,
-                                  bool is_webapk);
-
-  // Delegate for promoting an Android app.
   AppBannerInfoBarDelegateAndroid(
-      base::WeakPtr<AppBannerManager> weak_manager,
-      const base::string16& app_title,
-      const base::android::ScopedJavaGlobalRef<jobject>& native_app_data,
-      const SkBitmap& icon,
-      const std::string& native_app_package_name,
-      const std::string& referrer);
-
-  void CreateJavaDelegate();
-  bool AcceptNativeApp(content::WebContents* web_contents);
-  bool AcceptWebApp(content::WebContents* web_contents);
-
-  // Called when the OK button on a WebAPK infobar is pressed. If the WebAPK is
-  // already installed, opens it; otherwise, installs it. Returns whether the
-  // infobar should be closed as a result of the button press.
-  bool AcceptWebApk(content::WebContents* web_contents);
-
-  // Called when the user accepts the banner to install the app. (Not called
-  // when the "Open" button is pressed on the banner that is shown after
-  // installation for WebAPK banners.)
-  void SendBannerAccepted();
+      std::unique_ptr<AppBannerUiDelegateAndroid> ui_delegate);
+
+  void CreateJavaDelegate(JNIEnv* env);
 
   // ConfirmInfoBarDelegate:
   infobars::InfoBarDelegate::InfoBarIdentifier GetIdentifier() const override;
@@ -116,26 +63,9 @@ class AppBannerInfoBarDelegateAndroid : public ConfirmInfoBarDelegate {
   int GetButtons() const override;
   bool LinkClicked(WindowOpenDisposition disposition) override;
 
+  std::unique_ptr<AppBannerUiDelegateAndroid> ui_delegate_;
   base::android::ScopedJavaGlobalRef<jobject> java_delegate_;
 
-  // Used to fetch the splash screen icon for webapps.
-  base::WeakPtr<AppBannerManager> weak_manager_;
-
-  base::string16 app_title_;
-  std::unique_ptr<ShortcutInfo> shortcut_info_;
-
-  base::android::ScopedJavaGlobalRef<jobject> native_app_data_;
-
-  const SkBitmap primary_icon_;
-  const SkBitmap badge_icon_;
-
-  std::string package_name_;
-  std::string referrer_;
-  bool has_user_interaction_;
-
-  bool is_webapk_;
-  WebappInstallSource install_source_;
-
   DISALLOW_COPY_AND_ASSIGN(AppBannerInfoBarDelegateAndroid);
 };
 

chrome/browser/banners/app_banner_manager_android.cc

@@ -13,6 +13,7 @@
 #include "chrome/browser/banners/app_banner_infobar_delegate_android.h"
 #include "chrome/browser/banners/app_banner_metrics.h"
 #include "chrome/browser/banners/app_banner_settings_helper.h"
+#include "chrome/browser/banners/app_banner_ui_delegate_android.h"
 #include "chrome/browser/installable/pwa_ambient_badge_manager_android.h"
 #include "content/public/browser/manifest_icon_downloader.h"
 #include "content/public/browser/web_contents.h"
@@ -199,11 +200,14 @@ void AppBannerManagerAndroid::ShowBannerUi(WebappInstallSource install_source) {
   DCHECK(contents);
 
   if (native_app_data_.is_null()) {
-    if (AppBannerInfoBarDelegateAndroid::Create(
-            contents, GetWeakPtr(),
+    std::unique_ptr<AppBannerUiDelegateAndroid> ui_delegate =
+        AppBannerUiDelegateAndroid::Create(
+            GetWeakPtr(),
             ShortcutHelper::CreateShortcutInfo(
                 manifest_url_, manifest_, primary_icon_url_, badge_icon_url_),
-            primary_icon_, badge_icon_, install_source, can_install_webapk_)) {
+            primary_icon_, badge_icon_, install_source, can_install_webapk_);
+    if (AppBannerInfoBarDelegateAndroid::Create(contents,
+                                                std::move(ui_delegate))) {
       RecordDidShowBanner("AppBanner.WebApp.Shown");
       TrackDisplayEvent(DISPLAY_EVENT_WEB_APP_BANNER_CREATED);
       ReportStatus(SHOWING_WEB_APP_BANNER);
@@ -211,9 +215,13 @@ void AppBannerManagerAndroid::ShowBannerUi(WebappInstallSource install_source) {
       ReportStatus(FAILED_TO_CREATE_BANNER);
     }
   } else {
-    if (AppBannerInfoBarDelegateAndroid::Create(
-            contents, GetWeakPtr(), native_app_title_, native_app_data_,
-            primary_icon_, native_app_package_, referrer_)) {
+    std::unique_ptr<AppBannerUiDelegateAndroid> ui_delegate =
+        AppBannerUiDelegateAndroid::Create(
+            GetWeakPtr(), native_app_title_,
+            base::android::ScopedJavaLocalRef<jobject>(native_app_data_),
+            primary_icon_, native_app_package_, referrer_);
+    if (AppBannerInfoBarDelegateAndroid::Create(contents,
+                                                std::move(ui_delegate))) {
       RecordDidShowBanner("AppBanner.NativeApp.Shown");
       TrackDisplayEvent(DISPLAY_EVENT_NATIVE_APP_BANNER_CREATED);
       ReportStatus(SHOWING_NATIVE_APP_BANNER);

chrome/browser/banners/app_banner_ui_delegate_android.cc

+// Copyright 2018 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/banners/app_banner_ui_delegate_android.h"
+
+#include <utility>
+
+#include "base/android/jni_android.h"
+#include "base/android/jni_string.h"
+#include "chrome/browser/android/shortcut_helper.h"
+#include "chrome/browser/android/shortcut_info.h"
+#include "chrome/browser/android/tab_android.h"
+#include "chrome/browser/android/webapk/webapk_install_service.h"
+#include "chrome/browser/android/webapk/webapk_metrics.h"
+#include "chrome/browser/banners/app_banner_manager.h"
+#include "chrome/browser/banners/app_banner_metrics.h"
+#include "chrome/browser/banners/app_banner_settings_helper.h"
+#include "chrome/browser/browser_process.h"
+#include "components/rappor/public/rappor_utils.h"
+#include "components/rappor/rappor_service_impl.h"
+#include "content/public/browser/web_contents.h"
+#include "jni/AppBannerUiDelegateAndroid_jni.h"
+#include "ui/gfx/android/java_bitmap.h"
+#include "url/gurl.h"
+
+namespace banners {
+
+// static
+std::unique_ptr<AppBannerUiDelegateAndroid> AppBannerUiDelegateAndroid::Create(
+    base::WeakPtr<AppBannerManager> weak_manager,
+    std::unique_ptr<ShortcutInfo> shortcut_info,
+    const SkBitmap& primary_icon,
+    const SkBitmap& badge_icon,
+    WebappInstallSource install_source,
+    bool is_webapk) {
+  return std::unique_ptr<AppBannerUiDelegateAndroid>(
+      new AppBannerUiDelegateAndroid(weak_manager, std::move(shortcut_info),
+                                     primary_icon, badge_icon, install_source,
+                                     is_webapk));
+}
+
+// static
+std::unique_ptr<AppBannerUiDelegateAndroid> AppBannerUiDelegateAndroid::Create(
+    base::WeakPtr<AppBannerManager> weak_manager,
+    const base::string16& app_title,
+    const base::android::ScopedJavaLocalRef<jobject>& native_app_data,
+    const SkBitmap& icon,
+    const std::string& native_app_package_name,
+    const std::string& referrer) {
+  return std::unique_ptr<AppBannerUiDelegateAndroid>(
+      new AppBannerUiDelegateAndroid(weak_manager, app_title, native_app_data,
+                                     icon, native_app_package_name, referrer));
+}
+
+AppBannerUiDelegateAndroid::~AppBannerUiDelegateAndroid() {
+  if (!has_user_interaction_) {
+    AppType type = GetType();
+    if (type == AppType::NATIVE) {
+      TrackUserResponse(USER_RESPONSE_NATIVE_APP_IGNORED);
+    } else {
+      TrackUserResponse(USER_RESPONSE_WEB_APP_IGNORED);
+      if (type == AppType::WEBAPK)
+        webapk::TrackInstallEvent(webapk::INFOBAR_IGNORED);
+    }
+  }
+
+  TrackDismissEvent(DISMISS_EVENT_DISMISSED);
+  Java_AppBannerUiDelegateAndroid_destroy(base::android::AttachCurrentThread(),
+                                          java_delegate_);
+  java_delegate_.Reset();
+}
+
+const base::string16& AppBannerUiDelegateAndroid::GetAppTitle() const {
+  return app_title_;
+}
+
+base::android::ScopedJavaLocalRef<jobject>
+AppBannerUiDelegateAndroid::GetJavaObject() {
+  return base::android::ScopedJavaLocalRef<jobject>(java_delegate_);
+}
+
+const base::android::ScopedJavaLocalRef<jobject>
+AppBannerUiDelegateAndroid::GetNativeAppData() const {
+  return base::android::ScopedJavaLocalRef<jobject>(native_app_data_);
+}
+
+int AppBannerUiDelegateAndroid::GetInstallState() const {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  base::android::ScopedJavaLocalRef<jstring> jpackage_name(
+      base::android::ConvertUTF8ToJavaString(env, package_name_));
+  return Java_AppBannerUiDelegateAndroid_determineInstallState(
+      env, java_delegate_, jpackage_name);
+}
+
+const SkBitmap& AppBannerUiDelegateAndroid::GetPrimaryIcon() const {
+  return primary_icon_;
+}
+
+AppBannerUiDelegateAndroid::AppType AppBannerUiDelegateAndroid::GetType()
+    const {
+  return type_;
+}
+
+const GURL& AppBannerUiDelegateAndroid::GetWebAppUrl() const {
+  return shortcut_info_->url;
+}
+
+bool AppBannerUiDelegateAndroid::InstallApp(
+    content::WebContents* web_contents) {
+  has_user_interaction_ = true;
+
+  if (!web_contents) {
+    TrackDismissEvent(DISMISS_EVENT_ERROR);
+    return true;
+  }
+
+  bool should_close_banner = true;
+  switch (GetType()) {
+    case AppType::NATIVE:
+      should_close_banner = InstallOrOpenNativeApp(web_contents);
+      break;
+    case AppType::WEBAPK:
+      InstallWebApk(web_contents);
+      break;
+    case AppType::LEGACY_WEBAPP:
+      InstallLegacyWebApp(web_contents);
+      break;
+  }
+  SendBannerAccepted();
+  return should_close_banner;
+}
+
+void AppBannerUiDelegateAndroid::OnNativeAppInstallStarted(
+    content::WebContents* web_contents) {
+  AppBannerSettingsHelper::RecordBannerEvent(
+      web_contents, web_contents->GetVisibleURL(), package_name_,
+      AppBannerSettingsHelper::APP_BANNER_EVENT_DID_ADD_TO_HOMESCREEN,
+      AppBannerManager::GetCurrentTime());
+
+  TrackInstallEvent(INSTALL_EVENT_NATIVE_APP_INSTALL_STARTED);
+  rappor::SampleDomainAndRegistryFromGURL(g_browser_process->rappor_service(),
+                                          "AppBanner.NativeApp.Installed",
+                                          web_contents->GetURL());
+}
+
+void AppBannerUiDelegateAndroid::OnNativeAppInstallFinished(bool success) {
+  if (success)
+    TrackInstallEvent(INSTALL_EVENT_NATIVE_APP_INSTALL_COMPLETED);
+  else
+    TrackDismissEvent(DISMISS_EVENT_INSTALL_TIMEOUT);
+}
+
+void AppBannerUiDelegateAndroid::OnUiDismissed(
+    content::WebContents* web_contents) {
+  has_user_interaction_ = true;
+
+  if (weak_manager_)
+    weak_manager_->SendBannerDismissed();
+
+  if (GetType() == AppType::NATIVE) {
+    DCHECK(!package_name_.empty());
+    TrackUserResponse(USER_RESPONSE_NATIVE_APP_DISMISSED);
+    AppBannerSettingsHelper::RecordBannerDismissEvent(
+        web_contents, package_name_, AppBannerSettingsHelper::NATIVE);
+  } else {
+    DCHECK(GetType() == AppType::WEBAPK || GetType() == AppType::LEGACY_WEBAPP);
+
+    if (GetType() == AppType::WEBAPK)
+      webapk::TrackInstallEvent(webapk::INFOBAR_DISMISSED_BEFORE_INSTALLATION);
+    TrackUserResponse(USER_RESPONSE_WEB_APP_DISMISSED);
+    AppBannerSettingsHelper::RecordBannerDismissEvent(
+        web_contents, shortcut_info_->url.spec(), AppBannerSettingsHelper::WEB);
+  }
+}
+
+void AppBannerUiDelegateAndroid::ShowNativeAppDetails(
+    content::WebContents* web_contents) {
+  if (native_app_data_.is_null())
+    return;
+
+  TabAndroid* tab = TabAndroid::FromWebContents(web_contents);
+  DCHECK(tab);
+
+  Java_AppBannerUiDelegateAndroid_showAppDetails(
+      base::android::AttachCurrentThread(), java_delegate_,
+      tab->GetJavaObject(), native_app_data_);
+
+  TrackDismissEvent(DISMISS_EVENT_BANNER_CLICK);
+}
+
+AppBannerUiDelegateAndroid::AppBannerUiDelegateAndroid(
+    base::WeakPtr<AppBannerManager> weak_manager,
+    std::unique_ptr<ShortcutInfo> shortcut_info,
+    const SkBitmap& primary_icon,
+    const SkBitmap& badge_icon,
+    WebappInstallSource install_source,
+    bool is_webapk)
+    : weak_manager_(weak_manager),
+      app_title_(shortcut_info->name),
+      shortcut_info_(std::move(shortcut_info)),
+      primary_icon_(primary_icon),
+      badge_icon_(badge_icon),
+      type_(is_webapk ? AppType::WEBAPK : AppType::LEGACY_WEBAPP),
+      install_source_(install_source),
+      has_user_interaction_(false) {
+  if (is_webapk)
+    shortcut_info_->UpdateSource(ShortcutInfo::SOURCE_APP_BANNER_WEBAPK);
+  else
+    shortcut_info_->UpdateSource(ShortcutInfo::SOURCE_APP_BANNER);
+
+  CreateJavaDelegate();
+}
+
+AppBannerUiDelegateAndroid::AppBannerUiDelegateAndroid(
+    base::WeakPtr<AppBannerManager> weak_manager,
+    const base::string16& app_title,
+    const base::android::ScopedJavaLocalRef<jobject>& native_app_data,
+    const SkBitmap& icon,
+    const std::string& native_app_package_name,
+    const std::string& referrer)
+    : weak_manager_(weak_manager),
+      app_title_(app_title),
+      native_app_data_(native_app_data),
+      primary_icon_(icon),
+      package_name_(native_app_package_name),
+      referrer_(referrer),
+      type_(AppType::NATIVE),
+      has_user_interaction_(false) {
+  DCHECK(!native_app_data_.is_null());
+  DCHECK(!package_name_.empty());
+  CreateJavaDelegate();
+}
+
+void AppBannerUiDelegateAndroid::CreateInstallerDelegate(
+    base::android::ScopedJavaLocalRef<jobject> jobserver) {
+  DCHECK(!java_delegate_.is_null());
+
+  Java_AppBannerUiDelegateAndroid_createInstallerDelegate(
+      base::android::AttachCurrentThread(), java_delegate_, jobserver);
+}
+
+void AppBannerUiDelegateAndroid::CreateJavaDelegate() {
+  java_delegate_.Reset(Java_AppBannerUiDelegateAndroid_create(
+      base::android::AttachCurrentThread(), reinterpret_cast<intptr_t>(this)));
+}
+
+bool AppBannerUiDelegateAndroid::InstallOrOpenNativeApp(
+    content::WebContents* web_contents) {
+  DCHECK_EQ(AppType::NATIVE, GetType());
+  TrackUserResponse(USER_RESPONSE_NATIVE_APP_ACCEPTED);
+  JNIEnv* env = base::android::AttachCurrentThread();
+
+  TabAndroid* tab = TabAndroid::FromWebContents(web_contents);
+  DCHECK(tab);
+  base::android::ScopedJavaLocalRef<jstring> jreferrer(
+      base::android::ConvertUTF8ToJavaString(env, referrer_));
+
+  bool was_opened = Java_AppBannerUiDelegateAndroid_installOrOpenNativeApp(
+      env, java_delegate_, tab->GetJavaObject(), native_app_data_, jreferrer);
+
+  if (was_opened)
+    TrackDismissEvent(DISMISS_EVENT_APP_OPEN);
+  else
+    TrackInstallEvent(INSTALL_EVENT_NATIVE_APP_INSTALL_TRIGGERED);
+
+  return was_opened;
+}
+
+void AppBannerUiDelegateAndroid::InstallWebApk(
+    content::WebContents* web_contents) {
+  TrackUserResponse(USER_RESPONSE_WEB_APP_ACCEPTED);
+  AppBannerSettingsHelper::RecordBannerInstallEvent(
+      web_contents, shortcut_info_->url.spec(), AppBannerSettingsHelper::WEB);
+
+  WebApkInstallService::Get(web_contents->GetBrowserContext())
+      ->InstallAsync(web_contents, *shortcut_info_, primary_icon_, badge_icon_,
+                     install_source_);
+}
+
+void AppBannerUiDelegateAndroid::InstallLegacyWebApp(
+    content::WebContents* web_contents) {
+  DCHECK_EQ(AppType::LEGACY_WEBAPP, GetType());
+
+  TrackUserResponse(USER_RESPONSE_WEB_APP_ACCEPTED);
+
+  AppBannerSettingsHelper::RecordBannerInstallEvent(
+      web_contents, shortcut_info_->url.spec(), AppBannerSettingsHelper::WEB);
+
+  ShortcutHelper::AddToLauncherWithSkBitmap(web_contents, *shortcut_info_,
+                                            primary_icon_);
+}
+
+void AppBannerUiDelegateAndroid::SendBannerAccepted() {
+  if (!weak_manager_)
+    return;
+
+  weak_manager_->SendBannerAccepted();
+
+  // Send the appinstalled event and perform install time logging. Note that
+  // this is fired *before* the installation actually takes place (which can be
+  // a significant amount of time later, especially if using WebAPKs).
+  // TODO(mgiuca): Fire the event *after* the installation is completed.
+  bool is_native = GetType() == AppType::NATIVE;
+  weak_manager_->OnInstall(is_native, is_native
+                                          ? blink::kWebDisplayModeUndefined
+                                          : shortcut_info_->display);
+}
+
+}  // namespace banners

chrome/browser/banners/app_banner_ui_delegate_android.h

+// Copyright 2018 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.
+
+#ifndef CHROME_BROWSER_BANNERS_APP_BANNER_UI_DELEGATE_ANDROID_H_
+#define CHROME_BROWSER_BANNERS_APP_BANNER_UI_DELEGATE_ANDROID_H_
+
+#include <memory>
+#include <string>
+
+#include "base/android/scoped_java_ref.h"
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "base/strings/string16.h"
+#include "chrome/browser/installable/installable_metrics.h"
+#include "components/infobars/core/confirm_infobar_delegate.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+
+namespace content {
+class WebContents;
+}
+
+struct ShortcutInfo;
+
+namespace banners {
+
+class AppBannerManager;
+
+// Delegate provided to the app banner UI surfaces to install a web app or
+// native app.
+class AppBannerUiDelegateAndroid {
+ public:
+  // Describes the type of app for which this class holds data.
+  enum class AppType {
+    NATIVE,
+    WEBAPK,
+    LEGACY_WEBAPP,
+  };
+
+  // Creates a delegate for promoting the installation of a web app.
+  static std::unique_ptr<AppBannerUiDelegateAndroid> Create(
+      base::WeakPtr<AppBannerManager> weak_manager,
+      std::unique_ptr<ShortcutInfo> info,
+      const SkBitmap& primary_icon,
+      const SkBitmap& badge_icon,
+      WebappInstallSource install_source,
+      bool is_webapk);
+
+  // Creates a delegate for promoting the installation of an Android app.
+  static std::unique_ptr<AppBannerUiDelegateAndroid> Create(
+      base::WeakPtr<AppBannerManager> weak_manager,
+      const base::string16& app_title,
+      const base::android::ScopedJavaLocalRef<jobject>& native_app_data,
+      const SkBitmap& icon,
+      const std::string& native_app_package_name,
+      const std::string& referrer);
+
+  ~AppBannerUiDelegateAndroid();
+
+  const base::string16& GetAppTitle() const;
+  base::android::ScopedJavaLocalRef<jobject> GetJavaObject();
+  const base::android::ScopedJavaLocalRef<jobject> GetNativeAppData() const;
+
+  int GetInstallState() const;
+  const SkBitmap& GetPrimaryIcon() const;
+  AppType GetType() const;
+  const GURL& GetWebAppUrl() const;
+
+  // Creates the Java-side InstallerDelegate, passing |jobserver| to receive
+  // progress updates on the installation of a native app.
+  void CreateInstallerDelegate(
+      base::android::ScopedJavaLocalRef<jobject> jobserver);
+
+  // Installs the app referenced by the data in this object. Returns |true| if
+  // the installation UI should be dismissed.
+  bool InstallApp(content::WebContents* web_contents);
+
+  // Called by the UI layer to indicate that a native app has begun
+  // installation.
+  void OnNativeAppInstallStarted(content::WebContents* web_contents);
+
+  // Called by the UI layer to indicate that a native app has finished
+  // installation.
+  void OnNativeAppInstallFinished(bool success);
+
+  // Called by the UI layer to indicate that the user has dismissed the
+  // installation UI.
+  void OnUiDismissed(content::WebContents* web_contents);
+
+  // Called by the UI layer to display the details for a native app.
+  void ShowNativeAppDetails(content::WebContents* web_contents);
+
+ private:
+  // Delegate for promoting a web app.
+  AppBannerUiDelegateAndroid(base::WeakPtr<AppBannerManager> weak_manager,
+                             std::unique_ptr<ShortcutInfo> info,
+                             const SkBitmap& primary_icon,
+                             const SkBitmap& badge_icon,
+                             WebappInstallSource install_source,
+                             bool is_webapk);
+
+  // Delegate for promoting an Android app.
+  AppBannerUiDelegateAndroid(
+      base::WeakPtr<AppBannerManager> weak_manager,
+      const base::string16& app_title,
+      const base::android::ScopedJavaLocalRef<jobject>& native_app_data,
+      const SkBitmap& icon,
+      const std::string& native_app_package_name,
+      const std::string& referrer);
+
+  void CreateJavaDelegate();
+  bool InstallOrOpenNativeApp(content::WebContents* web_contents);
+  void InstallWebApk(content::WebContents* web_contents);
+  void InstallLegacyWebApp(content::WebContents* web_contents);
+
+  // Called when the user accepts the banner to install the app. (Not called
+  // when the "Open" button is pressed on the banner that is shown after
+  // installation for WebAPK banners.)
+  void SendBannerAccepted();
+  base::android::ScopedJavaGlobalRef<jobject> java_delegate_;
+
+  base::WeakPtr<AppBannerManager> weak_manager_;
+
+  base::string16 app_title_;
+  std::unique_ptr<ShortcutInfo> shortcut_info_;
+
+  base::android::ScopedJavaGlobalRef<jobject> native_app_data_;
+
+  const SkBitmap primary_icon_;
+  const SkBitmap badge_icon_;
+
+  std::string package_name_;
+  std::string referrer_;
+
+  AppType type_;
+  WebappInstallSource install_source_;
+  bool has_user_interaction_;
+
+  DISALLOW_COPY_AND_ASSIGN(AppBannerUiDelegateAndroid);
+};
+
+}  // namespace banners
+
+#endif  // CHROME_BROWSER_BANNERS_APP_BANNER_UI_DELEGATE_ANDROID_H_

chrome/browser/ui/android/infobars/app_banner_infobar_android.cc

@@ -4,53 +4,47 @@
 
 #include "chrome/browser/ui/android/infobars/app_banner_infobar_android.h"
 
-#include <memory>
-#include <string>
 #include <utility>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
-#include "base/android/scoped_java_ref.h"
 #include "chrome/browser/banners/app_banner_infobar_delegate_android.h"
+#include "chrome/browser/banners/app_banner_ui_delegate_android.h"
 #include "components/url_formatter/elide_url.h"
 #include "jni/AppBannerInfoBarAndroid_jni.h"
 #include "ui/gfx/android/java_bitmap.h"
 
 AppBannerInfoBarAndroid::AppBannerInfoBarAndroid(
-    std::unique_ptr<banners::AppBannerInfoBarDelegateAndroid> delegate,
-    const base::android::ScopedJavaGlobalRef<jobject>& japp_data)
-    : ConfirmInfoBar(std::move(delegate)), japp_data_(japp_data) {}
-
-AppBannerInfoBarAndroid::AppBannerInfoBarAndroid(
-    std::unique_ptr<banners::AppBannerInfoBarDelegateAndroid> delegate,
-    const GURL& app_url)
-    : ConfirmInfoBar(std::move(delegate)), app_url_(app_url) {}
+    std::unique_ptr<banners::AppBannerInfoBarDelegateAndroid> delegate)
+    : ConfirmInfoBar(std::move(delegate)) {}
 
 AppBannerInfoBarAndroid::~AppBannerInfoBarAndroid() {}
 
 base::android::ScopedJavaLocalRef<jobject>
 AppBannerInfoBarAndroid::CreateRenderInfoBar(JNIEnv* env) {
-  banners::AppBannerInfoBarDelegateAndroid* delegate = GetDelegate();
+  const banners::AppBannerUiDelegateAndroid* delegate =
+      GetDelegate()->GetUiDelegate();
 
   base::android::ScopedJavaLocalRef<jstring> app_title =
-      base::android::ConvertUTF16ToJavaString(env, delegate->GetMessageText());
+      base::android::ConvertUTF16ToJavaString(env, delegate->GetAppTitle());
 
   DCHECK(!delegate->GetPrimaryIcon().drawsNothing());
   base::android::ScopedJavaLocalRef<jobject> java_bitmap =
       gfx::ConvertToJavaBitmap(&delegate->GetPrimaryIcon());
 
   base::android::ScopedJavaLocalRef<jobject> infobar;
-  if (!japp_data_.is_null()) {
+  if (delegate->GetType() ==
+      banners::AppBannerUiDelegateAndroid::AppType::NATIVE) {
     infobar.Reset(Java_AppBannerInfoBarAndroid_createNativeAppInfoBar(
-        env, app_title, java_bitmap, japp_data_));
+        env, app_title, java_bitmap, delegate->GetNativeAppData()));
   } else {
     // Trim down the app URL to the origin. Banners only show on secure origins,
     // so elide the scheme.
     base::android::ScopedJavaLocalRef<jstring> app_url =
         base::android::ConvertUTF16ToJavaString(
-            env,
-            url_formatter::FormatUrlForSecurityDisplay(
-                app_url_, url_formatter::SchemeDisplay::OMIT_CRYPTOGRAPHIC));
+            env, url_formatter::FormatUrlForSecurityDisplay(
+                     delegate->GetWebAppUrl(),
+                     url_formatter::SchemeDisplay::OMIT_CRYPTOGRAPHIC));
 
     infobar.Reset(Java_AppBannerInfoBarAndroid_createWebAppInfoBar(
         env, app_title, java_bitmap, app_url));

chrome/browser/ui/android/infobars/app_banner_infobar_android.h

@@ -5,10 +5,11 @@
 #ifndef CHROME_BROWSER_UI_ANDROID_INFOBARS_APP_BANNER_INFOBAR_ANDROID_H_
 #define CHROME_BROWSER_UI_ANDROID_INFOBARS_APP_BANNER_INFOBAR_ANDROID_H_
 
+#include <memory>
+
 #include "base/android/scoped_java_ref.h"
 #include "base/macros.h"
 #include "chrome/browser/ui/android/infobars/confirm_infobar.h"
-#include "url/gurl.h"
 
 namespace banners {
 class AppBannerInfoBarDelegateAndroid;
@@ -17,15 +18,8 @@ class AppBannerInfoBarDelegateAndroid;
 
 class AppBannerInfoBarAndroid : public ConfirmInfoBar {
  public:
-  // Constructs an AppBannerInfoBarAndroid promoting a native app.
-  AppBannerInfoBarAndroid(
-      std::unique_ptr<banners::AppBannerInfoBarDelegateAndroid> delegate,
-      const base::android::ScopedJavaGlobalRef<jobject>& japp_data);
-
-  // Constructs an AppBannerInfoBarAndroid promoting a web app.
   AppBannerInfoBarAndroid(
-      std::unique_ptr<banners::AppBannerInfoBarDelegateAndroid> delegate,
-      const GURL& app_url);
+      std::unique_ptr<banners::AppBannerInfoBarDelegateAndroid> delegate);
 
   ~AppBannerInfoBarAndroid() override;
 
@@ -41,12 +35,6 @@ class AppBannerInfoBarAndroid : public ConfirmInfoBar {
   base::android::ScopedJavaLocalRef<jobject> CreateRenderInfoBar(
       JNIEnv* env) override;
 
-  // Native app: Details about the app.
-  base::android::ScopedJavaGlobalRef<jobject> japp_data_;
-
-  // Web app: URL for the app.
-  GURL app_url_;
-
   base::android::ScopedJavaGlobalRef<jobject> java_infobar_;
 
   DISALLOW_COPY_AND_ASSIGN(AppBannerInfoBarAndroid);