#include "base/values.h"
#include "chrome/browser/themes/theme_properties.h"
#include "chrome/common/extensions/manifest_handlers/theme_handler.h"
+#include "components/crx_file/id_util.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 "third_party/skia/include/core/SkCanvas.h"
#include "ui/base/resource/data_pack.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/gfx/screen.h"
#include "ui/gfx/size_conversions.h"
#include "ui/gfx/skia_util.h"
+#include "ui/resources/grit/ui_resources.h"
using content::BrowserThread;
using extensions::Extension;
// Version number of the current theme pack. We just throw out and rebuild
// theme packs that aren't int-equal to this. Increment this number if you
// change default theme assets.
-const int kThemePackVersion = 33;
+const int kThemePackVersion = 35;
// IDs that are in the DataPack won't clash with the positive integer
// uint16. kHeaderID should always have the maximum value because we want the
// IDR_* resource names change whenever new resources are added; use persistent
// IDs when storing to a cached pack.
+//
+// TODO(erg): The cocoa port is the last user of the IDR_*_[HP] variants. These
+// should be removed once the cocoa port no longer uses them.
PersistingImagesTable kPersistingImages[] = {
{ PRS_THEME_FRAME, IDR_THEME_FRAME,
"theme_frame" },
"theme_toolbar" },
{ PRS_THEME_TAB_BACKGROUND, IDR_THEME_TAB_BACKGROUND,
"theme_tab_background" },
+#if !defined(OS_MACOSX)
{ PRS_THEME_TAB_BACKGROUND_INCOGNITO, IDR_THEME_TAB_BACKGROUND_INCOGNITO,
"theme_tab_background_incognito" },
+#endif
{ PRS_THEME_TAB_BACKGROUND_V, IDR_THEME_TAB_BACKGROUND_V,
"theme_tab_background_v"},
{ PRS_THEME_NTP_BACKGROUND, IDR_THEME_NTP_BACKGROUND,
};
const size_t kPersistingImagesLength = arraysize(kPersistingImages);
-#if defined(OS_WIN)
+#if defined(USE_ASH) && !defined(OS_CHROMEOS)
// Persistent theme ids for Windows.
-const int PRS_THEME_FRAME_WIN = 100;
-const int PRS_THEME_FRAME_INACTIVE_WIN = 101;
-const int PRS_THEME_FRAME_INCOGNITO_WIN = 102;
-const int PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN = 103;
-const int PRS_THEME_TOOLBAR_WIN = 104;
-const int PRS_THEME_TAB_BACKGROUND_WIN = 105;
-const int PRS_THEME_TAB_BACKGROUND_INCOGNITO_WIN = 106;
+const int PRS_THEME_FRAME_DESKTOP = 100;
+const int PRS_THEME_FRAME_INACTIVE_DESKTOP = 101;
+const int PRS_THEME_FRAME_INCOGNITO_DESKTOP = 102;
+const int PRS_THEME_FRAME_INCOGNITO_INACTIVE_DESKTOP = 103;
+const int PRS_THEME_TOOLBAR_DESKTOP = 104;
+const int PRS_THEME_TAB_BACKGROUND_DESKTOP = 105;
+const int PRS_THEME_TAB_BACKGROUND_INCOGNITO_DESKTOP = 106;
// Persistent theme to resource id mapping for Windows AURA.
-PersistingImagesTable kPersistingImagesWinDesktopAura[] = {
- { PRS_THEME_FRAME_WIN, IDR_THEME_FRAME_WIN,
+PersistingImagesTable kPersistingImagesDesktopAura[] = {
+ { PRS_THEME_FRAME_DESKTOP, IDR_THEME_FRAME_DESKTOP,
"theme_frame" },
- { PRS_THEME_FRAME_INACTIVE_WIN, IDR_THEME_FRAME_INACTIVE_WIN,
+ { PRS_THEME_FRAME_INACTIVE_DESKTOP, IDR_THEME_FRAME_INACTIVE_DESKTOP,
"theme_frame_inactive" },
- { PRS_THEME_FRAME_INCOGNITO_WIN, IDR_THEME_FRAME_INCOGNITO_WIN,
+ { PRS_THEME_FRAME_INCOGNITO_DESKTOP, IDR_THEME_FRAME_INCOGNITO_DESKTOP,
"theme_frame_incognito" },
- { PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN,
- IDR_THEME_FRAME_INCOGNITO_INACTIVE_WIN,
+ { PRS_THEME_FRAME_INCOGNITO_INACTIVE_DESKTOP,
+ IDR_THEME_FRAME_INCOGNITO_INACTIVE_DESKTOP,
"theme_frame_incognito_inactive" },
- { PRS_THEME_TOOLBAR_WIN, IDR_THEME_TOOLBAR_WIN,
+ { PRS_THEME_TOOLBAR_DESKTOP, IDR_THEME_TOOLBAR_DESKTOP,
"theme_toolbar" },
- { PRS_THEME_TAB_BACKGROUND_WIN, IDR_THEME_TAB_BACKGROUND_WIN,
+ { PRS_THEME_TAB_BACKGROUND_DESKTOP, IDR_THEME_TAB_BACKGROUND_DESKTOP,
"theme_tab_background" },
- { PRS_THEME_TAB_BACKGROUND_INCOGNITO_WIN,
- IDR_THEME_TAB_BACKGROUND_INCOGNITO_WIN,
+ { PRS_THEME_TAB_BACKGROUND_INCOGNITO_DESKTOP,
+ IDR_THEME_TAB_BACKGROUND_INCOGNITO_DESKTOP,
"theme_tab_background_incognito" },
};
-const size_t kPersistingImagesWinDesktopAuraLength =
- arraysize(kPersistingImagesWinDesktopAura);
+const size_t kPersistingImagesDesktopAuraLength =
+ arraysize(kPersistingImagesDesktopAura);
#endif
int GetPersistentIDByNameHelper(const std::string& key,
int prs_id = kPersistingImages[i].persistent_id;
(*lookup_table)[idr] = prs_id;
}
-#if defined(OS_WIN)
- for (size_t i = 0; i < kPersistingImagesWinDesktopAuraLength; ++i) {
- int idr = kPersistingImagesWinDesktopAura[i].idr_id;
- int prs_id = kPersistingImagesWinDesktopAura[i].persistent_id;
+#if defined(USE_ASH) && !defined(OS_CHROMEOS)
+ for (size_t i = 0; i < kPersistingImagesDesktopAuraLength; ++i) {
+ int idr = kPersistingImagesDesktopAura[i].idr_id;
+ int prs_id = kPersistingImagesDesktopAura[i].persistent_id;
(*lookup_table)[idr] = prs_id;
}
#endif
return (it == lookup_table->end()) ? -1 : it->second;
}
+// Returns the maximum persistent id.
+int GetMaxPersistentId() {
+ static int max_prs_id = -1;
+ if (max_prs_id == -1) {
+ for (size_t i = 0; i < kPersistingImagesLength; ++i) {
+ if (kPersistingImages[i].persistent_id > max_prs_id)
+ max_prs_id = kPersistingImages[i].persistent_id;
+ }
+#if defined(USE_ASH) && !defined(OS_CHROMEOS)
+ for (size_t i = 0; i < kPersistingImagesDesktopAuraLength; ++i) {
+ if (kPersistingImagesDesktopAura[i].persistent_id > max_prs_id)
+ max_prs_id = kPersistingImagesDesktopAura[i].persistent_id;
+ }
+#endif
+ }
+ return max_prs_id;
+}
+
// Returns true if the scales in |input| match those in |expected|.
// The order must match as the index is used in determining the raw id.
bool InputScalesValid(const base::StringPiece& input,
// Do a memcpy to avoid misaligned memory access.
memcpy(scales.get(), input.data(), input.size());
for (size_t index = 0; index < scales_size; ++index) {
- if (scales[index] != ui::GetImageScale(expected[index]))
+ if (scales[index] != ui::GetScaleForScaleFactor(expected[index]))
return false;
}
return true;
const std::vector<ui::ScaleFactor>& scale_factors) {
scoped_ptr<float[]> scales(new float[scale_factors.size()]);
for (size_t i = 0; i < scale_factors.size(); ++i)
- scales[i] = ui::GetImageScale(scale_factors[i]);
+ scales[i] = ui::GetScaleForScaleFactor(scale_factors[i]);
std::string out_string = std::string(
reinterpret_cast<const char*>(scales.get()),
scale_factors.size() * sizeof(float));
{ PRS_THEME_FRAME_INCOGNITO, ThemeProperties::TINT_FRAME_INCOGNITO },
{ PRS_THEME_FRAME_INCOGNITO_INACTIVE,
ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE },
-#if defined(OS_WIN)
- { PRS_THEME_FRAME_WIN, ThemeProperties::TINT_FRAME },
- { PRS_THEME_FRAME_INACTIVE_WIN, ThemeProperties::TINT_FRAME_INACTIVE },
- { PRS_THEME_FRAME_INCOGNITO_WIN, ThemeProperties::TINT_FRAME_INCOGNITO },
- { PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN,
+#if defined(USE_ASH) && !defined(OS_CHROMEOS)
+ { PRS_THEME_FRAME_DESKTOP, ThemeProperties::TINT_FRAME },
+ { PRS_THEME_FRAME_INACTIVE_DESKTOP, ThemeProperties::TINT_FRAME_INACTIVE },
+ { PRS_THEME_FRAME_INCOGNITO_DESKTOP, ThemeProperties::TINT_FRAME_INCOGNITO },
+ { PRS_THEME_FRAME_INCOGNITO_INACTIVE_DESKTOP,
ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE },
#endif
};
IntToIntTable kTabBackgroundMap[] = {
{ PRS_THEME_TAB_BACKGROUND, PRS_THEME_FRAME },
{ PRS_THEME_TAB_BACKGROUND_INCOGNITO, PRS_THEME_FRAME_INCOGNITO },
-#if defined(OS_WIN)
- { PRS_THEME_TAB_BACKGROUND_WIN, PRS_THEME_FRAME_WIN },
- { PRS_THEME_TAB_BACKGROUND_INCOGNITO_WIN, PRS_THEME_FRAME_INCOGNITO_WIN },
+#if defined(USE_ASH) && !defined(OS_CHROMEOS)
+ { PRS_THEME_TAB_BACKGROUND_DESKTOP, PRS_THEME_FRAME_DESKTOP },
+ { PRS_THEME_TAB_BACKGROUND_INCOGNITO_DESKTOP,
+ PRS_THEME_FRAME_INCOGNITO_DESKTOP },
#endif
};
{ PRS_THEME_TOOLBAR, 200, false },
{ PRS_THEME_BUTTON_BACKGROUND, 60, false },
{ PRS_THEME_WINDOW_CONTROL_BACKGROUND, 50, false },
-#if defined(OS_WIN)
- { PRS_THEME_TOOLBAR_WIN, 200, false }
+#if defined(USE_ASH) && !defined(OS_CHROMEOS)
+ { PRS_THEME_TOOLBAR_DESKTOP, 200, false }
#endif
};
gfx::Size scaled_size = gfx::ToCeiledSize(
gfx::ScaleSize(gfx::Size(source_bitmap.width(),
source_bitmap.height()),
- ui::GetImageScale(desired_scale_factor) /
- ui::GetImageScale(source_scale_factor)));
+ ui::GetScaleForScaleFactor(desired_scale_factor) /
+ ui::GetScaleForScaleFactor(source_scale_factor)));
SkBitmap scaled_bitmap;
- scaled_bitmap.setConfig(SkBitmap::kARGB_8888_Config,
- scaled_size.width(),
- scaled_size.height());
- if (!scaled_bitmap.allocPixels())
- SK_CRASH();
+ scaled_bitmap.allocN32Pixels(scaled_size.width(), scaled_size.height());
scaled_bitmap.eraseARGB(0, 0, 0, 0);
SkCanvas canvas(scaled_bitmap);
SkRect scaled_bounds = RectToSkRect(gfx::Rect(scaled_size));
public:
explicit ThemeImageSource(const gfx::ImageSkia& source) : source_(source) {
}
- virtual ~ThemeImageSource() {}
+ ~ThemeImageSource() override {}
- virtual gfx::ImageSkiaRep GetImageForScale(float scale) OVERRIDE {
+ gfx::ImageSkiaRep GetImageForScale(float scale) override {
if (source_.HasRepresentation(scale))
return source_.GetRepresentation(scale);
const gfx::ImageSkiaRep& rep_100p = source_.GetRepresentation(1.0f);
explicit ThemeImagePngSource(const PngMap& png_map) : png_map_(png_map) {}
- virtual ~ThemeImagePngSource() {}
+ ~ThemeImagePngSource() override {}
private:
- virtual gfx::ImageSkiaRep GetImageForScale(float scale) OVERRIDE {
+ gfx::ImageSkiaRep GetImageForScale(float scale) override {
ui::ScaleFactor scale_factor = ui::GetSupportedScaleFactor(scale);
// Look up the bitmap for |scale factor| in the bitmap map. If found
// return it.
for (PngMap::const_iterator png_it = png_map_.begin();
png_it != png_map_.end(); ++png_it) {
if (available_png_it == png_map_.end() ||
- ui::GetImageScale(png_it->first) >
- ui::GetImageScale(available_png_it->first)) {
+ ui::GetScaleForScaleFactor(png_it->first) >
+ ui::GetScaleForScaleFactor(available_png_it->first)) {
available_png_it = png_it;
}
}
vertical_offset_(vertical_offset) {
}
- virtual ~TabBackgroundImageSource() {
- }
+ ~TabBackgroundImageSource() override {}
// Overridden from CanvasImageSource:
- virtual void Draw(gfx::Canvas* canvas) OVERRIDE {
+ void Draw(gfx::Canvas* canvas) override {
gfx::ImageSkia bg_tint =
gfx::ImageSkiaOperations::CreateHSLShiftedImage(image_to_tint_,
hsl_shift_);
}
// TODO(erg): Check endianess once DataPack works on the other endian.
std::string theme_id(reinterpret_cast<char*>(pack->header_->theme_id),
- extensions::id_util::kIdSize);
- std::string truncated_id =
- expected_id.substr(0, extensions::id_util::kIdSize);
+ crx_file::id_util::kIdSize);
+ std::string truncated_id = expected_id.substr(0, crx_file::id_util::kIdSize);
if (theme_id != truncated_id) {
DLOG(ERROR) << "Wrong id: " << theme_id << " vs " << expected_id;
return NULL;
if (!InputScalesValid(pointer, pack->scale_factors_)) {
DLOG(ERROR) << "BuildFromDataPack failure! The pack scale factors differ "
<< "from those supported by platform.";
+ return NULL;
}
return pack;
}
for (size_t i = 0; i < kPersistingImagesLength; ++i)
result->insert(kPersistingImages[i].idr_id);
-#if defined(OS_WIN)
- for (size_t i = 0; i < kPersistingImagesWinDesktopAuraLength; ++i)
- result->insert(kPersistingImagesWinDesktopAura[i].idr_id);
+#if defined(USE_ASH) && !defined(OS_CHROMEOS)
+ for (size_t i = 0; i < kPersistingImagesDesktopAuraLength; ++i)
+ result->insert(kPersistingImagesDesktopAura[i].idr_id);
#endif
}
png_map[scale_factors_[i]] = memory;
}
if (!png_map.empty()) {
- gfx::ImageSkia image_skia(new ThemeImagePngSource(png_map),
- ui::SCALE_FACTOR_100P);
+ gfx::ImageSkia image_skia(new ThemeImagePngSource(png_map), 1.0f);
// |image_skia| takes ownership of ThemeImagePngSource.
gfx::Image ret = gfx::Image(image_skia);
images_on_ui_thread_[prs_id] = ret;
display_properties_(NULL),
source_images_(NULL) {
scale_factors_ = ui::GetSupportedScaleFactors();
+ // On Windows HiDPI SCALE_FACTOR_100P may not be supported by default.
+ if (std::find(scale_factors_.begin(), scale_factors_.end(),
+ ui::SCALE_FACTOR_100P) == scale_factors_.end()) {
+ scale_factors_.push_back(ui::SCALE_FACTOR_100P);
+ }
}
void BrowserThemePack::BuildHeader(const Extension* extension) {
header_->little_endian = 1;
const std::string& id = extension->id();
- memcpy(header_->theme_id, id.c_str(), extensions::id_util::kIdSize);
+ memcpy(header_->theme_id, id.c_str(), crx_file::id_util::kIdSize);
}
void BrowserThemePack::BuildTintsFromJSON(
if (tint_list->GetDouble(0, &hsl.h) &&
tint_list->GetDouble(1, &hsl.s) &&
tint_list->GetDouble(2, &hsl.l)) {
+ MakeHSLShiftValid(&hsl);
int id = GetIntForString(iter.key(), kTintTable, kTintTableLength);
if (id != -1) {
temp_tints[id] = hsl;
int id = GetPersistentIDByName(image_name);
if (id != -1)
(*file_paths)[id][scale_factor] = image_path;
-#if defined(OS_WIN)
+#if defined(USE_ASH) && !defined(OS_CHROMEOS)
id = GetPersistentIDByNameHelper(image_name,
- kPersistingImagesWinDesktopAura,
- kPersistingImagesWinDesktopAuraLength);
+ kPersistingImagesDesktopAura,
+ kPersistingImagesDesktopAuraLength);
if (id != -1)
(*file_paths)[id][scale_factor] = image_path;
#endif
&bitmap)) {
image_skia.AddRepresentation(
gfx::ImageSkiaRep(bitmap,
- ui::GetImageScale(scale_factor)));
+ ui::GetScaleForScaleFactor(scale_factor)));
} else {
NOTREACHED() << "Unable to decode theme image resource "
<< it->first;
// thing and just use the default images.
int prs_base_id = 0;
-#if defined(OS_WIN)
- if (prs_id == PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN) {
- prs_base_id = images->count(PRS_THEME_FRAME_INCOGNITO_WIN) ?
- PRS_THEME_FRAME_INCOGNITO_WIN : PRS_THEME_FRAME_WIN;
- } else if (prs_id == PRS_THEME_FRAME_INACTIVE_WIN) {
- prs_base_id = PRS_THEME_FRAME_WIN;
- } else if (prs_id == PRS_THEME_FRAME_INCOGNITO_WIN &&
- !images->count(PRS_THEME_FRAME_INCOGNITO_WIN)) {
- prs_base_id = PRS_THEME_FRAME_WIN;
+#if defined(USE_ASH) && !defined(OS_CHROMEOS)
+ if (prs_id == PRS_THEME_FRAME_INCOGNITO_INACTIVE_DESKTOP) {
+ prs_base_id = images->count(PRS_THEME_FRAME_INCOGNITO_DESKTOP) ?
+ PRS_THEME_FRAME_INCOGNITO_DESKTOP : PRS_THEME_FRAME_DESKTOP;
+ } else if (prs_id == PRS_THEME_FRAME_INACTIVE_DESKTOP) {
+ prs_base_id = PRS_THEME_FRAME_DESKTOP;
+ } else if (prs_id == PRS_THEME_FRAME_INCOGNITO_DESKTOP &&
+ !images->count(PRS_THEME_FRAME_INCOGNITO_DESKTOP)) {
+ prs_base_id = PRS_THEME_FRAME_DESKTOP;
}
#endif
if (!prs_base_id) {
} else if (prs_base_id != prs_id && images->count(prs_base_id)) {
frame = (*images)[prs_base_id];
} else if (prs_base_id == PRS_THEME_FRAME_OVERLAY) {
-#if defined(OS_WIN)
- if (images->count(PRS_THEME_FRAME_WIN)) {
+#if defined(USE_ASH) && !defined(OS_CHROMEOS)
+ if (images->count(PRS_THEME_FRAME_DESKTOP)) {
#else
if (images->count(PRS_THEME_FRAME)) {
#endif
// If the theme doesn't specify an image, then apply the tint to
// the default frame.
frame = rb.GetImageNamed(IDR_THEME_FRAME);
-#if defined(OS_WIN) && defined(USE_AURA)
- if (prs_id >= PRS_THEME_FRAME_WIN &&
- prs_id <= PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN) {
- frame = rb.GetImageNamed(IDR_THEME_FRAME_WIN);
+#if defined(USE_ASH) && !defined(OS_CHROMEOS)
+ if (prs_id >= PRS_THEME_FRAME_DESKTOP &&
+ prs_id <= PRS_THEME_FRAME_INCOGNITO_INACTIVE_DESKTOP) {
+ frame = rb.GetImageNamed(IDR_THEME_FRAME_DESKTOP);
}
#endif
}
void BrowserThemePack::RepackImages(const ImageCache& images,
RawImages* reencoded_images) const {
- typedef std::vector<ui::ScaleFactor> ScaleFactors;
for (ImageCache::const_iterator it = images.begin();
it != images.end(); ++it) {
gfx::ImageSkia image_skia = *it->second.ToImageSkia();
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 ((GetMaxPersistentId() + 1) * i) + prs_id;
}
return -1;
}
if (base::StringToInt(key, &percent)) {
float scale = static_cast<float>(percent) / 100.0f;
for (size_t i = 0; i < scale_factors_.size(); ++i) {
- if (fabs(ui::GetImageScale(scale_factors_[i]) - scale) < 0.001) {
+ if (fabs(ui::GetScaleForScaleFactor(scale_factors_[i]) - scale)
+ < 0.001) {
*scale_factor = scale_factors_[i];
return true;
}
for (size_t i = 0; i < scale_factors_.size(); ++i) {
int raw_id = GetRawIDByPersistentID(prs_id, scale_factors_[i]);
if ((available_scale_factor == ui::SCALE_FACTOR_NONE ||
- (ui::GetImageScale(scale_factors_[i]) >
- ui::GetImageScale(available_scale_factor))) &&
+ (ui::GetScaleForScaleFactor(scale_factors_[i]) >
+ ui::GetScaleForScaleFactor(available_scale_factor))) &&
image_memory_.find(raw_id) != image_memory_.end()) {
available_scale_factor = scale_factors_[i];
}
projects / platform / framework / web / crosswalk.git / blobdiff