Replace AppBannerDataFetcher with InstallableManager.

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 "chrome/browser/banners/app_banner_data_fetcher.h"
-#include "chrome/browser/banners/app_banner_debug_log.h"
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/command_line.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/installable/installable_logging.h"
+#include "chrome/browser/installable/installable_manager.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/render_messages.h"
+#include "components/rappor/rappor_utils.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
-#include "content/public/common/frame_navigate_params.h"
 #include "content/public/common/origin_util.h"
+#include "third_party/WebKit/public/platform/modules/app_banner/WebAppBannerPromptReply.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/display/display.h"
+#include "ui/display/screen.h"
 
 namespace {
+
 bool gDisableSecureCheckForTesting = false;
+int gCurrentRequestID = -1;
+base::LazyInstance<base::TimeDelta> gTimeDeltaForTesting =
+    LAZY_INSTANCE_INITIALIZER;
+
+// Returns |size_in_px| in dp, i.e. divided by the current device scale factor.
+int ConvertIconSizeFromPxToDp(int size_in_px) {
+  return size_in_px /
+      display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor();
+}
+
+// Returns an InstallableParams object that requests all checks necessary for
+// a web app banner.
+InstallableParams GetWebAppParams(int ideal_icon_size_in_dp,
+                                  int minimum_icon_size_in_dp) {
+  InstallableParams params;
+  params.ideal_icon_size_in_dp = ideal_icon_size_in_dp;
+  params.minimum_icon_size_in_dp = minimum_icon_size_in_dp;
+  params.check_installable = true;
+  params.fetch_valid_icon = true;
+
+  return params;
+}
+
 }  // anonymous namespace
 
 namespace banners {
 
+// static
 void AppBannerManager::DisableSecureSchemeCheckForTesting() {
   gDisableSecureCheckForTesting = true;
 }
 
+// static
+base::Time AppBannerManager::GetCurrentTime() {

[benwells, 2016/08/09 03:41:26]

nit: If GetCurrentTime is only used for testing, call it
GetCurrentTimeForTesting

[dominickn, 2016/08/09 08:28:57]

It's not only used for testing - it's also used for recording things to content
settings.

[benwells, 2016/08/10 03:36:05]

Acknowledged.

+  return base::Time::Now() + gTimeDeltaForTesting.Get();
+}
+
+// static
+void AppBannerManager::SetTimeDeltaForTesting(int days) {
+  gTimeDeltaForTesting.Get() = base::TimeDelta::FromDays(days);
+}
+
+// static
 void AppBannerManager::SetEngagementWeights(double direct_engagement,
                                             double indirect_engagement) {
   AppBannerSettingsHelper::SetEngagementWeights(direct_engagement,
                                                 indirect_engagement);
 }
 
+// static
 bool AppBannerManager::URLsAreForTheSamePage(const GURL& first,
                                              const GURL& second) {
   return first.GetWithEmptyPath() == second.GetWithEmptyPath() &&
          first.path() == second.path() && first.query() == second.query();
 }
 
-AppBannerManager::AppBannerManager(content::WebContents* web_contents)
-    : content::WebContentsObserver(web_contents),
-      SiteEngagementObserver(nullptr),
-      data_fetcher_(nullptr),
-      banner_request_queued_(false),
-      load_finished_(false),
-      weak_factory_(this) {
-  AppBannerSettingsHelper::UpdateFromFieldTrial();
-}
-
-AppBannerManager::~AppBannerManager() {
-  CancelActiveFetcher();
-}
-
-void AppBannerManager::ReplaceWebContents(content::WebContents* web_contents) {
-  content::WebContentsObserver::Observe(web_contents);
-  if (data_fetcher_.get())
-    data_fetcher_.get()->ReplaceWebContents(web_contents);
-}
-
-bool AppBannerManager::IsFetcherActive() {
-  return data_fetcher_ && data_fetcher_->is_active();
-}
-
 void AppBannerManager::RequestAppBanner(const GURL& validated_url,
                                         bool is_debug_mode) {
   content::WebContents* contents = web_contents();
   if (contents->GetMainFrame()->GetParent()) {
-    OutputDeveloperNotShownMessage(contents, kNotLoadedInMainFrame,
-                                   is_debug_mode);
-    return;
-  }
-
-  if (data_fetcher_.get() && data_fetcher_->is_active() &&
-      URLsAreForTheSamePage(data_fetcher_->validated_url(), validated_url) &&
-      !is_debug_mode) {
+    ReportError(contents, NOT_IN_MAIN_FRAME);
+    return;
+  }
+
+  // Don't start a redundant banner request.
+  if (is_active_ &&
+      URLsAreForTheSamePage(validated_url, contents->GetLastCommittedURL())) {
     return;
   }
 
   // A secure origin is required to show banners, so exit early if we see the
   // URL is invalid.
   if (!content::IsOriginSecure(validated_url) &&
       !gDisableSecureCheckForTesting) {
-    OutputDeveloperNotShownMessage(contents, kNotServedFromSecureOrigin,
-                                   is_debug_mode);
-    return;
-  }
-
-  // Kick off the data retrieval pipeline.
-  data_fetcher_ =
-      CreateAppBannerDataFetcher(weak_factory_.GetWeakPtr(), is_debug_mode);
-  data_fetcher_->Start(validated_url, last_transition_type_);
-}
-
-void AppBannerManager::DidStartNavigation(
-    content::NavigationHandle* navigation_handle) {
-  if (!navigation_handle->IsInMainFrame())
+    ReportError(contents, NOT_FROM_SECURE_ORIGIN);
+    return;
+  }
+
+  is_debug_mode_ = is_debug_mode;
+  is_active_ = true;
+
+  // We start by requesting the manifest from the InstallableManager. The
+  // default-constructed params will have all other fields as false.
+  InstallableParams params;
+  manager_->GetData(

[benwells, 2016/08/09 03:41:26]

Now I've seen this API in use it seems a bit awkward. In particular the way
GetData is called twice, once just to get the manifest (with a callback
OnDidGetManifest) and a second time to do the check.

It would be nice if you could tell the difference between the two calls more
obviously, with callbacks which correspond to the calls more. Another niggle is
the name ContinueInstallation which doesn't communicate much about what
specifically it will do.

In a future patch (or this one if you feel like it) I'd consider thinking about
that. One simple thing to do would be to have some functions to get Params which
communicate what the GetData will do, e.g. GetData(ParamsToGetManifest(),
...OnDidGetManifest...) and GetData(ParamsToPerformCheck(),
...OnDidPerformCheck...). 

[dominickn, 2016/08/09 08:28:57]

Acknowledged. I'd like to defer bigger changes to the future, but one of the
reasons I designed the API like this was because banners alone had this
multiple-call thing going, with the split paths for native versus web banners on
mobile.

It was hard coming up with a name for ContinueInstallableCheck, because that's
the divergement point where the Android code goes and looks for a native app.
I'll have a think tonight and land this patch tomorrow after we've had a chance
to confer.

+      params, base::Bind(&AppBannerManager::OnDidGetManifest, GetWeakPtr()));
+}
+
+base::Closure AppBannerManager::FetchWebappSplashScreenImageCallback(
+    const std::string& webapp_id) {
+  return base::Closure();
+}
+
+AppBannerManager::AppBannerManager(content::WebContents* web_contents)
+    : content::WebContentsObserver(web_contents),
+      SiteEngagementObserver(nullptr),
+      manager_(nullptr),
+      event_request_id_(-1),
+      is_active_(false),
+      banner_request_queued_(false),
+      load_finished_(false),
+      was_canceled_by_page_(false),
+      page_requested_prompt_(false),
+      is_debug_mode_(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();
+}
+
+AppBannerManager::~AppBannerManager() { }
+
+std::string AppBannerManager::GetAppIdentifier() {
+  DCHECK(!manifest_.IsEmpty());
+  return manifest_.start_url.spec();
+}
+
+std::string AppBannerManager::GetBannerType() {
+  return "web";
+}
+
+std::string AppBannerManager::GetErrorParam(InstallableErrorCode code) {
+  if (code == NO_ACCEPTABLE_ICON || code == MANIFEST_MISSING_SUITABLE_ICON) {
+    return base::IntToString(InstallableManager::GetMinimumIconSizeInPx());
+  }
+
+  return std::string();
+}
+
+int AppBannerManager::GetIdealIconSizeInDp() {
+  return ConvertIconSizeFromPxToDp(
+      InstallableManager::GetMinimumIconSizeInPx());
+}
+
+int AppBannerManager::GetMinimumIconSizeInDp() {
+  return ConvertIconSizeFromPxToDp(
+      InstallableManager::GetMinimumIconSizeInPx());
+}
+
+base::WeakPtr<AppBannerManager> AppBannerManager::GetWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
+bool AppBannerManager::IsDebugMode() const {
+  return is_debug_mode_ ||
+         base::CommandLine::ForCurrentProcess()->HasSwitch(
+             switches::kBypassAppBannerEngagementChecks);
+}
+
+bool AppBannerManager::IsWebAppInstalled(
+    content::BrowserContext* browser_context,
+    const GURL& start_url) {
+  return false;
+}
+
+void AppBannerManager::OnDidGetManifest(const InstallableData& data) {
+  if (data.error_code != NO_ERROR_DETECTED) {
+    ReportError(web_contents(), data.error_code);
+    Stop();
+  }
+
+  if (!is_active_)
+    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();
+
+  ContinueInstallableCheck();
+}
+
+void AppBannerManager::ContinueInstallableCheck() {
+  if (IsWebAppInstalled(web_contents()->GetBrowserContext(),
+                        manifest_.start_url) &&
+      !IsDebugMode()) {
+    Stop();
+  }
+
+  if (!is_active_)
+    return;
+
+  // Fetch and verify the other required information.
+  manager_->GetData(
+      GetWebAppParams(GetIdealIconSizeInDp(), GetMinimumIconSizeInDp()),
+      base::Bind(&AppBannerManager::OnDidFinishInstallableCheck, GetWeakPtr()));
+}
+
+void AppBannerManager::OnDidFinishInstallableCheck(
+    const InstallableData& data) {
+  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);
+
+    ReportError(web_contents(), data.error_code);
+    Stop();
+  }
+
+  if (!is_active_)
+    return;
+
+  DCHECK(data.is_installable);
+  DCHECK(!data.icon_url.is_empty());
+  DCHECK(data.icon);
+
+  icon_url_ = data.icon_url;
+  icon_.reset(new SkBitmap(*data.icon));
+
+  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,
+      GetCurrentTime());
+  rappor::SampleDomainAndRegistryFromGURL(g_browser_process->rappor_service(),
+                                          event_name,
+                                          contents->GetLastCommittedURL());
+}
+
+void AppBannerManager::ReportError(content::WebContents* web_contents,
+                                   InstallableErrorCode code) {
+  if (IsDebugMode())
+    LogErrorToConsole(web_contents, code, GetErrorParam(code));
+}
+
+void AppBannerManager::Stop() {
+  if (was_canceled_by_page_ && !page_requested_prompt_) {
+    TrackBeforeInstallEvent(
+        BEFORE_INSTALL_EVENT_PROMPT_NOT_CALLED_AFTER_PREVENT_DEFAULT);
+  }
+
+  is_active_ = false;
+  was_canceled_by_page_ = false;
+  page_requested_prompt_ = false;
+  referrer_.erase();
+}
+
+void AppBannerManager::SendBannerPromptRequest() {
+  RecordCouldShowBanner();
+
+  // Given all of the other checks that have been made, the only possible reason
+  // for stopping now is that the app has been added to the homescreen.
+  if (!IsDebugMode() && !CheckIfShouldShowBanner())
+    Stop();
+
+  if (!is_active_)
+    return;
+
+  TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_CREATED);
+  event_request_id_ = ++gCurrentRequestID;
+  content::RenderFrameHost* frame = web_contents()->GetMainFrame();
+  frame->Send(new ChromeViewMsg_AppBannerPromptRequest(
+      frame->GetRoutingID(), event_request_id_, GetBannerType()));
+}
+
+void AppBannerManager::DidStartNavigation(content::NavigationHandle* handle) {
+  if (!handle->IsInMainFrame())
     return;
 
   load_finished_ = false;
   if (AppBannerSettingsHelper::ShouldUseSiteEngagementScore() &&
       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())));
   }
 }
 
