Use LANCZOS3 resize algorithm to generate missing image reps for extension action icons.

chrome/browser/extensions/api/extension_action/extension_actions_api.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/api/extension_action/extension_actions_api.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/extension_action/extension_page_actions_api_constants.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/location_bar_controller.h"
 #include "chrome/browser/extensions/state_store.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
+#include "ui/gfx/image/image_skia_operations.h"
 
 namespace {
 
 const char kBrowserActionStorageKey[] = "browser_action";
 const char kPopupUrlStorageKey[] = "poupup_url";
 const char kTitleStorageKey[] = "title";
 const char kIconStorageKey[] = "icon";
 const char kBadgeTextStorageKey[] = "badge_text";
 const char kBadgeBackgroundColorStorageKey[] = "badge_background_color";
 const char kBadgeTextColorStorageKey[] = "badge_text_color";
@@ skipping 83 matching lines @@
 
   const base::DictionaryValue* icon_value = NULL;
   if (dict->GetDictionary(kIconStorageKey, &icon_value)) {
     for (size_t i = 0; i < arraysize(kIconSizes); i++) {
       if (icon_value->GetString(kIconSizes[i].size_string, &str_value) &&
           StringToSkBitmap(str_value, &bitmap)) {
         CHECK(!bitmap.isNull());
         icon.AddRepresentation(gfx::ImageSkiaRep(bitmap, kIconSizes[i].scale));
       }
     }
-    action->SetIcon(kTabId, gfx::Image(icon));
+
+    if (!icon.isNull()) {
+      gfx::ImageSkia final_icon =
+          gfx::ImageSkiaOperations::CreateImageWithCustomResizeMethod(
+              icon, skia::ImageOperations::RESIZE_LANCZOS3);
+      action->SetIcon(kTabId, gfx::Image(final_icon));
+    }
   }
 }
 
 // Store |action|'s default values in a DictionaryValue for use in storing to
 // disk.
 scoped_ptr<base::DictionaryValue> DefaultsToValue(ExtensionAction* action) {
   const int kTabId = ExtensionAction::kDefaultTabId;
   scoped_ptr<base::DictionaryValue> dict(new DictionaryValue());
 
   dict->SetString(kPopupUrlStorageKey, action->GetPopupUrl(kTabId).spec());
   dict->SetString(kTitleStorageKey, action->GetTitle(kTabId));
   dict->SetString(kBadgeTextStorageKey, action->GetBadgeText(kTabId));
   dict->SetString(kBadgeBackgroundColorStorageKey,
                   SkColorToRawString(action->GetBadgeBackgroundColor(kTabId)));
   dict->SetString(kBadgeTextColorStorageKey,
                   SkColorToRawString(action->GetBadgeTextColor(kTabId)));
   dict->SetInteger(kAppearanceStorageKey,
                    action->GetIsVisible(kTabId) ?
                        ExtensionAction::ACTIVE : ExtensionAction::INVISIBLE);
 
   gfx::ImageSkia icon = action->GetExplicitlySetIcon(kTabId);
   if (!icon.isNull()) {
     base::DictionaryValue* icon_value = new base::DictionaryValue();
     for (size_t i = 0; i < arraysize(kIconSizes); i++) {
-      if (icon.HasRepresentation(kIconSizes[i].scale)) {
-        icon_value->SetString(
-            kIconSizes[i].size_string,
-            RepresentationToString(icon, kIconSizes[i].scale));
-      }
+      icon_value->SetString(
+          kIconSizes[i].size_string,
+          RepresentationToString(icon, kIconSizes[i].scale));
     }
     dict->Set(kIconStorageKey, icon_value);
   }
   return dict.Pass();
 }
 
 }  // namespace
 
 namespace extensions {
 
@@ skipping 289 matching lines @@
       if (canvas_set->GetBinary(kIconSizes[i].size_string, &binary)) {
         IPC::Message pickle(binary->GetBuffer(), binary->GetSize());
         PickleIterator iter(pickle);
         SkBitmap bitmap;
         EXTENSION_FUNCTION_VALIDATE(IPC::ReadParam(&pickle, &iter, &bitmap));
         CHECK(!bitmap.isNull());
         icon.AddRepresentation(gfx::ImageSkiaRep(bitmap, kIconSizes[i].scale));
       }
     }
 
-    extension_action_->SetIcon(tab_id_, gfx::Image(icon));
+    gfx::ImageSkia final_icon =
+        gfx::ImageSkiaOperations::CreateImageWithCustomResizeMethod(
+            icon, skia::ImageOperations::RESIZE_LANCZOS3);
+    extension_action_->SetIcon(tab_id_, gfx::Image(final_icon));
   } else if (details_->GetInteger("iconIndex", &icon_index)) {
     // Obsolete argument: ignore it.
     return true;
   } else {
     EXTENSION_FUNCTION_VALIDATE(false);
   }
   NotifyChange();
   return true;
 }
 
@@ skipping 73 matching lines @@
 bool ExtensionActionGetBadgeBackgroundColorFunction::RunExtensionAction() {
   ListValue* list = new ListValue();
   SkColor color = extension_action_->GetBadgeBackgroundColor(tab_id_);
   list->Append(Value::CreateIntegerValue(SkColorGetR(color)));
   list->Append(Value::CreateIntegerValue(SkColorGetG(color)));
   list->Append(Value::CreateIntegerValue(SkColorGetB(color)));
   list->Append(Value::CreateIntegerValue(SkColorGetA(color)));
   SetResult(list);
   return true;
 }