Handle more scale factors for extension Browser Action icons

chrome/browser/extensions/extension_action_storage_manager.cc

 // Copyright 2014 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_action_storage_manager.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 57 matching lines @@
   if (!base::Base64Decode(str, &raw_str))
     return false;
 
   bool success = gfx::PNGCodec::Decode(
       reinterpret_cast<unsigned const char*>(raw_str.data()), raw_str.size(),
       bitmap);
   return success;
 }
 
 // Conversion function for reading/writing to storage.
-std::string RepresentationToString(const gfx::ImageSkia& image, float scale) {
-  SkBitmap bitmap = image.GetRepresentation(scale).sk_bitmap();
+std::string BitmapToString(const SkBitmap& bitmap) {
   SkAutoLockPixels lock_image(bitmap);
   std::vector<unsigned char> data;
   bool success = gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, false, &data);
   if (!success)
     return std::string();
 
   base::StringPiece raw_str(
       reinterpret_cast<const char*>(&data[0]), data.size());
   std::string base64_str;
   base::Base64Encode(raw_str, &base64_str);
   return base64_str;
 }
 
 // Set |action|'s default values to those specified in |dict|.
 void SetDefaultsFromValue(const base::DictionaryValue* dict,
                           ExtensionAction* action) {
   const int kDefaultTabId = ExtensionAction::kDefaultTabId;
   std::string str_value;
-  int int_value;
-  SkBitmap bitmap;
-  gfx::ImageSkia icon;
 
   // For each value, don't set it if it has been modified already.
   if (dict->GetString(kPopupUrlStorageKey, &str_value) &&
       !action->HasPopupUrl(kDefaultTabId)) {
     action->SetPopupUrl(kDefaultTabId, GURL(str_value));
   }
   if (dict->GetString(kTitleStorageKey, &str_value) &&
       !action->HasTitle(kDefaultTabId)) {
     action->SetTitle(kDefaultTabId, str_value);
   }
   if (dict->GetString(kBadgeTextStorageKey, &str_value) &&
       !action->HasBadgeText(kDefaultTabId)) {
     action->SetBadgeText(kDefaultTabId, str_value);
   }
   if (dict->GetString(kBadgeBackgroundColorStorageKey, &str_value) &&
       !action->HasBadgeBackgroundColor(kDefaultTabId)) {
     action->SetBadgeBackgroundColor(kDefaultTabId,
                                     RawStringToSkColor(str_value));
   }
   if (dict->GetString(kBadgeTextColorStorageKey, &str_value) &&
       !action->HasBadgeTextColor(kDefaultTabId)) {
     action->SetBadgeTextColor(kDefaultTabId, RawStringToSkColor(str_value));
   }
-  if (dict->GetInteger(kAppearanceStorageKey, &int_value) &&
+
+  int appearance_storage = 0;
+  if (dict->GetInteger(kAppearanceStorageKey, &appearance_storage) &&
       !action->HasIsVisible(kDefaultTabId)) {
-    switch (int_value) {
+    switch (appearance_storage) {
       case INVISIBLE:
       case OBSOLETE_WANTS_ATTENTION:
         action->SetIsVisible(kDefaultTabId, false);
         break;
       case ACTIVE:
         action->SetIsVisible(kDefaultTabId, true);
         break;
     }
   }
 
   const base::DictionaryValue* icon_value = NULL;
   if (dict->GetDictionary(kIconStorageKey, &icon_value) &&
       !action->HasIcon(kDefaultTabId)) {
-    for (size_t i = 0; i < extension_misc::kNumExtensionActionIconSizes; i++) {
-      const extension_misc::IconRepresentationInfo& icon_info =
-          extension_misc::kExtensionActionIconSizes[i];
-      if (icon_value->GetString(icon_info.size_string, &str_value) &&
-          StringToSkBitmap(str_value, &bitmap)) {
+    gfx::ImageSkia icon;
+    SkBitmap bitmap;
+    for (base::DictionaryValue::Iterator iter(*icon_value); !iter.IsAtEnd();
+         iter.Advance()) {
+      int icon_size = 0;
+      std::string icon_string;
+      if (base::StringToInt(iter.key(), &icon_size) &&
+          iter.value().GetAsString(&icon_string) &&
+          StringToSkBitmap(icon_string, &bitmap)) {
         CHECK(!bitmap.isNull());
-        float scale = ui::GetScaleForScaleFactor(icon_info.scale);
+        float scale =
+            static_cast<float>(icon_size) / ExtensionAction::ActionIconSize();
         icon.AddRepresentation(gfx::ImageSkiaRep(bitmap, scale));
       }
     }
     action->SetIcon(kDefaultTabId, gfx::Image(icon));
   }
 }
 
 // Store |action|'s default values in a DictionaryValue for use in storing to
 // disk.
 scoped_ptr<base::DictionaryValue> DefaultsToValue(ExtensionAction* action) {
   const int kDefaultTabId = ExtensionAction::kDefaultTabId;
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
   dict->SetString(kPopupUrlStorageKey,
                   action->GetPopupUrl(kDefaultTabId).spec());
   dict->SetString(kTitleStorageKey, action->GetTitle(kDefaultTabId));
   dict->SetString(kBadgeTextStorageKey, action->GetBadgeText(kDefaultTabId));
   dict->SetString(
       kBadgeBackgroundColorStorageKey,
       SkColorToRawString(action->GetBadgeBackgroundColor(kDefaultTabId)));
   dict->SetString(kBadgeTextColorStorageKey,
                   SkColorToRawString(action->GetBadgeTextColor(kDefaultTabId)));
   dict->SetInteger(kAppearanceStorageKey,
                    action->GetIsVisible(kDefaultTabId) ? ACTIVE : INVISIBLE);
 
   gfx::ImageSkia icon =
       action->GetExplicitlySetIcon(kDefaultTabId).AsImageSkia();
   if (!icon.isNull()) {
     scoped_ptr<base::DictionaryValue> icon_value(new base::DictionaryValue());
-    for (size_t i = 0; i < extension_misc::kNumExtensionActionIconSizes; i++) {
-      const extension_misc::IconRepresentationInfo& icon_info =
-          extension_misc::kExtensionActionIconSizes[i];
-      float scale = ui::GetScaleForScaleFactor(icon_info.scale);
-      if (icon.HasRepresentation(scale)) {
-        icon_value->SetString(icon_info.size_string,
-                              RepresentationToString(icon, scale));
-      }
+    std::vector<gfx::ImageSkiaRep> image_reps = icon.image_reps();
+    for (const gfx::ImageSkiaRep& rep : image_reps) {
+      int size = static_cast<int>(rep.scale() * icon.width());
+      std::string size_string = base::IntToString(size);
+      icon_value->SetString(size_string, BitmapToString(rep.sk_bitmap()));
     }
-    dict->Set(kIconStorageKey, icon_value.release());
+    dict->Set(kIconStorageKey, icon_value.Pass());
   }
-  return dict.Pass();
+  return dict;
 }
 
 }  // namespace
 
 ExtensionActionStorageManager::ExtensionActionStorageManager(
     content::BrowserContext* context)
     : browser_context_(context),
       extension_action_observer_(this),
       extension_registry_observer_(this),
       weak_factory_(this) {
@@ skipping 73 matching lines @@
     return;
 
   SetDefaultsFromValue(dict, browser_action);
 }
 
 StateStore* ExtensionActionStorageManager::GetStateStore() {
   return ExtensionSystem::Get(browser_context_)->state_store();
 }
 
 }  // namespace extensions