Add trivial theming support in extensions....

chrome/browser/extensions/extension.cc

 // Copyright (c) 2006-2008 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.h"
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "net/base/net_util.h"
 #include "chrome/common/extensions/user_script.h"
+#include "chrome/common/resource_bundle.h"
 #include "chrome/common/url_constants.h"
 
 const char Extension::kManifestFilename[] = "manifest.json";
 
 const wchar_t* Extension::kContentScriptsKey = L"content_scripts";
 const wchar_t* Extension::kDescriptionKey = L"description";
 const wchar_t* Extension::kFormatVersionKey = L"format_version";
 const wchar_t* Extension::kIdKey = L"id";
 const wchar_t* Extension::kJsKey = L"js";
 const wchar_t* Extension::kMatchesKey = L"matches";
 const wchar_t* Extension::kNameKey = L"name";
 const wchar_t* Extension::kRunAtKey = L"run_at";
 const wchar_t* Extension::kVersionKey = L"version";
 const wchar_t* Extension::kZipHashKey = L"zip_hash";
 const wchar_t* Extension::kPluginsDirKey = L"plugins_dir";
+const wchar_t* Extension::kThemeKey = L"theme";
 
 const char* Extension::kRunAtDocumentStartValue = "document_start";
 const char* Extension::kRunAtDocumentEndValue = "document_end";
 
 // Extension-related error messages. Some of these are simple patterns, where a
 // '*' is replaced at runtime with a specific value. This is used instead of
 // printf because we want to unit test them and scanf is hard to make
 // cross-platform.
 const char* Extension::kInvalidContentScriptError =
     "Invalid value for 'content_scripts[*]'.";
@@ skipping 27 matching lines @@
     "Invalid value for 'content_scripts[*].run_at'.";
 const char* Extension::kInvalidVersionError =
     "Required value 'version' is missing or invalid.";
 const char* Extension::kInvalidZipHashError =
     "Required key 'zip_hash' is missing or invalid.";
 const char* Extension::kInvalidPluginsDirError =
     "Invalid value for 'plugins_dir'.";
 
 const size_t Extension::kIdSize = 20;  // SHA1 (160 bits) == 20 bytes
 
+Extension::Extension(const Extension& rhs) : 
+    path_(rhs.path_),
+    extension_url_(rhs.extension_url_),
+    id_(rhs.id_),
+    version_(new Version(*rhs.version_)),
+    name_(rhs.name_),
+    description_(rhs.description_),
+    content_scripts_(rhs.content_scripts_),
+    plugins_dir_(rhs.plugins_dir_),
+    zip_hash_(rhs.zip_hash_),
+    theme_paths_(rhs.theme_paths_) {
+}
+
 const std::string Extension::VersionString() const {
   return version_->GetString();
 }
 
 // static
 GURL Extension::GetResourceURL(const GURL& extension_url,
                                const std::string& relative_path) {
   DCHECK(extension_url.SchemeIs(chrome::kExtensionScheme));
   DCHECK(extension_url.path() == "/");
 
   GURL ret_val = GURL(extension_url.spec() + relative_path);
   DCHECK(StartsWithASCII(ret_val.spec(), extension_url.spec(), false));
 
   return ret_val;
 }
 
+FilePath Extension::GetThemeResourcePath(const int resource_id) {
+  std::wstring id = IntToWString(resource_id);
+  std::string path = theme_paths_[id];
+  if (path.size())
+    return path_.AppendASCII(path.c_str());
+  return FilePath();
+}
+
 // static
 FilePath Extension::GetResourcePath(const FilePath& extension_path,
                                     const std::string& relative_path) {
   // Build up a file:// URL and convert that back to a FilePath.  This avoids
   // URL encoding and path separator issues.
 
   // Convert the extension's root to a file:// URL.
   GURL extension_url = net::FilePathToFileURL(extension_path);
   if (!extension_url.is_valid())
     return FilePath();
@@ skipping 130 matching lines @@
   // Initialize plugins dir (optional).
   if (source.HasKey(kPluginsDirKey)) {
     std::string plugins_dir;
     if (!source.GetString(kPluginsDirKey, &plugins_dir)) {
       *error = kInvalidPluginsDirError;
       return false;
     }
     plugins_dir_ = path_.AppendASCII(plugins_dir);
   }
 
+  if (source.HasKey(kThemeKey)) {
+    DictionaryValue* dict_value;
+    if (source.GetDictionary(kThemeKey, &dict_value)) {
+      DictionaryValue::key_iterator iter = dict_value->begin_keys();
+      while (iter != dict_value->end_keys()) {
+        std::string val;
+        if (dict_value->GetString(*iter, &val)) {
+          std::wstring id = *iter;
+          theme_paths_[id] = val;
+        }
+        ++iter;
+      }
+      ResourceBundle::GetSharedInstance().SetThemeExtension(*this);
+    }
+  }
+
   // Initialize content scripts (optional).
   if (source.HasKey(kContentScriptsKey)) {
     ListValue* list_value;
     if (!source.GetList(kContentScriptsKey, &list_value)) {
       *error = kInvalidContentScriptsListError;
       return false;
     }
 
     for (size_t i = 0; i < list_value->GetSize(); ++i) {
       DictionaryValue* content_script;
@@ skipping 72 matching lines @@
       script.set_path(Extension::GetResourcePath(path(), file));
       script.set_url(Extension::GetResourceURL(url(), file));
 
       content_scripts_.push_back(script);
     }
   }
 
   return true;
 }