chrome/browser/banners/app_banner_data_fetcher.h

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_BANNERS_APP_BANNER_DATA_FETCHER_H_
   6 #define CHROME_BROWSER_BANNERS_APP_BANNER_DATA_FETCHER_H_
   7
   8 #include "base/memory/ref_counted.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/memory/weak_ptr.h"
  11 #include "base/observer_list.h"
  12 #include "base/time/time.h"
  13 #include "chrome/common/web_application_info.h"
  14 #include "content/public/browser/web_contents.h"
  15 #include "content/public/browser/web_contents_observer.h"
  16 #include "content/public/common/manifest.h"
  17 #include "third_party/WebKit/public/platform/modules/app_banner/WebAppBannerPromptReply.h"
  18
  19 namespace chrome {
  20 class BitmapFetcher;
  21 }  // namespace chrome
  22
  23 namespace infobars {
  24 class InfoBar;
  25 }  // namespace infobars
  26
  27 namespace banners {
  28 class AppBannerDataFetcher;
  29
  30 // Fetches data required to show a web app banner for the URL currently shown by
  31 // the WebContents.
  32 class AppBannerDataFetcher
  33     : public base::RefCounted<AppBannerDataFetcher>,
  34       public content::WebContentsObserver {
  35  public:
  36   class Observer {
  37    public:
  38     virtual void OnDecidedWhetherToShow(AppBannerDataFetcher* fetcher,
  39                                         bool will_show) = 0;
  40     virtual void OnFetcherDestroyed(AppBannerDataFetcher* fetcher) = 0;
  41   };
  42
  43   class Delegate {
  44    public:
  45     // Called to handle a non-web app. Returns |true| if the non-web app can be
  46     // handled, and the fetcher needs to remain active and wait for a callback.
  47     virtual bool HandleNonWebApp(const std::string& platform,
  48                                  const GURL& url,
  49                                  const std::string& id) = 0;
  50   };
  51
  52   // Returns the current time.
  53   static base::Time GetCurrentTime();
  54
  55   // Fast-forwards the current time for testing.
  56   static void SetTimeDeltaForTesting(int days);
  57
  58   AppBannerDataFetcher(content::WebContents* web_contents,
  59                        base::WeakPtr<Delegate> weak_delegate,
  60                        int ideal_icon_size_in_dp);
  61
  62   // Begins creating a banner for the URL being displayed by the Delegate's
  63   // WebContents.
  64   void Start(const GURL& validated_url, ui::PageTransition transition_type);
  65
  66   // Stops the pipeline when any asynchronous calls return.
  67   void Cancel();
  68
  69   // Replaces the WebContents that is being observed.
  70   void ReplaceWebContents(content::WebContents* web_contents);
  71
  72   // Adds an observer to the list.
  73   void AddObserverForTesting(Observer* observer);
  74
  75   // Removes an observer from the list.
  76   void RemoveObserverForTesting(Observer* observer);
  77
  78   // Returns whether or not the pipeline has been stopped.
  79   bool is_active() { return is_active_; }
  80
  81   // Returns whether the beforeinstallprompt Javascript event was canceled.
  82   bool was_canceled_by_page() { return was_canceled_by_page_; }
  83
  84   // Returns whether the page has validly requested that the banner be shown
  85   // by calling prompt() on the beforeinstallprompt Javascript event.
  86   bool page_requested_prompt() { return page_requested_prompt_; }
  87
  88   // Returns the type of transition which triggered this fetch.
  89   ui::PageTransition transition_type() { return transition_type_; }
  90
  91   // Returns the URL that kicked off the banner data retrieval.
  92   const GURL& validated_url() { return validated_url_; }
  93
  94   // WebContentsObserver overrides.
  95   void WebContentsDestroyed() override;
  96   void DidNavigateMainFrame(
  97       const content::LoadCommittedDetails& details,
  98       const content::FrameNavigateParams& params) override;
  99   bool OnMessageReceived(const IPC::Message& message,
 100                          content::RenderFrameHost* render_frame_host) override;
 101
 102  protected:
 103   ~AppBannerDataFetcher() override;
 104
 105   // Return a string describing what type of banner is being created. Used when
 106   // alerting websites that a banner is about to be created.
 107   virtual std::string GetBannerType();
 108
 109   // Called after the manager sends a message to the renderer regarding its
 110   // intention to show a prompt. The renderer will send a message back with the
 111   // opportunity to cancel.
 112   void OnBannerPromptReply(content::RenderFrameHost* render_frame_host,
 113                            int request_id,
 114                            blink::WebAppBannerPromptReply reply,
 115                            std::string referrer);
 116
 117   // Called when the client has prevented a banner from being shown, and is
 118   // now requesting that it be shown later.
 119   void OnRequestShowAppBanner(content::RenderFrameHost* render_frame_host,
 120                               int request_id);
 121
 122   content::WebContents* GetWebContents();
 123   virtual std::string GetAppIdentifier();
 124   const content::Manifest& web_app_data() { return web_app_data_; }
 125   void set_app_title(const base::string16& title) { app_title_ = title; }
 126   int event_request_id() { return event_request_id_; }
 127
 128   // Fetches the icon at the given URL asynchronously, returning |false| if a
 129   // load could not be started.
 130   bool FetchAppIcon(content::WebContents* web_contents, const GURL& url);
 131
 132   // Records that a banner was shown. The |event_name| corresponds to the RAPPOR
 133   // metric being recorded.
 134   void RecordDidShowBanner(const std::string& event_name);
 135
 136  private:
 137   // Callbacks for data retrieval.
 138   void OnDidGetManifest(const content::Manifest& manifest);
 139   void OnDidCheckHasServiceWorker(bool has_service_worker);
 140   void OnAppIconFetched(const SkBitmap& bitmap);
 141
 142   // Called when it is determined that the webapp has fulfilled the initial
 143   // criteria of having a manifest and a service worker.
 144   void OnHasServiceWorker(content::WebContents* web_contents);
 145
 146   // Returns whether the given web app has already been installed.
 147   // Implemented on desktop platforms only.
 148   virtual bool IsWebAppInstalled(content::BrowserContext* browser_context,
 149                                  const GURL& start_url);
 150
 151   // Record that the banner could be shown at this point, if the triggering
 152   // heuristic allowed.
 153   void RecordCouldShowBanner();
 154
 155   // Creates a banner for the app using the given |icon|.
 156   virtual void ShowBanner(const SkBitmap* icon,
 157                           const base::string16& title,
 158                           const std::string& referrer) = 0;
 159
 160   // Returns whether the banner should be shown.
 161   bool CheckIfShouldShowBanner();
 162
 163   // Returns whether the fetcher is active and web contents have not been
 164   // closed.
 165   bool CheckFetcherIsStillAlive(content::WebContents* web_contents);
 166
 167   // Returns whether the given Manifest is following the requirements to show
 168   // a web app banner.
 169   static bool IsManifestValidForWebApp(const content::Manifest& manifest,
 170                                        content::WebContents* web_contents);
 171
 172   const int ideal_icon_size_in_dp_;
 173   const base::WeakPtr<Delegate> weak_delegate_;
 174   base::ObserverList<Observer> observer_list_;
 175   bool is_active_;
 176   bool was_canceled_by_page_;
 177   bool page_requested_prompt_;
 178   ui::PageTransition transition_type_;
 179   int event_request_id_;
 180   scoped_ptr<SkBitmap> app_icon_;
 181   std::string referrer_;
 182
 183   GURL validated_url_;
 184   base::string16 app_title_;
 185   content::Manifest web_app_data_;
 186
 187   friend class AppBannerDataFetcherUnitTest;
 188   friend class base::RefCounted<AppBannerDataFetcher>;
 189   DISALLOW_COPY_AND_ASSIGN(AppBannerDataFetcher);
 190 };
 191
 192 }  // namespace banners
 193
 194 #endif  // CHROME_BROWSER_BANNERS_APP_BANNER_DATA_FETCHER_H_