Update AppBannerManager & AppBannerManagerAndroid to request badge icon.

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/callback.h"
@@ skipping 11 matching lines @@
 #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"
 
 namespace {
 
-int gCurrentRequestID = -1;
-int gTimeDeltaInDaysForTesting = 0;
+const int kInvalidIdealBadgeIconSizeInPx = -1;
+
+int g_current_request_id = -1;

[dominickn, 2017/02/14 00:01:16]

The change to this is unrelated to this CL. Can you do it separately?

Additionally, I'm planning on removing the gCurrentRequestID in the future
anyway, so perhaps it's best to just leave this for now.

[F, 2017/02/14 19:22:42]

Done.

+int g_time_delta_in_days_for_testing = 0;
 
 InstallableParams ParamsToGetManifest() {
   return InstallableParams();
 }
 
 // Returns an InstallableParams object that requests all checks necessary for
 // a web app banner.
-InstallableParams ParamsToPerformInstallableCheck(int ideal_icon_size_in_px,
-                                                  int minimum_icon_size_in_px) {
+InstallableParams ParamsToPerformInstallableCheck(
+    int ideal_primary_icon_size_in_px,
+    int minimum_primary_icon_size_in_px,
+    int ideal_badge_icon_size_in_px) {
   InstallableParams params;
-  params.ideal_primary_icon_size_in_px = ideal_icon_size_in_px;
-  params.minimum_primary_icon_size_in_px = minimum_icon_size_in_px;
+  params.ideal_primary_icon_size_in_px = ideal_primary_icon_size_in_px;
+  params.minimum_primary_icon_size_in_px = minimum_primary_icon_size_in_px;
   params.check_installable = true;
   params.fetch_valid_primary_icon = true;
-
+  if (ideal_badge_icon_size_in_px != kInvalidIdealBadgeIconSizeInPx) {
+    params.fetch_valid_badge_icon = true;
+    params.ideal_badge_icon_size_in_px = ideal_badge_icon_size_in_px;
+    params.minimum_badge_icon_size_in_px = ideal_badge_icon_size_in_px;
+  }
   return params;
 }
 
 }  // anonymous namespace
 
 namespace banners {
 
 // static
 base::Time AppBannerManager::GetCurrentTime() {
   return base::Time::Now() +
-         base::TimeDelta::FromDays(gTimeDeltaInDaysForTesting);
+         base::TimeDelta::FromDays(g_time_delta_in_days_for_testing);
 }
 
 // static
 void AppBannerManager::SetTimeDeltaForTesting(int days) {
-  gTimeDeltaInDaysForTesting = days;
+  g_time_delta_in_days_for_testing = days;
 }
 
 // static
 void AppBannerManager::SetTotalEngagementToTrigger(double engagement) {
   AppBannerSettingsHelper::SetTotalEngagementToTrigger(engagement);
 }
 
 // static
 bool AppBannerManager::URLsAreForTheSamePage(const GURL& first,
                                              const GURL& second) {
@@ skipping 54 matching lines @@
 
 void AppBannerManager::OnInstall() {
   blink::mojom::InstallationServicePtr installation_service;
   web_contents()->GetMainFrame()->GetRemoteInterfaces()->GetInterface(
       mojo::MakeRequest(&installation_service));
   DCHECK(installation_service);
   installation_service->OnInstall();
 }
 
 void AppBannerManager::SendBannerAccepted(int request_id) {
-  if (request_id != gCurrentRequestID)
+  if (request_id != g_current_request_id)
     return;
 
   DCHECK(event_.is_bound());
   event_->BannerAccepted(GetBannerType());
 }
 
 void AppBannerManager::SendBannerDismissed(int request_id) {
-  if (request_id != gCurrentRequestID)
+  if (request_id != g_current_request_id)
     return;
 
   DCHECK(event_.is_bound());
   event_->BannerDismissed();
 }
 
 base::Closure AppBannerManager::FetchWebappSplashScreenImageCallback(
     const std::string& webapp_id) {
   return base::Closure();
 }
@@ skipping 32 matching lines @@
 }
 
 std::string AppBannerManager::GetStatusParam(InstallableStatusCode code) {
   if (code == NO_ACCEPTABLE_ICON || code == MANIFEST_MISSING_SUITABLE_ICON) {
     return base::IntToString(InstallableManager::GetMinimumIconSizeInPx());
   }
 
   return std::string();
 }
 
-int AppBannerManager::GetIdealIconSizeInPx() {
+int AppBannerManager::GetIdealPrimaryIconSizeInPx() {
   return InstallableManager::GetMinimumIconSizeInPx();
 }
 
-int AppBannerManager::GetMinimumIconSizeInPx() {
+int AppBannerManager::GetMinimumPrimaryIconSizeInPx() {
   return InstallableManager::GetMinimumIconSizeInPx();
 }
 
+int AppBannerManager::GetIdealBadgeIconSizeInPx() {
+  return kInvalidIdealBadgeIconSizeInPx;
+}
+
 base::WeakPtr<AppBannerManager> AppBannerManager::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 bool AppBannerManager::IsDebugMode() const {
   return is_debug_mode_ ||
          base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kBypassAppBannerEngagementChecks);
 }
 
@@ skipping 22 matching lines @@
                                           : manifest_.name.string();
 
   PerformInstallableCheck();
 }
 
 void AppBannerManager::PerformInstallableCheck() {
   if (!CheckIfShouldShowBanner())
     return;
 
   // Fetch and verify the other required information.
-  manager_->GetData(ParamsToPerformInstallableCheck(GetIdealIconSizeInPx(),
-                                                    GetMinimumIconSizeInPx()),
-                    base::Bind(&AppBannerManager::OnDidPerformInstallableCheck,
-                               GetWeakPtr()));
+  manager_->GetData(
+      ParamsToPerformInstallableCheck(GetIdealPrimaryIconSizeInPx(),
+                                      GetMinimumPrimaryIconSizeInPx(),
+                                      GetIdealBadgeIconSizeInPx()),
+      base::Bind(&AppBannerManager::OnDidPerformInstallableCheck,
+                 GetWeakPtr()));
 }
 
 void AppBannerManager::OnDidPerformInstallableCheck(
     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);
 
     ReportStatus(web_contents(), data.error_code);
     Stop();
   }
 
   if (!is_active_)
     return;
 
   DCHECK(data.is_installable);
   DCHECK(!data.primary_icon_url.is_empty());
   DCHECK(data.primary_icon);
 
-  icon_url_ = data.primary_icon_url;
-  icon_.reset(new SkBitmap(*data.primary_icon));
+  primary_icon_url_ = data.primary_icon_url;
+  primary_icon_.reset(new SkBitmap(*data.primary_icon));
+
+  if (data.badge_icon) {
+    DCHECK(!data.badge_icon_url.is_empty());
+
+    badge_icon_url_ = data.badge_icon_url;
+    badge_icon_.reset(new SkBitmap(*data.badge_icon));
+  }
 
   SendBannerPromptRequest();
 }
 
 void AppBannerManager::RecordDidShowBanner(const std::string& event_name) {
   content::WebContents* contents = web_contents();
   DCHECK(contents);
 
   AppBannerSettingsHelper::RecordBannerEvent(
       contents, validated_url_, GetAppIdentifier(),
@@ skipping 46 matching lines @@
   is_active_ = false;
   was_canceled_by_page_ = false;
   page_requested_prompt_ = false;
   need_to_log_status_ = false;
 }
 
 void AppBannerManager::SendBannerPromptRequest() {
   RecordCouldShowBanner();
 
   TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_CREATED);
-  event_request_id_ = ++gCurrentRequestID;
+  event_request_id_ = ++g_current_request_id;
 
   web_contents()->GetMainFrame()->GetRemoteInterfaces()->GetInterface(
       mojo::MakeRequest(&controller_));
 
   controller_->BannerPromptRequest(
       binding_.CreateInterfacePtrAndBind(), mojo::MakeRequest(&event_),
       {GetBannerType()},
       base::Bind(&AppBannerManager::OnBannerPromptReply, GetWeakPtr()));
 }
 
@@ skipping 162 matching lines @@
     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());
+  DCHECK(!primary_icon_url_.is_empty());
+  DCHECK(primary_icon_.get());
 
   TrackBeforeInstallEvent(BEFORE_INSTALL_EVENT_COMPLETE);
   ShowBanner();
   is_active_ = false;
 }
 
 void AppBannerManager::DisplayAppBanner() {
   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(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