Use apple-touch-icons for streamlined hosted apps.

chrome/browser/extensions/tab_helper.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/tab_helper.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 45 matching lines @@
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/frame_navigate_params.h"
 #include "extensions/browser/extension_error.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_resource.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/feature_switch.h"
+#include "skia/ext/image_operations.h"
 #include "ui/gfx/image/image.h"
 
 using content::NavigationController;
 using content::NavigationEntry;
 using content::RenderViewHost;
 using content::WebContents;
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(extensions::TabHelper);
 
 namespace extensions {
 
 TabHelper::ScriptExecutionObserver::ScriptExecutionObserver(
     TabHelper* tab_helper)
     : tab_helper_(tab_helper) {
   tab_helper_->AddScriptExecutionObserver(this);
 }
 
 TabHelper::ScriptExecutionObserver::ScriptExecutionObserver()
     : tab_helper_(NULL) {
 }
 
 TabHelper::ScriptExecutionObserver::~ScriptExecutionObserver() {
   if (tab_helper_)
     tab_helper_->RemoveScriptExecutionObserver(this);
 }
 
+// static
+std::vector<SkBitmap> TabHelper::ConstrainBitmapsToSizes(
+    const std::vector<SkBitmap>& bitmaps,
+    const std::set<int>& sizes) {
+  std::vector<SkBitmap> output_bitmaps;
+  std::map<int, SkBitmap> ordered_bitmaps;
+  for (std::vector<SkBitmap>::const_iterator it = bitmaps.begin();
+       it != bitmaps.end(); ++it) {
+    DCHECK(it->width() == it->height());
+    ordered_bitmaps[it->width()] = *it;
+  }
+
+  std::set<int>::const_iterator sizes_it = sizes.begin();
+  std::map<int, SkBitmap>::const_iterator bitmaps_it = ordered_bitmaps.begin();
+  while (sizes_it != sizes.end() && bitmaps_it != ordered_bitmaps.end()) {
+    int size = *sizes_it;
+    // Find the closest not-smaller bitmap.
+    bitmaps_it = ordered_bitmaps.lower_bound(size);
+    ++sizes_it;
+    // Ensure the bitmap is valid and smaller than the next allowed size.
+    if (bitmaps_it != ordered_bitmaps.end() &&
+        (sizes_it == sizes.end() || bitmaps_it->second.width() < *sizes_it)) {
+      // Resize the bitmap if it does not exactly match the desired size.
+      output_bitmaps.push_back(bitmaps_it->second.width() == size
+          ? bitmaps_it->second
+          : skia::ImageOperations::Resize(
+                bitmaps_it->second, skia::ImageOperations::RESIZE_LANCZOS3,
+                size, size));
+    }
+  }
+  return output_bitmaps;
+}
+
 TabHelper::TabHelper(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       extension_app_(NULL),
       extension_function_dispatcher_(
           Profile::FromBrowserContext(web_contents->GetBrowserContext()), this),
       pending_web_app_action_(NONE),
       script_executor_(new ScriptExecutor(web_contents,
                                           &script_execution_observers_)),
       image_loader_ptr_factory_(this),
       webstore_inline_installer_factory_(new WebstoreInlineInstallerFactory()) {
@@ skipping 215 matching lines @@
     install_info.app_url = web_contents()->GetURL();
 
   if (install_info.title.empty())
     install_info.title = web_contents()->GetTitle();
   if (install_info.title.empty())
     install_info.title = base::UTF8ToUTF16(install_info.app_url.spec());
 
   install_info.urls.push_back(install_info.app_url);
   install_info.is_bookmark_app = true;
 
-  // Add the downloaded icons.
+  // Add the downloaded icons. Extensions only allow certain icon sizes. First
+  // populate icons that match the allowed sizes exactly and then downscale
+  // remaining icons to the closest allowed size that doesn't yet have an icon.
+  std::set<int> allowed_sizes(
+      extension_misc::kExtensionIconSizes,
+      extension_misc::kExtensionIconSizes +
+          extension_misc::kNumExtensionIconSizes);
+  std::vector<SkBitmap> downloaded_icons;
   for (FaviconDownloader::FaviconMap::const_iterator map_it = bitmaps.begin();
        map_it != bitmaps.end(); ++map_it) {
     for (std::vector<SkBitmap>::const_iterator bitmap_it =
              map_it->second.begin();
          bitmap_it != map_it->second.end(); ++bitmap_it) {
-      if (!bitmap_it->empty()) {
-        WebApplicationInfo::IconInfo icon_info;
-        icon_info.data = *bitmap_it;
-        icon_info.width = icon_info.data.width();
-        icon_info.height = icon_info.data.height();
-        install_info.icons.push_back(icon_info);
-      }
+      if (bitmap_it->empty() || bitmap_it->width() != bitmap_it->height())

[benwells, 2014/01/07 07:03:49]

What happens if there are multiple icons available of the same size?

[calamity, 2014/01/08 23:08:23]

They'll end up getting de-duped when being inserted into the map in
ConstrainBitmapsToSizes(), taking the last bitmap in the vector of that size
(which will be the last bitmap in the FaviconMap which is URL keyed).

+        continue;
+
+      downloaded_icons.push_back(*bitmap_it);
     }
   }
 
+  // If there are icons that don't match the accepted icon sizes, find the
+  // closest bigger icon to the accepted sizes and resize the icon to it. An
+  // icon will be resized and used for at most one size.
+  std::vector<SkBitmap> resized_bitmaps(
+      TabHelper::ConstrainBitmapsToSizes(downloaded_icons,
+                                         allowed_sizes));
+  for (std::vector<SkBitmap>::const_iterator resized_bitmaps_it =
+           resized_bitmaps.begin();
+       resized_bitmaps_it != resized_bitmaps.end(); ++resized_bitmaps_it) {
+    WebApplicationInfo::IconInfo icon_info;
+    icon_info.data = *resized_bitmaps_it;
+    icon_info.width = icon_info.data.width();
+    icon_info.height = icon_info.data.height();
+    install_info.icons.push_back(icon_info);
+  }
+
   Profile* profile =
       Profile::FromBrowserContext(web_contents()->GetBrowserContext());
   scoped_refptr<extensions::CrxInstaller> installer(
       extensions::CrxInstaller::CreateSilent(profile->GetExtensionService()));
   installer->set_error_on_unsupported_requirements(true);
   installer->InstallWebApp(install_info);
   favicon_downloader_.reset();
 }
 
 void TabHelper::DidCloneToNewWebContents(WebContents* old_web_contents,
@@ skipping 283 matching lines @@
   }
 }
 
 void TabHelper::SetTabId(RenderViewHost* render_view_host) {
   render_view_host->Send(
       new ExtensionMsg_SetTabId(render_view_host->GetRoutingID(),
                                 SessionID::IdForTab(web_contents())));
 }
 
 }  // namespace extensions