Allow the app banner installability check to run on page load.

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"
+#include "base/feature_list.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.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/engagement/site_engagement_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_features.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/rappor/public/rappor_utils.h"
 #include "components/rappor/rappor_service_impl.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/platform/modules/installation/installation.mojom.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 34 matching lines @@
          first.path_piece() == second.path_piece() &&
          first.query_piece() == second.query_piece();
 }
 
 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 (IsActive()) {

[benwells, 2017/03/30 08:22:37]

My initial comment: Is this right? Should it be !IsInactive?

Then I realised that we rerun the banner checks sometimes to get more stuff. Is
that still right? Will it still needed now if we do all the checks on page load?

[dominickn, 2017/03/30 23:42:52]

The main case this is catching is if we've triggered on page load and then
engagement ticks over whilst we're still checking (but haven't yet gotten to
waiting for engagement).

If that's the case, we'll eventually get to the pending engagement check, which
will pass. So just bailing out if we're currently active is correct I think.

[benwells, 2017/03/31 04:00:35]

OK. This logic is really complicated, but right now I think it has to be. What I
was wondering really was, if we get to a time when we are doing a check on page
load, and getting all the things then, can we remove the need to be able to
retrigger the flow for more things and just have the one run each page load.

[dominickn, 2017/03/31 04:59:17]

Yep, I think we can remove the retrigger stuff here if we know we're running on
page load. :)

     if (URLsAreForTheSamePage(validated_url, contents->GetLastCommittedURL()))
       return;
     else
       weak_factory_.InvalidateWeakPtrs();
   }
 
-  is_active_ = true;
+  UpdateState(State::ACTIVE);
   is_debug_mode_ = is_debug_mode;
