Remove dependency on ui::ScaleFactor from ui/gfx

chrome/browser/extensions/api/extension_action/extension_action_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_action_api.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/lazy_instance.h"
@@ skipping 82 matching lines @@
   // http://crbug.com/140546 is fixed.
   std::string raw_str;
   if (!base::Base64Decode(str, &raw_str))
     return false;
   IPC::Message bitmap_pickle(raw_str.data(), raw_str.size());
   PickleIterator iter(bitmap_pickle);
   return IPC::ReadParam(&bitmap_pickle, &iter, bitmap);
 }
 
 // Conversion function for reading/writing to storage.
-std::string RepresentationToString(const gfx::ImageSkia& image,
-                                   ui::ScaleFactor scale) {
+std::string RepresentationToString(const gfx::ImageSkia& image, float scale) {
   SkBitmap bitmap = image.GetRepresentation(scale).sk_bitmap();
   IPC::Message bitmap_pickle;
   // Clear the header values so they don't vary in serialization.
   bitmap_pickle.SetHeaderValues(0, 0, 0);
   IPC::WriteParam(&bitmap_pickle, bitmap);
   std::string raw_str(static_cast<const char*>(bitmap_pickle.data()),
                       bitmap_pickle.size());
   std::string base64_str;
   if (!base::Base64Encode(raw_str, &base64_str))
     return std::string();
@@ skipping 22 matching lines @@
   if (dict->GetInteger(kAppearanceStorageKey, &int_value))
     action->SetAppearance(kTabId,
                           static_cast<ExtensionAction::Appearance>(int_value));
 
   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));
+        float scale = ui::GetImageScale(kIconSizes[i].scale);
+        icon.AddRepresentation(gfx::ImageSkiaRep(bitmap, scale));
       }
     }
     action->SetIcon(kTabId, 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 kTabId = ExtensionAction::kDefaultTabId;
   scoped_ptr<base::DictionaryValue> dict(new base::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)) {
+      float scale = ui::GetImageScale(kIconSizes[i].scale);
+      if (icon.HasRepresentation(scale)) {
         icon_value->SetString(
             kIconSizes[i].size_string,
-            RepresentationToString(icon, kIconSizes[i].scale));
+            RepresentationToString(icon, scale));
       }
     }
     dict->Set(kIconStorageKey, icon_value);
   }
   return dict.Pass();
 }
 
 }  // namespace
 
 //
@@ skipping 500 matching lines @@
     gfx::ImageSkia icon;
     // Extract icon representations from the ImageDataSet dictionary.
     for (size_t i = 0; i < arraysize(kIconSizes); i++) {
       base::BinaryValue* binary;
       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));
+        float scale = ui::GetImageScale(kIconSizes[i].scale);
+        icon.AddRepresentation(gfx::ImageSkiaRep(bitmap, scale));
       }
     }
 
     extension_action_->SetIcon(tab_id_, gfx::Image(icon));
   } else if (details_->GetInteger("iconIndex", &icon_index)) {
     // Obsolete argument: ignore it.
     return true;
   } else {
     EXTENSION_FUNCTION_VALIDATE(false);
   }
@@ skipping 172 matching lines @@
   return true;
 }
 
 bool EnablePageActionsFunction::RunImpl() {
   return SetPageActionEnabled(true);
 }
 
 bool DisablePageActionsFunction::RunImpl() {
   return SetPageActionEnabled(false);
 }