webapps: initial addition of splash screen icon downloading

chrome/browser/android/webapps/add_to_homescreen_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/android/webapps/add_to_homescreen_data_fetcher.h"
 
 #include "base/basictypes.h"
 #include "base/location.h"
 #include "base/strings/string16.h"
 #include "base/task/cancelable_task_tracker.h"
+#include "chrome/browser/android/shortcut_helper.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/manifest/manifest_icon_downloader.h"
 #include "chrome/browser/manifest/manifest_icon_selector.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/web_application_info.h"
 #include "components/dom_distiller/core/url_utils.h"
 #include "components/favicon/core/favicon_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/frame_navigate_params.h"
 #include "content/public/common/manifest.h"
 #include "third_party/WebKit/public/platform/modules/screen_orientation/WebScreenOrientationLockType.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/screen.h"
 #include "url/gurl.h"
 
 using content::Manifest;
 
-// Android's preferred icon size in DP is 48, as defined in
-// http://developer.android.com/design/style/iconography.html
-const int AddToHomescreenDataFetcher::kPreferredIconSizeInDp = 48;
-
 AddToHomescreenDataFetcher::AddToHomescreenDataFetcher(
     content::WebContents* web_contents,
+    int ideal_icon_size_in_dp,
+    int ideal_splash_icon_size_in_dp,
     Observer* observer)
     : WebContentsObserver(web_contents),
       weak_observer_(observer),
       is_waiting_for_web_application_info_(false),
       is_icon_saved_(false),
       is_ready_(false),
       icon_timeout_timer_(false, false),
       shortcut_info_(dom_distiller::url_utils::GetOriginalUrlFromDistillerUrl(
                      web_contents->GetURL())),
-      preferred_icon_size_in_px_(kPreferredIconSizeInDp *
-          gfx::Screen::GetScreenFor(web_contents->GetNativeView())->
-              GetPrimaryDisplay().device_scale_factor()) {
+      ideal_icon_size_in_dp_(ideal_icon_size_in_dp),
+      ideal_splash_icon_size_in_dp_(ideal_splash_icon_size_in_dp) {
   // Send a message to the renderer to retrieve information about the page.
   is_waiting_for_web_application_info_ = true;
   Send(new ChromeViewMsg_GetWebApplicationInfo(routing_id()));
 }
 
 void AddToHomescreenDataFetcher::OnDidGetWebApplicationInfo(
     const WebApplicationInfo& received_web_app_info) {
   is_waiting_for_web_application_info_ = false;
   if (!web_contents() || !weak_observer_) return;
 
@@ skipping 33 matching lines @@
   }
 
   web_contents()->GetManifest(
       base::Bind(&AddToHomescreenDataFetcher::OnDidGetManifest, this));
 }
 
 void AddToHomescreenDataFetcher::OnDidGetManifest(
     const content::Manifest& manifest) {
   if (!web_contents() || !weak_observer_) return;
 
+  manifest_ = manifest;
   if (!manifest.IsEmpty()) {
       content::RecordAction(
           base::UserMetricsAction("webapps.AddShortcut.Manifest"));
       shortcut_info_.UpdateFromManifest(manifest);
   }
 
   GURL icon_src = ManifestIconSelector::FindBestMatchingIcon(
       manifest.icons,
-      kPreferredIconSizeInDp,
+      ideal_icon_size_in_dp_,
       gfx::Screen::GetScreenFor(web_contents()->GetNativeView()));
 
   // If fetching the Manifest icon fails, fallback to the best favicon
   // for the page.
   if (!ManifestIconDownloader::Download(
         web_contents(),
         icon_src,
-        kPreferredIconSizeInDp,
+        ideal_icon_size_in_dp_,
         base::Bind(&AddToHomescreenDataFetcher::OnManifestIconFetched,
                    this))) {
     FetchFavicon();
   }
 
   weak_observer_->OnUserTitleAvailable(shortcut_info_.user_title);
 
   // Kick off a timeout for downloading the icon.  If an icon isn't set within
   // the timeout, fall back to using a dynamically-generated launcher icon.
   icon_timeout_timer_.Start(FROM_HERE,
@@ skipping 16 matching lines @@
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 AddToHomescreenDataFetcher::~AddToHomescreenDataFetcher() {
   DCHECK(!weak_observer_);
 }
 
+void AddToHomescreenDataFetcher::FetchSplashscreenIcon(const std::string& id) {
+  if (manifest_.IsEmpty())
+    return;
+
+  GURL icon_src = ManifestIconSelector::FindBestMatchingIcon(
+      manifest_.icons,
+      ideal_splash_icon_size_in_dp_,
+      gfx::Screen::GetScreenFor(web_contents()->GetNativeView()));
+
+  // This is a fire and forget task. It is not vital for the splashscreen icon
+  // to be downloaded so the result of the download is not checked and neither
+  // is there any fallback option.
+  ManifestIconDownloader::Download(
+        web_contents(),
+        icon_src,
+        ideal_splash_icon_size_in_dp_,
+        base::Bind(&ShortcutHelper::AddSplashscreenIconToWebappData,
+                   id));

[mlamouri (slow - plz ping), 2015/08/24 16:43:54]

nit: "id));" doesn't fit in the previous line?

[Lalit Maganti, 2015/08/25 11:38:44]

Changed to webapp_id which doesn't fit :/

+}
+
 void AddToHomescreenDataFetcher::FetchFavicon() {
   if (!web_contents() || !weak_observer_) return;
 
   Profile* profile =
       Profile::FromBrowserContext(web_contents()->GetBrowserContext());
 
   // Grab the best, largest icon we can find to represent this bookmark.
   // TODO(dfalcantara): Try combining with the new BookmarksHandler once its
   //                    rewrite is further along.
   std::vector<int> icon_types;
   icon_types.push_back(favicon_base::FAVICON);
   icon_types.push_back(favicon_base::TOUCH_PRECOMPOSED_ICON |
                        favicon_base::TOUCH_ICON);
   favicon::FaviconService* favicon_service =
       FaviconServiceFactory::GetForProfile(profile,
                                            ServiceAccessType::EXPLICIT_ACCESS);
 
   // Using favicon if its size is not smaller than platform required size,
   // otherwise using the largest icon among all avaliable icons.
-  int threshold_to_get_any_largest_icon = preferred_icon_size_in_px_ - 1;
+  int ideal_icon_size_in_px = ideal_icon_size_in_dp_ *
+      gfx::Screen::GetScreenFor(web_contents()->GetNativeView())->
+          GetPrimaryDisplay().device_scale_factor();
+  int threshold_to_get_any_largest_icon = ideal_icon_size_in_px - 1;
   favicon_service->GetLargestRawFaviconForPageURL(
       shortcut_info_.url,
       icon_types,
       threshold_to_get_any_largest_icon,
       base::Bind(&AddToHomescreenDataFetcher::OnFaviconFetched, this),
       &favicon_task_tracker_);
 }
 
 void AddToHomescreenDataFetcher::OnFaviconFetched(
     const favicon_base::FaviconRawBitmapResult& bitmap_result) {
@@ skipping 44 matching lines @@
 void AddToHomescreenDataFetcher::NotifyObserver(const SkBitmap& bitmap) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!web_contents() || !weak_observer_ || is_icon_saved_)
     return;
 
   is_icon_saved_ = true;
   shortcut_icon_ = bitmap;
   is_ready_ = true;
   weak_observer_->OnDataAvailable(shortcut_info_, shortcut_icon_);
 }