Resized the icon in the Uninstall dialog to be 64x64 px

chrome/browser/extensions/extension_install_prompt.cc

 // Copyright (c) 2012 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/extensions/extension_install_prompt.h"
 
 #include <map>
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 101 matching lines @@
         IDS_EXTENSION_PROMPT_WILL_HAVE_ACCESS_TO,
         IDS_EXTENSION_PROMPT_THESE_WILL_HAVE_ACCESS_TO,
         IDS_EXTENSION_PROMPT_WILL_NOW_HAVE_ACCESS_TO,
         IDS_EXTENSION_PROMPT_WANTS_ACCESS_TO,
         IDS_EXTENSION_PROMPT_WILL_HAVE_ACCESS_TO,
         IDS_EXTENSION_PROMPT_CAN_ACCESS,
         IDS_EXTENSION_PROMPT_WILL_HAVE_ACCESS_TO,
         IDS_EXTENSION_PROMPT_WILL_HAVE_ACCESS_TO,
 };
 
-// Size of extension icon in top left of dialog.
-const int kIconSize = 69;
-
-// Returns pixel size under maximal scale factor for the icon whose device
-// independent size is |size_in_dip|
-int GetSizeForMaxScaleFactor(int size_in_dip) {
-  return static_cast<int>(size_in_dip * gfx::ImageSkia::GetMaxSupportedScale());
-}
-
 // Returns bitmap for the default icon with size equal to the default icon's
 // pixel size under maximal supported scale factor.
 SkBitmap GetDefaultIconBitmapForMaxScaleFactor(bool is_app) {
   const gfx::ImageSkia& image = is_app ?
       extensions::util::GetDefaultAppIcon() :
       extensions::util::GetDefaultExtensionIcon();
   return image.GetRepresentation(
       gfx::ImageSkia::GetMaxSupportedScale()).sk_bitmap();
 }
 
@@ skipping 542 matching lines @@
 }
 
 void ExtensionInstallPrompt::LoadImageIfNeeded() {
   // Bundle install prompts do not have an icon.
   // Also |install_ui_.profile()| can be NULL in unit tests.
   if (!icon_.empty() || !install_ui_->profile()) {
     ShowConfirmation();
     return;
   }
 
-  // Load the image asynchronously. For the response, check OnImageLoaded.
   extensions::ExtensionResource image = extensions::IconsInfo::GetIconResource(
       extension_,
       extension_misc::EXTENSION_ICON_LARGE,
       ExtensionIconSet::MATCH_BIGGER);
-  // Load the icon whose pixel size is large enough to be displayed under
-  // maximal supported scale factor. UI code will scale the icon down if needed.
-  // TODO(tbarzic): We should use IconImage here and load the required bitmap
-  //     lazily.
-  int pixel_size = GetSizeForMaxScaleFactor(kIconSize);
-  extensions::ImageLoader::Get(install_ui_->profile())->LoadImageAsync(
-      extension_, image, gfx::Size(pixel_size, pixel_size),
+
+  // Load the image asynchronously. The response will be sent to OnImageLoaded.
+  extensions::ImageLoader* loader =
+      extensions::ImageLoader::Get(install_ui_->profile());
+
+  std::vector<extensions::ImageLoader::ImageRepresentation> images_list;
+  images_list.push_back(extensions::ImageLoader::ImageRepresentation(
+      image,
+      extensions::ImageLoader::ImageRepresentation::NEVER_RESIZE,

[benwells, 2014/06/02 06:07:02]

Sorry if you've already been asked these questions, but what happens with the
NEVER_RESIZE if there is not an appropriate image?

[sashab, 2014/06/03 01:17:32]

If there is no appropriate image, OnImageLoaded() is called with an empty image.
This then causes SetIcon() to be called with NULL, which  then loads the default
icon for the app/extension.

+      gfx::Size(),
+      ui::SCALE_FACTOR_100P));

[benwells, 2014/06/02 06:07:02]

What does this scale factor mean exactly? In particular what happens on hi dpi
devices?

[sashab, 2014/06/03 01:17:32]

If you look at ImageLoader::LoadImageAsync() (the function that was being called
before), this is just an expansion of this function so that we can use
NEVER_RESIZE instead of RESIZE_WHEN_LARGER for the second argument. So although
I'm not answering your question, this behaviour matches the previous behaviour.

Now, to answer your question - I'm not totally 100% confident with my knowledge
of this DPI stuff, but from what I understand this enum is saying 'load the NxN
image and display at NxN pixels'. If I passed SCALE_FACTOR_200P, it would say
'load this NxN image and display it at 2Nx2N pixels', which would effectively
stretch it by 2X but because it's a 200% DPI display, it would appear as the
same *actual* size. You could imagine a chromebook, for example, where doubling
the resolution didn't actually change the size of anything, it just increased
the *resolution*, making edges smoother and corners rounder. I think that's
where this is trying to head - where you actually pass the scale factor of the
display in here, and it displays it accordingly.

Unfortunately, there's no easy way to get the 'DPI' of a display since you could
have two monitors, each with a different DPI, and you can even drag one window
between monitors and stuff like that. But we can get a good estimate of the DPI,
and you can see that in ResourceBundle::InitSharedInstance(). Basically,
especially on Windows, we are just picking a target DPI that looks nice so that
when we re-size images, they don't look too blurry.

Update: After talking to calamity@, this SCALE_FACTOR_100P is passed to
ImageSkia as 'choose the image with this DPI'. Since we are just using ImageSkia
as an image container for a single image, and not properly using it to load
images for each DPI and then choose the correct one with the given DPI at
runtime, we should only ever pass SCALE_FACTOR_100P since there will only be one
image in our ImageSkia, and it will have this DPI. For apps and extensions,
since we want to display the app's actual icon wherever possible (and not our
default icon), we always want to choose the app's icon, no matter what DPI
display the user has.

I think the proper fix here would be to go through all the icons an app has for
our target resolution, assign each one to a DPI, and then actually choose an
icon that best matches the target display. However, since we don't provide apps
with a way to specify DPI (and only a way to specify resolution), there is a lot
more work to be done before we can 'smart' choose app icons for high DPI
monitors.

Long story short: this is a hack.

+  loader->LoadImagesAsync(
+      extension_,
+      images_list,
       base::Bind(&ExtensionInstallPrompt::OnImageLoaded, AsWeakPtr()));
 }
 
 void ExtensionInstallPrompt::ShowConfirmation() {
   if (prompt_.type() == INSTALL_PROMPT)
     prompt_.set_experiment(ExtensionInstallPromptExperiment::Find());
   else
     prompt_.set_experiment(ExtensionInstallPromptExperiment::ControlGroup());
 
   if (permissions_.get() &&
@@ skipping 33 matching lines @@
   }
 
   if (AutoConfirmPrompt(delegate_))
     return;
 
   if (show_dialog_callback_.is_null())
     GetDefaultShowDialogCallback().Run(show_params_, delegate_, prompt_);
   else
     show_dialog_callback_.Run(show_params_, delegate_, prompt_);
 }