Allow banners to trigger on sites which don't register a service worker onload.

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 60 matching lines @@
   // 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();
   }
 
   UpdateState(State::ACTIVE);
-  is_debug_mode_ = is_debug_mode;
+  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();
 
   // Exit if this is an incognito window, non-main frame, or insecure context.
   InstallableStatusCode code = NO_ERROR_DETECTED;
   if (Profile::FromBrowserContext(contents->GetBrowserContext())
@@ skipping 11 matching lines @@
     return;
   }
 
   if (validated_url_.is_empty())
     validated_url_ = validated_url;
 
   // Any existing binding is invalid when we request a new banner.
   if (binding_.is_bound())
     binding_.Close();
 
+  UpdateState(State::PENDING_MANIFEST);
   manager_->GetData(
       ParamsToGetManifest(),
       base::Bind(&AppBannerManager::OnDidGetManifest, GetWeakPtr()));
 }
 
 void AppBannerManager::OnInstall() {
   blink::mojom::InstallationServicePtr installation_service;
   web_contents()->GetMainFrame()->GetRemoteInterfaces()->GetInterface(
       mojo::MakeRequest(&installation_service));
   DCHECK(installation_service);
@@ skipping 24 matching lines @@
     : content::WebContentsObserver(web_contents),
       SiteEngagementObserver(SiteEngagementService::Get(
           Profile::FromBrowserContext(web_contents->GetBrowserContext()))),
       state_(State::INACTIVE),
       manager_(nullptr),
       event_request_id_(-1),
       binding_(this),
       has_sufficient_engagement_(false),
       load_finished_(false),
       page_requested_prompt_(false),
-      is_debug_mode_(false),
+      triggered_by_devtools_(false),
       need_to_log_status_(false),
       weak_factory_(this) {
   // Ensure the InstallableManager exists since we have a hard dependency on it.
   InstallableManager::CreateForWebContents(web_contents);
   manager_ = InstallableManager::FromWebContents(web_contents);
   DCHECK(manager_);
 
   AppBannerSettingsHelper::UpdateFromFieldTrial();
 }
 
@@ skipping 18 matching lines @@
 
 int AppBannerManager::GetIdealPrimaryIconSizeInPx() {
   return InstallableManager::GetMinimumIconSizeInPx();
 }
 
 int AppBannerManager::GetMinimumPrimaryIconSizeInPx() {
   return InstallableManager::GetMinimumIconSizeInPx();
 }
 
 bool AppBannerManager::IsDebugMode() const {
-  return is_debug_mode_ ||
+  return triggered_by_devtools_ ||
          base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kBypassAppBannerEngagementChecks);
 }
 
 bool AppBannerManager::IsWebAppInstalled(
     content::BrowserContext* browser_context,
     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();
   }
 
   if (!is_active())
     return;
 
   DCHECK(!data.manifest_url.is_empty());
   DCHECK(!data.manifest.IsEmpty());
@@ skipping 11 matching lines @@
   PerformInstallableCheck();
 }
 
 InstallableParams AppBannerManager::ParamsToPerformInstallableCheck() {
   InstallableParams params;
   params.ideal_primary_icon_size_in_px = GetIdealPrimaryIconSizeInPx();
   params.minimum_primary_icon_size_in_px = GetMinimumPrimaryIconSizeInPx();
   params.check_installable = true;
   params.fetch_valid_primary_icon = true;
 
+  // Don't wait for the service worker if this was triggered from devtools.
+  params.wait_for_worker = !triggered_by_devtools_;
+
   return params;
 }
 
 void AppBannerManager::PerformInstallableCheck() {
   if (!CheckIfShouldShowBanner())
     return;
 
   // Fetch and verify the other required information.
+  UpdateState(State::PENDING_INSTALLABLE_CHECK);
   manager_->GetData(ParamsToPerformInstallableCheck(),
                     base::Bind(&AppBannerManager::OnDidPerformInstallableCheck,
                                GetWeakPtr()));
 }
 
 void AppBannerManager::OnDidPerformInstallableCheck(
     const InstallableData& data) {
+  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();
   }
@@ skipping 47 matching lines @@
 
 void AppBannerManager::ResetCurrentPageData() {
   active_media_players_.clear();
   manifest_ = content::Manifest();
   manifest_url_ = GURL();
   validated_url_ = GURL();
   referrer_.erase();
 }
 
 void AppBannerManager::Stop() {
-  if (state_ == State::PENDING_EVENT && !page_requested_prompt_) {
-    TrackBeforeInstallEvent(
-        BEFORE_INSTALL_EVENT_PROMPT_NOT_CALLED_AFTER_PREVENT_DEFAULT);
-    ReportStatus(web_contents(), RENDERER_CANCELLED);
-  } else if (state_ == State::PENDING_ENGAGEMENT &&
-             !has_sufficient_engagement_) {
-    TrackDisplayEvent(DISPLAY_EVENT_NOT_VISITED_ENOUGH);
-    ReportStatus(web_contents(), INSUFFICIENT_ENGAGEMENT);
+  // Record the status if we are currently waiting for data.
+  InstallableStatusCode code = NO_ERROR_DETECTED;
+  switch (state_) {
+    case State::PENDING_EVENT:
+      if (!page_requested_prompt_) {
+        TrackBeforeInstallEvent(
+            BEFORE_INSTALL_EVENT_PROMPT_NOT_CALLED_AFTER_PREVENT_DEFAULT);
+        code = RENDERER_CANCELLED;
+      }
+      break;
+    case State::PENDING_ENGAGEMENT:
+      if (!has_sufficient_engagement_) {
+        TrackDisplayEvent(DISPLAY_EVENT_NOT_VISITED_ENOUGH);
+        code = INSUFFICIENT_ENGAGEMENT;
+      }
+      break;
+    case State::PENDING_MANIFEST:
+      code = WAITING_FOR_MANIFEST;
+      break;
+    case State::PENDING_INSTALLABLE_CHECK:
+      code = WAITING_FOR_INSTALLABLE_CHECK;
+      break;
+    case State::ACTIVE:
+    case State::INACTIVE:
+    case State::COMPLETE:
+      break;
   }
 
+  if (code != NO_ERROR_DETECTED)
+    ReportStatus(web_contents(), code);
+
   // In every non-debug run through the banner pipeline, we should have called
   // ReportStatus() and set need_to_log_status_ to false. The only case where
-  // we don't is if we're still active and waiting for a callback from the
-  // InstallableManager (e.g. the renderer crashes or the browser is shutting
-  // down). These situations are explicitly not logged.
+  // we don't is if we're still active and waiting for native app data, which is
+  // explicitly not logged.
   DCHECK(!need_to_log_status_ || is_active());
 
   weak_factory_.InvalidateWeakPtrs();
   binding_.Close();
   controller_.reset();
   event_.reset();
 
   UpdateState(State::COMPLETE);
   need_to_log_status_ = false;
   has_sufficient_engagement_ = false;
@@ skipping 213 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