Pass in extra parameters to WebApkBuilder#buildWebApkAsync()

chrome/browser/banners/app_banner_data_fetcher.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_data_fetcher.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 184 matching lines @@
     return;
   }
 
   AppBannerSettingsHelper::RecordMinutesFromFirstVisitToShow(
       web_contents, validated_url_, GetAppIdentifier(), GetCurrentTime());
 
   // Definitely going to show the banner now.
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnDecidedWhetherToShow(this, true));
 
-  ShowBanner(app_icon_.get(), app_title_, referrer);
+  ShowBanner(app_icon_url_, app_icon_.get(), app_title_, referrer);
   is_active_ = false;
 }
 
 void AppBannerDataFetcher::OnRequestShowAppBanner(
     content::RenderFrameHost* render_frame_host,
     int request_id) {
   if (was_canceled_by_page_) {
     // Simulate an "OK" from the website to restart the banner display pipeline.
     was_canceled_by_page_ = false;
     OnBannerPromptReply(render_frame_host, request_id,
@@ skipping 12 matching lines @@
   return "web";
 }
 
 content::WebContents* AppBannerDataFetcher::GetWebContents() {
   if (!web_contents() || web_contents()->IsBeingDestroyed())
     return nullptr;
   return web_contents();
 }
 
 std::string AppBannerDataFetcher::GetAppIdentifier() {
-  DCHECK(!web_app_data_.IsEmpty());
-  return web_app_data_.start_url.spec();
+  DCHECK(!manifest_.IsEmpty());
+  return manifest_.start_url.spec();
 }
 
 void AppBannerDataFetcher::RecordDidShowBanner(const std::string& event_name) {
   content::WebContents* web_contents = GetWebContents();
   DCHECK(web_contents);
 
   AppBannerSettingsHelper::RecordBannerEvent(
       web_contents, validated_url_, GetAppIdentifier(),
       AppBannerSettingsHelper::APP_BANNER_EVENT_DID_SHOW,
       GetCurrentTime());
@@ skipping 11 matching lines @@
 
     Cancel();
     return;
   }
 
   web_contents->GetManifest(
       base::Bind(&AppBannerDataFetcher::OnDidGetManifest, this));
 }
 
 void AppBannerDataFetcher::OnDidGetManifest(
+    const GURL& manifest_url,
     const content::Manifest& manifest) {
   content::WebContents* web_contents = GetWebContents();
   if (!CheckFetcherIsStillAlive(web_contents)) {
     Cancel();
     return;
   }
   if (manifest.IsEmpty()) {
     OutputDeveloperNotShownMessage(web_contents, kManifestEmpty,
                                    is_debug_mode_);
     Cancel();
@@ skipping 11 matching lines @@
     }
   }
 
   if (!IsManifestValidForWebApp(manifest, web_contents, is_debug_mode_)) {
     Cancel();
     return;
   }
 
   // Since the manifest is valid, one of short name or name must be non-null.
   // Prefer name if it isn't null.
-  web_app_data_ = manifest;
-  app_title_ = (web_app_data_.name.is_null())
-                   ? web_app_data_.short_name.string()
-                   : web_app_data_.name.string();
+  manifest_url_ = manifest_url;
+  manifest_ = manifest;
+  app_title_ = (manifest_.name.is_null()) ? manifest_.short_name.string()
+                                          : manifest_.name.string();
 
   if (IsWebAppInstalled(web_contents->GetBrowserContext(),
                         manifest.start_url) &&
       !is_debug_mode_) {
     Cancel();
     return;
   }
 
   banners::TrackDisplayEvent(DISPLAY_EVENT_WEB_APP_BANNER_REQUESTED);
 
@@ skipping 27 matching lines @@
     Cancel();
     return;
   }
 
   OnHasServiceWorker(web_contents);
 }
 
 void AppBannerDataFetcher::OnHasServiceWorker(
     content::WebContents* web_contents) {
   GURL icon_url = ManifestIconSelector::FindBestMatchingIcon(
-      web_app_data_.icons, ideal_icon_size_in_dp_, minimum_icon_size_in_dp_);
+      manifest_.icons, ideal_icon_size_in_dp_, minimum_icon_size_in_dp_);
 
   if (icon_url.is_empty()) {
     OutputDeveloperNotShownMessage(
         web_contents,
         kNoIconMatchingRequirements,
         base::IntToString(ManifestIconSelector::ConvertIconSizeFromDpToPx(
             minimum_icon_size_in_dp_)),
         is_debug_mode_);
     Cancel();
   } else if (!FetchAppIcon(web_contents, icon_url)) {
     OutputDeveloperNotShownMessage(web_contents, kCannotDownloadIcon,
                                    is_debug_mode_);
     Cancel();
   }
 }
 
 bool AppBannerDataFetcher::FetchAppIcon(content::WebContents* web_contents,
                                         const GURL& icon_url) {
+  app_icon_url_ = icon_url;
   return ManifestIconDownloader::Download(
-      web_contents,
-      icon_url,
-      ideal_icon_size_in_dp_,
-      minimum_icon_size_in_dp_,
-      base::Bind(&AppBannerDataFetcher::OnAppIconFetched,
-                 this));
+      web_contents, icon_url, ideal_icon_size_in_dp_, minimum_icon_size_in_dp_,
+      base::Bind(&AppBannerDataFetcher::OnAppIconFetched, this));
 }
 
 void AppBannerDataFetcher::OnAppIconFetched(const SkBitmap& bitmap) {
   if (!is_active_) return;
 
   content::WebContents* web_contents = GetWebContents();
   if (!CheckFetcherIsStillAlive(web_contents)) {
     Cancel();
     return;
   }
@@ skipping 90 matching lines @@
 
   if (!DoesManifestContainRequiredIcon(manifest)) {
     OutputDeveloperNotShownMessage(web_contents, kManifestMissingSuitableIcon,
                                    is_debug_mode);
     return false;
   }
   return true;
 }
 
 }  // namespace banners