Move ThemeHandler from c/c/e/api; move GetBrowserImages() out of Extension class

chrome/browser/themes/browser_theme_pack.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/themes/browser_theme_pack.h"
 
 #include <limits>
 
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/themes/theme_properties.h"
-#include "chrome/common/extensions/api/themes/theme_handler.h"
+#include "chrome/common/extensions/manifest_handlers/theme_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/common/id_util.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "net/base/file_stream.h"
 #include "net/base/net_errors.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/base/resource/data_pack.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
@@ skipping 506 matching lines @@
 
 // static
 scoped_refptr<BrowserThemePack> BrowserThemePack::BuildFromExtension(
     const Extension* extension) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(extension);
   DCHECK(extension->is_theme());
 
   scoped_refptr<BrowserThemePack> pack(new BrowserThemePack);
   pack->BuildHeader(extension);
-  pack->BuildTintsFromJSON(extensions::ThemeInfo::GetThemeTints(extension));
-  pack->BuildColorsFromJSON(extensions::ThemeInfo::GetThemeColors(extension));
+  pack->BuildTintsFromJSON(extensions::ThemeInfo::GetTints(extension));
+  pack->BuildColorsFromJSON(extensions::ThemeInfo::GetColors(extension));
   pack->BuildDisplayPropertiesFromJSON(
-      extensions::ThemeInfo::GetThemeDisplayProperties(extension));
+      extensions::ThemeInfo::GetDisplayProperties(extension));
 
   // Builds the images. (Image building is dependent on tints).
   FilePathMap file_paths;
   pack->ParseImageNamesFromJSON(
-      extensions::ThemeInfo::GetThemeImages(extension),
+      extensions::ThemeInfo::GetImages(extension),
       extension->path(),
       &file_paths);
   pack->BuildSourceImagesArray(file_paths);
 
   if (!pack->LoadRawBitmapsTo(file_paths, &pack->images_on_ui_thread_))
     return NULL;
 
   pack->CreateImages(&pack->images_on_ui_thread_);
 
   // Make sure the |images_on_file_thread_| has bitmaps for supported
@@ skipping 270 matching lines @@
 #elif defined(__BIG_ENDIAN__)
   // Mac check
   #error DataPack assumes little endian
 #endif
   header_->little_endian = 1;
 
   const std::string& id = extension->id();
   memcpy(header_->theme_id, id.c_str(), extensions::id_util::kIdSize);
 }
 
-void BrowserThemePack::BuildTintsFromJSON(DictionaryValue* tints_value) {
+void BrowserThemePack::BuildTintsFromJSON(
+    const base::DictionaryValue* tints_value) {
   tints_ = new TintEntry[kTintTableLength];
   for (size_t i = 0; i < kTintTableLength; ++i) {
     tints_[i].id = -1;
     tints_[i].h = -1;
     tints_[i].s = -1;
     tints_[i].l = -1;
   }
 
   if (!tints_value)
     return;
@@ skipping 24 matching lines @@
            temp_tints.begin();
        it != temp_tints.end() && count < kTintTableLength;
        ++it, ++count) {
     tints_[count].id = it->first;
     tints_[count].h = it->second.h;
     tints_[count].s = it->second.s;
     tints_[count].l = it->second.l;
   }
 }
 
-void BrowserThemePack::BuildColorsFromJSON(DictionaryValue* colors_value) {
+void BrowserThemePack::BuildColorsFromJSON(
+    const base::DictionaryValue* colors_value) {
   colors_ = new ColorPair[kColorTableLength];
   for (size_t i = 0; i < kColorTableLength; ++i) {
     colors_[i].id = -1;
     colors_[i].color = SkColorSetRGB(0, 0, 0);
   }
 
   std::map<int, SkColor> temp_colors;
   if (colors_value)
     ReadColorsFromJSON(colors_value, &temp_colors);
   GenerateMissingColors(&temp_colors);
 
   // Copy data from the intermediary data structure to the array.
   size_t count = 0;
   for (std::map<int, SkColor>::const_iterator it = temp_colors.begin();
        it != temp_colors.end() && count < kColorTableLength; ++it, ++count) {
     colors_[count].id = it->first;
     colors_[count].color = it->second;
   }
 }
 
 void BrowserThemePack::ReadColorsFromJSON(
-    DictionaryValue* colors_value,
+    const base::DictionaryValue* colors_value,
     std::map<int, SkColor>* temp_colors) {
   // Parse the incoming data from |colors_value| into an intermediary structure.
   for (DictionaryValue::Iterator iter(*colors_value); !iter.IsAtEnd();
        iter.Advance()) {
     const ListValue* color_list;
     if (iter.value().GetAsList(&color_list) &&
         ((color_list->GetSize() == 3) || (color_list->GetSize() == 4))) {
       SkColor color = SK_ColorWHITE;
       int r, g, b;
       if (color_list->GetInteger(0, &r) &&
@@ skipping 74 matching lines @@
             ThemeProperties::TINT_FRAME_INCOGNITO));
   }
   if (!colors->count(ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE)) {
     (*colors)[ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE] =
         HSLShift(frame, GetTintInternal(
             ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE));
   }
 }
 
 void BrowserThemePack::BuildDisplayPropertiesFromJSON(
-    DictionaryValue* display_properties_value) {
+    const base::DictionaryValue* display_properties_value) {
   display_properties_ = new DisplayPropertyPair[kDisplayPropertiesSize];
   for (size_t i = 0; i < kDisplayPropertiesSize; ++i) {
     display_properties_[i].id = -1;
     display_properties_[i].property = 0;
   }
 
   if (!display_properties_value)
     return;
 
   std::map<int, int> temp_properties;
@@ skipping 31 matching lines @@
   size_t count = 0;
   for (std::map<int, int>::const_iterator it = temp_properties.begin();
        it != temp_properties.end() && count < kDisplayPropertiesSize;
        ++it, ++count) {
     display_properties_[count].id = it->first;
     display_properties_[count].property = it->second;
   }
 }
 
 void BrowserThemePack::ParseImageNamesFromJSON(
-    DictionaryValue* images_value,
+    const base::DictionaryValue* images_value,
     const base::FilePath& images_path,
     FilePathMap* file_paths) const {
   if (!images_value)
     return;
 
   for (DictionaryValue::Iterator iter(*images_value); !iter.IsAtEnd();
        iter.Advance()) {
     std::string val;
     if (iter.value().GetAsString(&val)) {
       int id = GetPersistentIDByName(iter.key());
@@ skipping 286 matching lines @@
     ui::ScaleFactor scale_factor) const {
   if (prs_id < 0)
     return -1;
 
   for (size_t i = 0; i < scale_factors_.size(); ++i) {
     if (scale_factors_[i] == scale_factor)
       return static_cast<int>(kPersistingImagesLength * i) + prs_id;
   }
   return -1;
 }