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

chrome/browser/banners/app_banner_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_BANNERS_APP_BANNER_MANAGER_H_
 #define CHROME_BROWSER_BANNERS_APP_BANNER_MANAGER_H_
 
 #include <memory>
 #include <vector>
 
@@ skipping 76 matching lines @@
       const extensions::Extension* extension,
       const WebApplicationInfo& web_app_info) {}
 
   // Overridden and passed through base::Bind on Android. Called when the
   // download of a native app's icon is complete, as native banners use an icon
   // provided from the Play Store rather than the web manifest. Not used on
   // desktop platforms.
   virtual void OnAppIconFetched(const SkBitmap& bitmap) {}
 
  protected:
+  enum class State {
+    // The banner pipeline has not yet been triggered for this page load.
+    INACTIVE,
+
+    // The banner pipeline is currently running for this page load.
+    ACTIVE,
+
+    // The banner pipeline has finished running, but is waiting for sufficient
+    // engagement to trigger the banner.
+    PENDING_ENGAGEMENT,
+
+    // The banner pipeline has finished running, but is waiting for an event to
+    // trigger the banner.
+    PENDING_EVENT,
+
+    // The banner pipeline has finished running for this page load and no more
+    // processing is to be done.
+    COMPLETE,
+  };
+
   explicit AppBannerManager(content::WebContents* web_contents);
   ~AppBannerManager() override;
 
   // Returns true if the banner should be shown. Returns false if the banner has
   // been shown too recently, or if the app has already been installed.
   // GetAppIdentifier() must return a valid value for this method to work.
   bool CheckIfShouldShowBanner();
 
   // Return a string identifying this app for metrics.
   virtual std::string GetAppIdentifier();
@@ skipping 57 matching lines @@
   // Stops the banner pipeline, preventing any outstanding callbacks from
   // running and resetting the manager state. This method is virtual to allow
   // tests to intercept it and verify correct behaviour.
   virtual void Stop();
 
   // Sends a message to the renderer that the page has met the requirements to
   // show a banner. The page can respond to cancel the banner (and possibly
   // display it later), or otherwise allow it to be shown.
   void SendBannerPromptRequest();
 
+  // Updates the current state to |state|. Virtual to allow overriding in tests.
+  virtual void UpdateState(State state);
+
   // content::WebContentsObserver overrides.
   void DidStartNavigation(content::NavigationHandle* handle) override;
   void DidFinishNavigation(content::NavigationHandle* handle) override;
   void DidFinishLoad(content::RenderFrameHost* render_frame_host,
                      const GURL& validated_url) override;
   void MediaStartedPlaying(const MediaPlayerInfo& media_info,
                            const MediaPlayerId& id) override;
   void MediaStoppedPlaying(const MediaPlayerInfo& media_info,
                            const MediaPlayerId& id) override;
   void WebContentsDestroyed() override;
 
   // SiteEngagementObserver overrides.
   void OnEngagementIncreased(content::WebContents* web_contents,
                              const GURL& url,
                              double score) override;
 
   // Subclass accessors for private fields which should not be changed outside
   // this class.
   InstallableManager* manager() const { return manager_; }
   int event_request_id() const { return event_request_id_; }
-  bool is_active() const { return is_active_; }
+  bool is_active() const { return state_ == State::ACTIVE; }
+  bool is_active_or_pending() const {
+    return state_ == State::ACTIVE || state_ == State::PENDING_ENGAGEMENT ||
+           state_ == State::PENDING_EVENT;
+  }
+  bool is_complete() const { return state_ == State::COMPLETE; }
+  bool is_pending_engagement() const {
+    return state_ == State::PENDING_ENGAGEMENT;
+  }
+  bool is_pending_event() const {
+    return state_ == State::PENDING_EVENT || page_requested_prompt_;
+  }
 
   // The title to display in the banner.
   base::string16 app_title_;
 
   // The URL for which the banner check is being conducted.
   GURL validated_url_;
 
   // The URL of the manifest.
   GURL manifest_url_;
 
   // The manifest object.
   content::Manifest manifest_;
 
   // The URL of the primary icon.
   GURL primary_icon_url_;
 
   // The primary icon object.
   std::unique_ptr<SkBitmap> primary_icon_;
 
   // The referrer string (if any) specified in the app URL. Used only for native
   // app banners.
   std::string referrer_;
 
+  // The current banner pipeline state for this page load.
+  State state_;
+
  private:
   friend class AppBannerManagerTest;
 
   // Record that the banner could be shown at this point, if the triggering
   // heuristic allowed.
   void RecordCouldShowBanner();
 
   // Creates a banner for the app. Overridden by subclasses as the infobar is
   // platform-specific.
   virtual void ShowBanner() = 0;
@@ skipping 19 matching lines @@
   // We do not want to trigger a banner when the manager is attached to
   // a WebContents that is playing video. Banners triggering on a site in the
   // background will appear when the tab is reactivated.
   std::vector<MediaPlayerId> active_media_players_;
 
   // Mojo bindings and interface pointers.
   mojo::Binding<blink::mojom::AppBannerService> binding_;
   blink::mojom::AppBannerEventPtr event_;
   blink::mojom::AppBannerControllerPtr controller_;
 
-  // Whether we are currently working on whether to show a banner.
-  bool is_active_;
-
   // If a banner is requested before the page has finished loading, defer
   // triggering the pipeline until the load is complete.
-  bool banner_request_queued_;
+  bool has_sufficient_engagement_;
   bool load_finished_;
 
-  // Record whether the page decides to defer showing the banner, and if it
-  // requests for it to be shown later on.
-  bool was_canceled_by_page_;
+  // Record whether the page requests for a banner to be shown later on.
   bool page_requested_prompt_;
 
   // Whether we should be logging errors to the console for this request.
   bool is_debug_mode_;
 
   // Whether the installable status has been logged for this run.
   bool need_to_log_status_;
 
   // The concrete subclasses of this class are expected to have their lifetimes
   // scoped to the WebContents which they are observing. This allows us to use
   // weak pointers for callbacks.
   base::WeakPtrFactory<AppBannerManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AppBannerManager);
 };
 
 }  // namespace banners
 
 #endif  // CHROME_BROWSER_BANNERS_APP_BANNER_MANAGER_H_