Use exact pixel sizes instead of dip in webapp/WebAPK installability code

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 <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 11 matching lines @@
 #include "chrome/common/web_application_info.h"
 #include "components/dom_distiller/core/url_utils.h"
 #include "components/favicon/core/favicon_service.h"
 #include "components/favicon_base/favicon_types.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/manifest.h"
 #include "third_party/WebKit/public/platform/modules/screen_orientation/WebScreenOrientationLockType.h"
-#include "ui/display/display.h"
-#include "ui/display/screen.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/favicon_size.h"
 #include "url/gurl.h"
 
 namespace {
 
 // Looks up the original, online URL of the site requested.  The URL from the
 // WebContents may be a distilled article which is not appropriate for a home
 // screen shortcut.
 GURL GetShortcutUrl(content::BrowserContext* browser_context,
                     const GURL& actual_url) {
   return dom_distiller::url_utils::GetOriginalUrlFromDistillerUrl(actual_url);
 }
 
-InstallableParams ParamsToPerformInstallableCheck(int ideal_icon_size_in_dp,
-                                                  int minimum_icon_size_in_dp,
+InstallableParams ParamsToPerformInstallableCheck(int ideal_icon_size_in_px,
+                                                  int minimum_icon_size_in_px,
                                                   bool check_installable) {
   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.ideal_icon_size_in_px = ideal_icon_size_in_px;
+  params.minimum_icon_size_in_px = minimum_icon_size_in_px;
   params.check_installable = check_installable;
   params.fetch_valid_icon = true;
   return params;
 }
 
 }  // namespace
 
 AddToHomescreenDataFetcher::AddToHomescreenDataFetcher(
     content::WebContents* web_contents,
-    int ideal_icon_size_in_dp,
-    int minimum_icon_size_in_dp,
-    int ideal_splash_image_size_in_dp,
-    int minimum_splash_image_size_in_dp,
+    int ideal_icon_size_in_px,
+    int minimum_icon_size_in_px,
+    int ideal_splash_image_size_in_px,
+    int minimum_splash_image_size_in_px,
     bool check_webapk_compatibility,
     Observer* observer)
     : WebContentsObserver(web_contents),
       weak_observer_(observer),
       shortcut_info_(GetShortcutUrl(web_contents->GetBrowserContext(),
                                     web_contents->GetLastCommittedURL())),
       data_timeout_timer_(false, false),
-      ideal_icon_size_in_dp_(ideal_icon_size_in_dp),
-      minimum_icon_size_in_dp_(minimum_icon_size_in_dp),
-      ideal_splash_image_size_in_dp_(ideal_splash_image_size_in_dp),
-      minimum_splash_image_size_in_dp_(minimum_splash_image_size_in_dp),
+      ideal_icon_size_in_px_(ideal_icon_size_in_px),
+      minimum_icon_size_in_px_(minimum_icon_size_in_px),
+      ideal_splash_image_size_in_px_(ideal_splash_image_size_in_px),
+      minimum_splash_image_size_in_px_(minimum_splash_image_size_in_px),
       check_webapk_compatibility_(check_webapk_compatibility),
       is_waiting_for_web_application_info_(true),
       is_installable_check_complete_(false),
       is_icon_saved_(false),
       is_ready_(false) {
-  DCHECK(minimum_icon_size_in_dp <= ideal_icon_size_in_dp);
-  DCHECK(minimum_splash_image_size_in_dp <= ideal_splash_image_size_in_dp);
+  DCHECK(minimum_icon_size_in_px <= ideal_icon_size_in_px);
+  DCHECK(minimum_splash_image_size_in_px <= ideal_splash_image_size_in_px);
 
   // Send a message to the renderer to retrieve information about the page.
   Send(new ChromeViewMsg_GetWebApplicationInfo(routing_id()));
 }
 
 base::Closure AddToHomescreenDataFetcher::FetchSplashScreenImageCallback(
     const std::string& webapp_id) {
   return base::Bind(&ShortcutHelper::FetchSplashScreenImage, web_contents(),
-                    splash_screen_url_, ideal_splash_image_size_in_dp_,
-                    minimum_splash_image_size_in_dp_, webapp_id);
+                    splash_screen_url_, ideal_splash_image_size_in_px_,
+                    minimum_splash_image_size_in_px_, webapp_id);
 }
 
 void AddToHomescreenDataFetcher::OnDidGetWebApplicationInfo(
     const WebApplicationInfo& received_web_app_info) {
   is_waiting_for_web_application_info_ = false;
   if (!web_contents() || !weak_observer_)
     return;
 
   // Sanitize received_web_app_info.
   WebApplicationInfo web_app_info = received_web_app_info;
@@ skipping 35 matching lines @@
       InstallableManager::FromWebContents(web_contents());
   DCHECK(manager);
 
   // Kick off a timeout for downloading data. If we haven't finished within the
   // timeout, fall back to using a dynamically-generated launcher icon.
   data_timeout_timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(4000),
       base::Bind(&AddToHomescreenDataFetcher::OnDataTimedout, this));
 
   manager->GetData(
-      ParamsToPerformInstallableCheck(ideal_icon_size_in_dp_,
-                                      minimum_icon_size_in_dp_,
+      ParamsToPerformInstallableCheck(ideal_icon_size_in_px_,
+                                      minimum_icon_size_in_px_,
                                       check_webapk_compatibility_),
       base::Bind(&AddToHomescreenDataFetcher::OnDidPerformInstallableCheck,
                  this));
 }
 
 AddToHomescreenDataFetcher::~AddToHomescreenDataFetcher() {
   DCHECK(!weak_observer_);
 }
 
 bool AddToHomescreenDataFetcher::OnMessageReceived(
@@ skipping 43 matching lines @@
 
   if (!data.manifest.IsEmpty()) {
     content::RecordAction(
         base::UserMetricsAction("webapps.AddShortcut.Manifest"));
     shortcut_info_.UpdateFromManifest(data.manifest);
     shortcut_info_.manifest_url = data.manifest_url;
   }
 
   // Save the splash screen URL for the later download.
   splash_screen_url_ = ManifestIconSelector::FindBestMatchingIcon(
-      data.manifest.icons, ideal_splash_image_size_in_dp_,
-      minimum_splash_image_size_in_dp_);
+      data.manifest.icons, ideal_splash_image_size_in_px_,
+      minimum_splash_image_size_in_px_);
 
   weak_observer_->OnUserTitleAvailable(shortcut_info_.user_title);
 
   if (data.icon) {
     shortcut_info_.best_icon_url = data.icon_url;
 
     CreateLauncherIcon(*(data.icon));
     return;
   }
 
@@ skipping 11 matching lines @@
       favicon_base::FAVICON,
       favicon_base::TOUCH_PRECOMPOSED_ICON | favicon_base::TOUCH_ICON};
 
   favicon::FaviconService* favicon_service =
       FaviconServiceFactory::GetForProfile(
           Profile::FromBrowserContext(web_contents()->GetBrowserContext()),
           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 ideal_icon_size_in_px =
-      ideal_icon_size_in_dp_ *
-      display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor();
-  int threshold_to_get_any_largest_icon = ideal_icon_size_in_px - 1;
+  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) {
   if (!web_contents() || !weak_observer_ || is_icon_saved_)
     return;
@@ skipping 52 matching lines @@
 void AddToHomescreenDataFetcher::NotifyObserver(const SkBitmap& icon) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!web_contents() || !weak_observer_ || is_icon_saved_)
     return;
 
   is_icon_saved_ = true;
   shortcut_icon_ = icon;
   is_ready_ = true;
   weak_observer_->OnDataAvailable(shortcut_info_, shortcut_icon_);
 }