Move 'theme' parsing out of Extension class

chrome/common/extensions/extension.cc

 // Copyright (c) 2013 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/common/extensions/extension.h"
 
 #include <ostream>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 23 matching lines @@
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/extensions/features/base_feature_provider.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/manifest_handler_helpers.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
 #include "chrome/common/extensions/permissions/permissions_info.h"
+#include "chrome/common/extensions/theme_handler.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/url_constants.h"
 #include "crypto/sha2.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/url_pattern_set.h"
 #include "googleurl/src/url_util.h"
 #include "grit/chromium_strings.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 836 matching lines @@
   // TODO(viettrungluu): These |FilePath::FromWStringHack(UTF8ToWide())|
   // indicate that we're doing something wrong.
 
   // Extension icons.
   for (ExtensionIconSet::IconMap::const_iterator iter = icons().map().begin();
        iter != icons().map().end(); ++iter) {
     image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(iter->second)));
   }
 
   // Theme images.
-  DictionaryValue* theme_images = GetThemeImages();
+  DictionaryValue* theme_images = ThemeInfo::GetThemeImages(this);
   if (theme_images) {
     for (DictionaryValue::Iterator it(*theme_images); !it.IsAtEnd();
          it.Advance()) {
       std::string val;
       if (it.value().GetAsString(&val))
         image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(val)));
     }
   }
 
   if (page_action_info() && !page_action_info()->default_icon.empty()) {
@@ skipping 640 matching lines @@
 
   if (!LoadAppIsolation(api_permissions, error))
     return false;
 
   if (!LoadSharedFeatures(api_permissions, error))
     return false;
 
   if (!LoadExtensionFeatures(&api_permissions, error))
     return false;
 
-  if (!LoadThemeFeatures(error))
-    return false;
-
   if (!LoadManagedModeFeatures(error))
     return false;
 
   if (HasMultipleUISurfaces()) {
     *error = ASCIIToUTF16(errors::kOneUISurfaceOnly);
     return false;
   }
 
   finished_parsing_manifest_ = true;
 
@@ skipping 1049 matching lines @@
     // TODO(abarth): Should we continue to let extensions override the
     //               default Content-Security-Policy?
     content_security_policy_ = is_platform_app() ?
         kDefaultPlatformAppContentSecurityPolicy :
         kDefaultContentSecurityPolicy;
     CHECK(ContentSecurityPolicyIsSecure(content_security_policy_, GetType()));
   }
   return true;
 }
 
-bool Extension::LoadThemeFeatures(string16* error) {
-  if (!manifest_->HasKey(keys::kTheme))
-    return true;
-  DictionaryValue* theme_value = NULL;
-  if (!manifest_->GetDictionary(keys::kTheme, &theme_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidTheme);
-    return false;
-  }
-  if (!LoadThemeImages(theme_value, error))
-    return false;
-  if (!LoadThemeColors(theme_value, error))
-    return false;
-  if (!LoadThemeTints(theme_value, error))
-    return false;
-  if (!LoadThemeDisplayProperties(theme_value, error))
-    return false;
-
-  return true;
-}
-
-bool Extension::LoadThemeImages(const DictionaryValue* theme_value,
-                                string16* error) {
-  const DictionaryValue* images_value = NULL;
-  if (theme_value->GetDictionary(keys::kThemeImages, &images_value)) {
-    // Validate that the images are all strings
-    for (DictionaryValue::Iterator iter(*images_value); !iter.IsAtEnd();
-         iter.Advance()) {
-      std::string val;
-      if (!iter.value().GetAsString(&val)) {
-        *error = ASCIIToUTF16(errors::kInvalidThemeImages);
-        return false;
-      }
-    }
-    theme_images_.reset(images_value->DeepCopy());
-  }
-  return true;
-}
-
-bool Extension::LoadThemeColors(const DictionaryValue* theme_value,
-                                string16* error) {
-  const DictionaryValue* colors_value = NULL;
-  if (theme_value->GetDictionary(keys::kThemeColors, &colors_value)) {
-    // Validate that the colors are RGB or RGBA lists
-    for (DictionaryValue::Iterator iter(*colors_value); !iter.IsAtEnd();
-         iter.Advance()) {
-      const ListValue* color_list = NULL;
-      double alpha = 0.0;
-      int color = 0;
-      // The color must be a list
-      if (!iter.value().GetAsList(&color_list) ||
-          // And either 3 items (RGB) or 4 (RGBA)
-          ((color_list->GetSize() != 3) &&
-           ((color_list->GetSize() != 4) ||
-            // For RGBA, the fourth item must be a real or int alpha value.
-            // Note that GetDouble() can get an integer value.
-            !color_list->GetDouble(3, &alpha))) ||
-          // For both RGB and RGBA, the first three items must be ints (R,G,B)
-          !color_list->GetInteger(0, &color) ||
-          !color_list->GetInteger(1, &color) ||
-          !color_list->GetInteger(2, &color)) {
-        *error = ASCIIToUTF16(errors::kInvalidThemeColors);
-        return false;
-      }
-    }
-    theme_colors_.reset(colors_value->DeepCopy());
-  }
-  return true;
-}
-
-bool Extension::LoadThemeTints(const DictionaryValue* theme_value,
-                               string16* error) {
-  const DictionaryValue* tints_value = NULL;
-  if (!theme_value->GetDictionary(keys::kThemeTints, &tints_value))
-    return true;
-
-  // Validate that the tints are all reals.
-  for (DictionaryValue::Iterator iter(*tints_value); !iter.IsAtEnd();
-       iter.Advance()) {
-    const ListValue* tint_list = NULL;
-    double v = 0.0;
-    if (!iter.value().GetAsList(&tint_list) ||
-        tint_list->GetSize() != 3 ||
-        !tint_list->GetDouble(0, &v) ||
-        !tint_list->GetDouble(1, &v) ||
-        !tint_list->GetDouble(2, &v)) {
-      *error = ASCIIToUTF16(errors::kInvalidThemeTints);
-      return false;
-    }
-  }
-  theme_tints_.reset(tints_value->DeepCopy());
-  return true;
-}
-
-bool Extension::LoadThemeDisplayProperties(const DictionaryValue* theme_value,
-                                           string16* error) {
-  const DictionaryValue* display_properties_value = NULL;
-  if (theme_value->GetDictionary(keys::kThemeDisplayProperties,
-                                 &display_properties_value)) {
-    theme_display_properties_.reset(
-        display_properties_value->DeepCopy());
-  }
-  return true;
-}
 SkBitmap* Extension::GetCachedImageImpl(const ExtensionResource& source,
                                         const gfx::Size& max_size) const {
   const FilePath& path = source.relative_path();
 
   // Look for exact size match.
   ImageCache::iterator i = image_cache_.find(
       ImageCacheKey(path, SizeToString(max_size)));
   if (i != image_cache_.end())
     return &(i->second);
 
@@ skipping 468 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions