Stop the banner pipeline from being triggered if it is already active.

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 19 matching lines @@
 
 namespace {
 
 int gCurrentRequestID = -1;
 int gTimeDeltaInDaysForTesting = 0;
 
 InstallableParams ParamsToGetManifest() {
   return InstallableParams();
 }
 
-// Returns whether or not the URLs match for everything except for the ref.
-bool URLsAreForTheSamePage(const GURL& first, const GURL& second) {
-  return first.GetWithEmptyPath() == second.GetWithEmptyPath() &&
-         first.path_piece() == second.path_piece() &&
-         first.query_piece() == second.query_piece();
-}
-
 }  // anonymous namespace
 
 namespace banners {
 
 // static
 base::Time AppBannerManager::GetCurrentTime() {
   return base::Time::Now() +
          base::TimeDelta::FromDays(gTimeDeltaInDaysForTesting);
 }
 
 // static
 void AppBannerManager::SetTimeDeltaForTesting(int days) {
   gTimeDeltaInDaysForTesting = days;
 }
 
 // static
 void AppBannerManager::SetTotalEngagementToTrigger(double engagement) {
   AppBannerSettingsHelper::SetTotalEngagementToTrigger(engagement);
 }
 
 void AppBannerManager::RequestAppBanner(const GURL& validated_url,
                                         bool is_debug_mode) {
   content::WebContents* contents = web_contents();
 
-  // Don't start a redundant banner request. Otherwise, if one is running,
-  // invalidate our weak pointers so it terminates.
-  if (is_active()) {
-    if (URLsAreForTheSamePage(validated_url, contents->GetLastCommittedURL()))
-      return;
-    else
-      weak_factory_.InvalidateWeakPtrs();
+  // The only time we should start the pipeline while it is already running is
+  // if it's been triggered from devtools.
+  if (is_active_or_pending()) {
+    DCHECK(is_debug_mode);
+    weak_factory_.InvalidateWeakPtrs();
   }
 
   UpdateState(State::ACTIVE);
   triggered_by_devtools_ = is_debug_mode;
   page_requested_prompt_ = false;
 
   // We only need to call ReportStatus if we aren't in debug mode (this avoids
   // skew from testing).
   DCHECK(!need_to_log_status_);
   need_to_log_status_ = !IsDebugMode();
@@ skipping 116 matching lines @@
     const GURL& start_url,
     const GURL& manifest_url) {
   return false;
 }
 
 void AppBannerManager::OnDidGetManifest(const InstallableData& data) {
   UpdateState(State::ACTIVE);
   if (data.error_code != NO_ERROR_DETECTED) {
     ReportStatus(web_contents(), data.error_code);
     Stop();
+    return;
   }
 
-  if (!is_active())
-    return;
-
   DCHECK(!data.manifest_url.is_empty());
   DCHECK(!data.manifest.IsEmpty());
 
   manifest_url_ = data.manifest_url;
   manifest_ = data.manifest;
 
   // One of manifest_.name or manifest_.short_name must be non-null and
   // non-empty if the error code was NO_ERROR_DETECTED.
   if (manifest_.name.is_null() || manifest_.name.string().empty())
     app_title_ = manifest_.short_name.string();
@@ skipping 32 matching lines @@
   UpdateState(State::ACTIVE);
   if (data.is_installable)
     TrackDisplayEvent(DISPLAY_EVENT_WEB_APP_BANNER_REQUESTED);
 
   if (data.error_code != NO_ERROR_DETECTED) {
     if (data.error_code == NO_MATCHING_SERVICE_WORKER)
       TrackDisplayEvent(DISPLAY_EVENT_LACKS_SERVICE_WORKER);
 
     ReportStatus(web_contents(), data.error_code);
     Stop();
+    return;
   }
 
-  if (!is_active())
-    return;
-
   DCHECK(data.is_installable);
   DCHECK(!data.primary_icon_url.is_empty());
   DCHECK(data.primary_icon);
 
   primary_icon_url_ = data.primary_icon_url;
   primary_icon_ = *data.primary_icon;
 
   // If we triggered the installability check on page load, then it's possible
   // we don't have enough engagement yet. If that's the case, return here but
   // don't call Stop(). We wait for OnEngagementIncreased to tell us that we
@@ skipping 140 matching lines @@
   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.
-  if (has_sufficient_engagement_ ||
-      base::FeatureList::IsEnabled(
-          features::kCheckInstallabilityForBannerOnLoad)) {
+  if (!is_active_or_pending() &&
+      (has_sufficient_engagement_ ||
+       base::FeatureList::IsEnabled(
+           features::kCheckInstallabilityForBannerOnLoad))) {
     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 22 matching lines @@
   //  3. we have accumulated sufficient engagement.
   if (web_contents() == contents && active_media_players_.empty() &&
       AppBannerSettingsHelper::HasSufficientEngagement(score)) {
     has_sufficient_engagement_ = true;
 
     if (is_pending_engagement()) {
       // We have already finished the installability eligibility checks. Proceed
       // directly to sending the banner prompt request.
       UpdateState(State::ACTIVE);
       SendBannerPromptRequest();
-    } else if (load_finished_) {
+    } else if (load_finished_ && !is_active_or_pending()) {
       // This performs some simple tests and starts async checks to test
       // installability. It should be safe to start in response to user input.
+      // Don't call if we're already working on processing a banner request.
       RequestAppBanner(url, false /* is_debug_mode */);
     }
   }
 }
 
 void AppBannerManager::RecordCouldShowBanner() {
   content::WebContents* contents = web_contents();
   DCHECK(contents);
 
   AppBannerSettingsHelper::RecordBannerEvent(
@@ skipping 93 matching lines @@
   if (is_pending_event()) {
     // Simulate a non-canceled OnBannerPromptReply to show the delayed banner.
     OnBannerPromptReply(blink::mojom::AppBannerPromptReply::NONE, referrer_);
   } else {
     // Log that the prompt request was made for when we get the prompt reply.
     page_requested_prompt_ = true;
   }
 }
 
 }  // namespace banners