-  was_canceled_by_page_ = false;
   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 42 matching lines @@
 void AppBannerManager::SendBannerDismissed(int request_id) {
   if (request_id != gCurrentRequestID)
     return;
 
   DCHECK(event_.is_bound());
   event_->BannerDismissed();
 }
 
 AppBannerManager::AppBannerManager(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
-      SiteEngagementObserver(nullptr),
+      SiteEngagementObserver(SiteEngagementService::Get(
+          Profile::FromBrowserContext(web_contents->GetBrowserContext()))),
+      state_(State::INACTIVE),
       manager_(nullptr),
       event_request_id_(-1),
       binding_(this),
-      is_active_(false),
-      banner_request_queued_(false),
+      has_sufficient_engagement_(false),
       load_finished_(false),
-      was_canceled_by_page_(false),
       page_requested_prompt_(false),
       is_debug_mode_(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 42 matching lines @@
     const GURL& manifest_url) {
   return false;
 }
 
 void AppBannerManager::OnDidGetManifest(const InstallableData& data) {
   if (data.error_code != NO_ERROR_DETECTED) {
     ReportStatus(web_contents(), data.error_code);
     Stop();
   }
 
-  if (!is_active_)
+  if (!IsActive())
     return;
 
   DCHECK(!data.manifest_url.is_empty());
   DCHECK(!data.manifest.IsEmpty());
 
   manifest_url_ = data.manifest_url;
   manifest_ = data.manifest;
   app_title_ = (manifest_.name.is_null()) ? manifest_.short_name.string()
                                           : manifest_.name.string();
 
@@ skipping 26 matching lines @@
     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();
   }
 
-  if (!is_active_)
+  if (!IsActive())
     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_.reset(new SkBitmap(*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
+  // should trigger.
+  if (!has_sufficient_engagement_) {
+    UpdateState(State::PENDING_ENGAGEMENT);
+    return;
+  }
+
   SendBannerPromptRequest();
 }
 
 void AppBannerManager::RecordDidShowBanner(const std::string& event_name) {
   content::WebContents* contents = web_contents();
   DCHECK(contents);
 
   AppBannerSettingsHelper::RecordBannerEvent(
       contents, validated_url_, GetAppIdentifier(),
       AppBannerSettingsHelper::APP_BANNER_EVENT_DID_SHOW,
@@ skipping 17 matching lines @@
 
 void AppBannerManager::ResetCurrentPageData() {
   active_media_players_.clear();
   manifest_ = content::Manifest();
   manifest_url_ = GURL();
   validated_url_ = GURL();
   referrer_.erase();
 }
 
 void AppBannerManager::Stop() {
-  if (was_canceled_by_page_ && !page_requested_prompt_) {
+  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);
   }
 
   // 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.
-  DCHECK(!need_to_log_status_ || is_active_);
+  DCHECK(!need_to_log_status_ || IsActive());
 
   weak_factory_.InvalidateWeakPtrs();
   binding_.Close();
   controller_.reset();
   event_.reset();
 
-  is_active_ = false;
+  UpdateState(State::COMPLETE);
   need_to_log_status_ = false;
+  has_sufficient_engagement_ = false;

[benwells, 2017/03/30 08:22:37]

Why do you set this false? and why COMPLETE?

[dominickn, 2017/03/30 23:42:52]

COMPLETE means that we're not going to do anything more for this page load.
Hence, having sufficient engagement is now irrelevant.

We want to clear this out early (i.e. as soon as Stop() is called) to ensure
that we're not storing banner-triggering state for too long.

 }
 
 void AppBannerManager::SendBannerPromptRequest() {
   RecordCouldShowBanner();
 
   TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_CREATED);
   event_request_id_ = ++gCurrentRequestID;
 
   web_contents()->GetMainFrame()->GetRemoteInterfaces()->GetInterface(
       mojo::MakeRequest(&controller_));
 
   controller_->BannerPromptRequest(
       binding_.CreateInterfacePtrAndBind(), mojo::MakeRequest(&event_),
       {GetBannerType()},
       base::Bind(&AppBannerManager::OnBannerPromptReply, GetWeakPtr()));
 }
 
+void AppBannerManager::UpdateState(State state) {
+  state_ = state;

[benwells, 2017/03/30 08:22:36]

Is it worth setting more state here (e.g. if inactive, set
has_sufficient_engageemnt false, etc.)?

I think adding DCHECKS (e.g. if PENDING_EVENT, has_sufficient_engagement should
be true) would be worthwhile as the logic is quite subtle, and there might be
some invariants we can check here.

[dominickn, 2017/03/30 23:42:52]

I added the pending event DCHECK, but I can't think of any more that are
sensible to have here (we pay the cost of evaluating more conditionals for
single cases).

The main reason I added this method was to let it be overridden in tests for run
loop catching.

+}
+
 void AppBannerManager::DidStartNavigation(content::NavigationHandle* handle) {
   if (!handle->IsInMainFrame() || handle->IsSameDocument())
     return;
 
+  if (IsActiveOrPending())
+    Stop();
+  UpdateState(State::INACTIVE);
   load_finished_ = false;
-  if (GetSiteEngagementService() == nullptr) {
-    // Ensure that we are observing the site engagement service on navigation
-    // start. This may be the first navigation, or we may have stopped
-    // observing if the banner flow was triggered on the previous page.
-    SiteEngagementObserver::Observe(SiteEngagementService::Get(
-        Profile::FromBrowserContext(web_contents()->GetBrowserContext())));
-  }
+  has_sufficient_engagement_ = false;
+  page_requested_prompt_ = false;
 }
 
 void AppBannerManager::DidFinishNavigation(content::NavigationHandle* handle) {
   if (handle->IsInMainFrame() && handle->HasCommitted() &&
       !handle->IsSameDocument()) {
     ResetCurrentPageData();
-    if (is_active_)
-      Stop();
   }
 }
 
 void AppBannerManager::DidFinishLoad(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url) {
   // Don't start the banner flow unless the main frame has finished loading.
   if (render_frame_host->GetParent())
     return;
 
   load_finished_ = true;
   validated_url_ = validated_url;
-  // Start the pipeline immediately if 0 engagement is required or if we've
-  // queued a banner request.
-  if (banner_request_queued_ ||
-      AppBannerSettingsHelper::HasSufficientEngagement(0)) {
-    SiteEngagementObserver::Observe(nullptr);
-    banner_request_queued_ = false;
-
+  // Start the pipeline immediately if:
+  //  1. we have sufficient engagement, or
+  //  2. 0 engagement is required, or
+  //  3. the feature to start the installability check in load is enabled
+  if (has_sufficient_engagement_ ||
+      AppBannerSettingsHelper::HasSufficientEngagement(0) ||
+      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,
                                            const MediaPlayerId& id) {
   active_media_players_.erase(std::remove(active_media_players_.begin(),
                                           active_media_players_.end(), id),
                               active_media_players_.end());
 }
 
 void AppBannerManager::WebContentsDestroyed() {
   Stop();
 }
 
 void AppBannerManager::OnEngagementIncreased(content::WebContents* contents,
                                              const GURL& url,
                                              double score) {
+  // In the ACTIVE state, we may have triggered the installability check, but
+  // not checked engagement yet. In the INACTIVE or PENDING_ENGAGEMENT states,
+  // we are waiting for an engagement signal to trigger the pipeline.
+  if (IsComplete() || IsPendingEvent())
+    return;
+
   // Only trigger a banner using site engagement if:
   //  1. engagement increased for the web contents which we are attached to; and
   //  2. there are no currently active media players; and
   //  3. we have accumulated sufficient engagement.
   if (web_contents() == contents && active_media_players_.empty() &&
       AppBannerSettingsHelper::HasSufficientEngagement(score)) {
-    // Stop observing so we don't double-trigger the banner.
-    SiteEngagementObserver::Observe(nullptr);
+    has_sufficient_engagement_ = true;
 
-    if (!load_finished_) {
-      // Queue the banner request until the main frame finishes loading.
-      banner_request_queued_ = true;
-    } else {
-      // A banner request performs some simple tests, creates a data fetcher,
-      // and starts some asynchronous checks to test installability. It should
-      // be safe to start this in response to user input.
+    if (IsPendingEngagement()) {
+      // We have already finished the installability eligibility checks. Proceed
+      // directly to sending the banner prompt request.
+      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 */);
     }
   }
 }
 
 void AppBannerManager::RecordCouldShowBanner() {
   content::WebContents* contents = web_contents();
   DCHECK(contents);
 
   AppBannerSettingsHelper::RecordBannerEvent(
@@ skipping 42 matching lines @@
 }
 
 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.
+  // 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 &&
-      !page_requested_prompt_) {
+  if (reply == blink::mojom::AppBannerPromptReply::CANCEL) {
+    UpdateState(State::PENDING_EVENT);

[benwells, 2017/03/30 08:22:36]

How come you don't have to check page_requested_prompt anymore?

[dominickn, 2017/03/30 23:42:52]

We still do to return (see line 519). The key thing here is that the metric is
recorded when the reply is a CANCEL (this was a bug).

     TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_PREVENT_DEFAULT_CALLED);
-    was_canceled_by_page_ = true;
-    return;
+    if (!page_requested_prompt_)
+      return;
   }
 
-  // If we haven't yet returned, but either of |was_canceled_by_page_| or
+  // 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 (was_canceled_by_page_ || page_requested_prompt_) {
+  if (IsPendingEvent()) {
     TrackBeforeInstallEvent(
         BEFORE_INSTALL_EVENT_PROMPT_CALLED_AFTER_PREVENT_DEFAULT);
-    was_canceled_by_page_ = false;
+    UpdateState(State::ACTIVE);

[benwells, 2017/03/30 08:22:36]

This is weird - why go back to ACTIVE?

[dominickn, 2017/03/30 23:42:52]

This is analogous to the case where we didn't have the site call
preventDefault(). In that case, it stays in ACTIVE all the way till the banner
is shown. So we move back to ACTIVE when we rejoin that code path.

Does that make sense?

[benwells, 2017/03/31 04:00:35]

Ah ... I think so.

   } else {
     TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_NO_ACTION);
   }
 
   AppBannerSettingsHelper::RecordMinutesFromFirstVisitToShow(
       contents, validated_url_, GetAppIdentifier(), GetCurrentTime());
 
   DCHECK(!manifest_url_.is_empty());
   DCHECK(!manifest_.IsEmpty());
   DCHECK(!primary_icon_url_.is_empty());
   DCHECK(primary_icon_.get());
 
   TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_COMPLETE);
   ShowBanner();
-  is_active_ = false;
+  UpdateState(State::COMPLETE);
 }
 
 void AppBannerManager::DisplayAppBanner() {
-  if (was_canceled_by_page_) {
+  if (IsPendingEvent()) {
     // Simulate a non-canceled OnBannerPromptReply to show the delayed banner.
-    // Don't reset |was_canceled_by_page_| yet for metrics purposes.
     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