-void AppBannerManager::DidFinishNavigation(
-    content::NavigationHandle* navigation_handle) {
-  if (navigation_handle->HasCommitted())
-    last_transition_type_ = navigation_handle->GetPageTransition();
+void AppBannerManager::DidFinishNavigation(content::NavigationHandle* handle) {
+  if (handle->IsInMainFrame() && handle->HasCommitted()) {
+    last_transition_type_ = handle->GetPageTransition();
+    active_media_players_.clear();
+    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;
   if (!AppBannerSettingsHelper::ShouldUseSiteEngagementScore() ||
       banner_request_queued_) {
     banner_request_queued_ = false;
 
-    // The third argument is the is_debug_mode boolean value, which is true only
-    // when it is triggered by the developer's action in DevTools.
     RequestAppBanner(validated_url, false /* is_debug_mode */);
   }
 }
 
 void AppBannerManager::MediaStartedPlaying(const MediaPlayerId& id) {
   active_media_players_.push_back(id);
 }
 
 void AppBannerManager::MediaStoppedPlaying(const MediaPlayerId& id) {
   active_media_players_.erase(std::remove(active_media_players_.begin(),
                                           active_media_players_.end(), id),
                               active_media_players_.end());
 }
 
-bool AppBannerManager::HandleNonWebApp(const std::string& platform,
-                                       const GURL& url,
-                                       const std::string& id,
-                                       bool is_debug_mode) {
-  return false;
+void AppBannerManager::WebContentsDestroyed() {
+  Stop();
 }
 
 void AppBannerManager::OnEngagementIncreased(content::WebContents* contents,
                                              const GURL& url,
                                              double score) {
   // 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);
 
     if (!load_finished_) {
       // Wait until the main frame finishes loading before requesting a banner.
       banner_request_queued_ = true;
     } else {
       // Requesting a banner 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.
       RequestAppBanner(url, false /* is_debug_mode */);
     }
   }
 }
 
-void AppBannerManager::CancelActiveFetcher() {
-  if (data_fetcher_) {
-    data_fetcher_->Cancel();
-    data_fetcher_ = nullptr;
+void AppBannerManager::RecordCouldShowBanner() {
+  content::WebContents* contents = web_contents();
+  DCHECK(contents);
+
+  AppBannerSettingsHelper::RecordBannerCouldShowEvent(
+      contents, validated_url_, GetAppIdentifier(),
+      GetCurrentTime(), last_transition_type_);
+}
+
+bool AppBannerManager::CheckIfShouldShowBanner() {
+  content::WebContents* contents = web_contents();
+  DCHECK(contents);
+
+  return AppBannerSettingsHelper::ShouldShowBanner(
+      contents, validated_url_, GetAppIdentifier(), GetCurrentTime());
+}
+
+bool AppBannerManager::OnMessageReceived(
+    const IPC::Message& message,
+    content::RenderFrameHost* render_frame_host) {
+  bool handled = true;
+
+  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(AppBannerManager, message, render_frame_host)
+    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_AppBannerPromptReply,
+                        OnBannerPromptReply)
+    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_RequestShowAppBanner,
+                        OnRequestShowAppBanner)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+
+  return handled;
+}
+
+void AppBannerManager::OnBannerPromptReply(
+    content::RenderFrameHost* render_frame_host,
+    int request_id,
+    blink::WebAppBannerPromptReply reply,
+    std::string referrer) {
+  content::WebContents* contents = web_contents();
+  if (request_id != event_request_id_)
+    return;
+
+  // 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::WebAppBannerPromptReply::Cancel &&
+      !page_requested_prompt_) {
+    TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_PREVENT_DEFAULT_CALLED);
+    was_canceled_by_page_ = true;
+    ReportError(contents, RENDERER_CANCELLED);
+    return;
+  }
+
+  // If we haven't yet returned, but either of |was_canceled_by_page_| 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_) {
+    TrackBeforeInstallEvent(
+        BEFORE_INSTALL_EVENT_PROMPT_CALLED_AFTER_PREVENT_DEFAULT);
+    was_canceled_by_page_ = false;
+  } else {
+    TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_NO_ACTION);
+  }
+
+  AppBannerSettingsHelper::RecordMinutesFromFirstVisitToShow(
+      contents, validated_url_, GetAppIdentifier(), GetCurrentTime());
+
+  DCHECK(!manifest_url_.is_empty());
+  DCHECK(!manifest_.IsEmpty());
+  DCHECK(!icon_url_.is_empty());
+  DCHECK(icon_.get());
+  TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_COMPLETE);
+  ShowBanner();
+  is_active_ = false;
+}
+
+void AppBannerManager::OnRequestShowAppBanner(
+    content::RenderFrameHost* render_frame_host,
+    int request_id) {
+  if (was_canceled_by_page_) {
+    // Simulate a non-canceled OnBannerPromptReply to show the delayed banner.
+    // Don't reset |was_canceled_by_page_| yet for metrics purposes.
+    OnBannerPromptReply(render_frame_host, request_id,
+                        blink::WebAppBannerPromptReply::None, referrer_);
+  } else {
+    // Log that the prompt request was made for when we get the prompt reply.
+    page_requested_prompt_ = true;
   }
 }
 
 }  // namespace banners