Implement experimental app banner flow.

chrome/browser/banners/app_banner_manager.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/banners/app_banner_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 387 matching lines @@
   load_finished_ = true;
   validated_url_ = validated_url;
 
   // If the bypass flag is on, or if we require no engagement to trigger the
   // banner, the rest of the banner pipeline should operate as if the engagement
   // threshold has been met.
   if (AppBannerSettingsHelper::HasSufficientEngagement(0))
     has_sufficient_engagement_ = true;
 
   // Start the pipeline immediately if we pass (or bypass) the engagement check,
-  // or if the feature to run the installability check on page load is enabled.
+  // or if the feature to run the installability check on page load is enabled,
+  // or if the experimental banner flow is enabled.
   if (has_sufficient_engagement_ ||
       base::FeatureList::IsEnabled(
-          features::kCheckInstallabilityForBannerOnLoad)) {
+          features::kCheckInstallabilityForBannerOnLoad) ||
+      IsExperimentalAppBannersEnabled()) {
     RequestAppBanner(validated_url, false /* is_debug_mode */);
   }
 }
 
 void AppBannerManager::MediaStartedPlaying(const MediaPlayerInfo& media_info,
                                            const MediaPlayerId& id) {
   active_media_players_.push_back(id);
 }
 
 void AppBannerManager::MediaStoppedPlaying(const MediaPlayerInfo& media_info,
@@ skipping 30 matching lines @@
       UpdateState(State::ACTIVE);
       SendBannerPromptRequest();
     } else if (load_finished_) {
       // This performs some simple tests and starts async checks to test
       // installability. It should be safe to start in response to user input.
       RequestAppBanner(url, false /* is_debug_mode */);
     }
   }
 }
 
+// static
+bool AppBannerManager::IsExperimentalAppBannersEnabled() {
+  return base::FeatureList::IsEnabled(features::kExperimentalAppBanners);
+}
+
 void AppBannerManager::RecordCouldShowBanner() {
   content::WebContents* contents = web_contents();
   DCHECK(contents);
 
   AppBannerSettingsHelper::RecordBannerEvent(
       contents, validated_url_, GetAppIdentifier(),
       AppBannerSettingsHelper::APP_BANNER_EVENT_COULD_SHOW, GetCurrentTime());
 }
 
 bool AppBannerManager::CheckIfShouldShowBanner() {
@@ skipping 35 matching lines @@
   }
   return true;
 }
 
 void AppBannerManager::OnBannerPromptReply(
     blink::mojom::AppBannerPromptReply reply,
     const std::string& referrer) {
   // We don't need the controller any more, so reset it so the Blink-side object
   // is destroyed.
   controller_.reset();
-  content::WebContents* contents = web_contents();
 
   // The renderer might have requested the prompt to be canceled. They may
   // request that it is redisplayed later, so don't Stop() here. However, log
   // that the cancelation was requested, so Stop() can be called if a redisplay
   // isn't asked for.
   //
   // We use the additional page_requested_prompt_ variable because the redisplay
   // request may be received *before* the Cancel prompt reply (e.g. if redisplay
   // is requested in the beforeinstallprompt event handler).
   referrer_ = referrer;
-  if (reply == blink::mojom::AppBannerPromptReply::CANCEL) {
+  if (IsExperimentalAppBannersEnabled() ||
+      reply == blink::mojom::AppBannerPromptReply::CANCEL) {
     UpdateState(State::PENDING_EVENT);
     TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_PREVENT_DEFAULT_CALLED);
     if (!page_requested_prompt_)
       return;
   }
 
+  if (!IsExperimentalAppBannersEnabled())
+    ShowBanner();
+}
+
+void AppBannerManager::ShowBanner() {
   // If we haven't yet returned, but we're in the PENDING_EVENT state or
   // |page_requested_prompt_| is true, the page has requested a delayed showing
   // of the prompt. Otherwise, the prompt was never canceled by the page.
   if (is_pending_event()) {
     TrackBeforeInstallEvent(
         BEFORE_INSTALL_EVENT_PROMPT_CALLED_AFTER_PREVENT_DEFAULT);
     UpdateState(State::ACTIVE);
   } else {
     TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_NO_ACTION);
+    // In the experimental flow, the banner is only shown if the site explicitly
+    // requests it to be shown.
+    DCHECK(!IsExperimentalAppBannersEnabled());
   }
 
+  content::WebContents* contents = web_contents();
   AppBannerSettingsHelper::RecordMinutesFromFirstVisitToShow(
       contents, validated_url_, GetAppIdentifier(), GetCurrentTime());
 
   DCHECK(!manifest_url_.is_empty());
   DCHECK(!manifest_.IsEmpty());
   DCHECK(!primary_icon_url_.is_empty());
   DCHECK(!primary_icon_.drawsNothing());
 
   TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_COMPLETE);
-  ShowBanner();
+  ShowBannerUI();
   UpdateState(State::COMPLETE);
 }
 
 void AppBannerManager::DisplayAppBanner(bool user_gesture) {
+  // In the experimental flow, a user gesture is required for the prompt to be
+  // shown.
+  if (IsExperimentalAppBannersEnabled() && !user_gesture) {
+    // TODO: do some logging / error here
+    return;
+  }
+
   if (is_pending_event()) {
     // Simulate a non-canceled OnBannerPromptReply to show the delayed banner.
-    OnBannerPromptReply(blink::mojom::AppBannerPromptReply::NONE, referrer_);
+    ShowBanner();
   } else {
     // Log that the prompt request was made for when we get the prompt reply.
     page_requested_prompt_ = true;
   }
 }
 
 }  // namespace banners