browser_theme_pack.cc revision effb81e5f8246d0db0270817048dc992db66e9fb 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/themes/browser_theme_pack.h"
6
7#include <limits>
8
9#include "base/files/file.h"
10#include "base/memory/ref_counted_memory.h"
11#include "base/memory/scoped_ptr.h"
12#include "base/stl_util.h"
13#include "base/strings/string_number_conversions.h"
14#include "base/strings/string_util.h"
15#include "base/strings/utf_string_conversions.h"
16#include "base/threading/sequenced_worker_pool.h"
17#include "base/threading/thread_restrictions.h"
18#include "base/values.h"
19#include "chrome/browser/themes/theme_properties.h"
20#include "chrome/common/extensions/manifest_handlers/theme_handler.h"
21#include "content/public/browser/browser_thread.h"
22#include "extensions/common/id_util.h"
23#include "grit/theme_resources.h"
24#include "grit/ui_resources.h"
25#include "third_party/skia/include/core/SkCanvas.h"
26#include "ui/base/resource/data_pack.h"
27#include "ui/base/resource/resource_bundle.h"
28#include "ui/gfx/canvas.h"
29#include "ui/gfx/codec/png_codec.h"
30#include "ui/gfx/image/canvas_image_source.h"
31#include "ui/gfx/image/image.h"
32#include "ui/gfx/image/image_skia.h"
33#include "ui/gfx/image/image_skia_operations.h"
34#include "ui/gfx/screen.h"
35#include "ui/gfx/size_conversions.h"
36#include "ui/gfx/skia_util.h"
37
38using content::BrowserThread;
39using extensions::Extension;
40
41namespace {
42
43// Version number of the current theme pack. We just throw out and rebuild
44// theme packs that aren't int-equal to this. Increment this number if you
45// change default theme assets.
46const int kThemePackVersion = 32;
47
48// IDs that are in the DataPack won't clash with the positive integer
49// uint16. kHeaderID should always have the maximum value because we want the
50// "header" to be written last. That way we can detect whether the pack was
51// successfully written and ignore and regenerate if it was only partially
52// written (i.e. chrome crashed on a different thread while writing the pack).
53const int kMaxID = 0x0000FFFF;  // Max unsigned 16-bit int.
54const int kHeaderID = kMaxID - 1;
55const int kTintsID = kMaxID - 2;
56const int kColorsID = kMaxID - 3;
57const int kDisplayPropertiesID = kMaxID - 4;
58const int kSourceImagesID = kMaxID - 5;
59const int kScaleFactorsID = kMaxID - 6;
60
61// The sum of kFrameBorderThickness and kNonClientRestoredExtraThickness from
62// OpaqueBrowserFrameView.
63const int kRestoredTabVerticalOffset = 15;
64
65// Persistent constants for the main images that we need. These have the same
66// names as their IDR_* counterparts but these values will always stay the
67// same.
68const int PRS_THEME_FRAME = 1;
69const int PRS_THEME_FRAME_INACTIVE = 2;
70const int PRS_THEME_FRAME_INCOGNITO = 3;
71const int PRS_THEME_FRAME_INCOGNITO_INACTIVE = 4;
72const int PRS_THEME_TOOLBAR = 5;
73const int PRS_THEME_TAB_BACKGROUND = 6;
74const int PRS_THEME_TAB_BACKGROUND_INCOGNITO = 7;
75const int PRS_THEME_TAB_BACKGROUND_V = 8;
76const int PRS_THEME_NTP_BACKGROUND = 9;
77const int PRS_THEME_FRAME_OVERLAY = 10;
78const int PRS_THEME_FRAME_OVERLAY_INACTIVE = 11;
79const int PRS_THEME_BUTTON_BACKGROUND = 12;
80const int PRS_THEME_NTP_ATTRIBUTION = 13;
81const int PRS_THEME_WINDOW_CONTROL_BACKGROUND = 14;
82
83struct PersistingImagesTable {
84  // A non-changing integer ID meant to be saved in theme packs. This ID must
85  // not change between versions of chrome.
86  int persistent_id;
87
88  // The IDR that depends on the whims of GRIT and therefore changes whenever
89  // someone adds a new resource.
90  int idr_id;
91
92  // String to check for when parsing theme manifests or NULL if this isn't
93  // supposed to be changeable by the user.
94  const char* key;
95};
96
97// IDR_* resource names change whenever new resources are added; use persistent
98// IDs when storing to a cached pack.
99PersistingImagesTable kPersistingImages[] = {
100  { PRS_THEME_FRAME, IDR_THEME_FRAME,
101    "theme_frame" },
102  { PRS_THEME_FRAME_INACTIVE, IDR_THEME_FRAME_INACTIVE,
103    "theme_frame_inactive" },
104  { PRS_THEME_FRAME_INCOGNITO, IDR_THEME_FRAME_INCOGNITO,
105    "theme_frame_incognito" },
106  { PRS_THEME_FRAME_INCOGNITO_INACTIVE, IDR_THEME_FRAME_INCOGNITO_INACTIVE,
107    "theme_frame_incognito_inactive" },
108  { PRS_THEME_TOOLBAR, IDR_THEME_TOOLBAR,
109    "theme_toolbar" },
110  { PRS_THEME_TAB_BACKGROUND, IDR_THEME_TAB_BACKGROUND,
111    "theme_tab_background" },
112  { PRS_THEME_TAB_BACKGROUND_INCOGNITO, IDR_THEME_TAB_BACKGROUND_INCOGNITO,
113    "theme_tab_background_incognito" },
114  { PRS_THEME_TAB_BACKGROUND_V, IDR_THEME_TAB_BACKGROUND_V,
115    "theme_tab_background_v"},
116  { PRS_THEME_NTP_BACKGROUND, IDR_THEME_NTP_BACKGROUND,
117    "theme_ntp_background" },
118  { PRS_THEME_FRAME_OVERLAY, IDR_THEME_FRAME_OVERLAY,
119    "theme_frame_overlay" },
120  { PRS_THEME_FRAME_OVERLAY_INACTIVE, IDR_THEME_FRAME_OVERLAY_INACTIVE,
121    "theme_frame_overlay_inactive" },
122  { PRS_THEME_BUTTON_BACKGROUND, IDR_THEME_BUTTON_BACKGROUND,
123    "theme_button_background" },
124  { PRS_THEME_NTP_ATTRIBUTION, IDR_THEME_NTP_ATTRIBUTION,
125    "theme_ntp_attribution" },
126  { PRS_THEME_WINDOW_CONTROL_BACKGROUND, IDR_THEME_WINDOW_CONTROL_BACKGROUND,
127    "theme_window_control_background"},
128
129  // The rest of these entries have no key because they can't be overridden
130  // from the json manifest.
131  { 15, IDR_BACK, NULL },
132  { 16, IDR_BACK_D, NULL },
133  { 17, IDR_BACK_H, NULL },
134  { 18, IDR_BACK_P, NULL },
135  { 19, IDR_FORWARD, NULL },
136  { 20, IDR_FORWARD_D, NULL },
137  { 21, IDR_FORWARD_H, NULL },
138  { 22, IDR_FORWARD_P, NULL },
139  { 23, IDR_HOME, NULL },
140  { 24, IDR_HOME_H, NULL },
141  { 25, IDR_HOME_P, NULL },
142  { 26, IDR_RELOAD, NULL },
143  { 27, IDR_RELOAD_H, NULL },
144  { 28, IDR_RELOAD_P, NULL },
145  { 29, IDR_STOP, NULL },
146  { 30, IDR_STOP_D, NULL },
147  { 31, IDR_STOP_H, NULL },
148  { 32, IDR_STOP_P, NULL },
149  { 33, IDR_BROWSER_ACTIONS_OVERFLOW, NULL },
150  { 34, IDR_BROWSER_ACTIONS_OVERFLOW_H, NULL },
151  { 35, IDR_BROWSER_ACTIONS_OVERFLOW_P, NULL },
152  { 36, IDR_TOOLS, NULL },
153  { 37, IDR_TOOLS_H, NULL },
154  { 38, IDR_TOOLS_P, NULL },
155  { 39, IDR_MENU_DROPARROW, NULL },
156  { 40, IDR_THROBBER, NULL },
157  { 41, IDR_THROBBER_WAITING, NULL },
158  { 42, IDR_THROBBER_LIGHT, NULL },
159  { 43, IDR_TOOLBAR_BEZEL_HOVER, NULL },
160  { 44, IDR_TOOLBAR_BEZEL_PRESSED, NULL },
161  { 45, IDR_TOOLS_BAR, NULL },
162};
163const size_t kPersistingImagesLength = arraysize(kPersistingImages);
164
165#if defined(OS_WIN)
166// Persistent theme ids for Windows.
167const int PRS_THEME_FRAME_WIN = 100;
168const int PRS_THEME_FRAME_INACTIVE_WIN = 101;
169const int PRS_THEME_FRAME_INCOGNITO_WIN = 102;
170const int PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN = 103;
171const int PRS_THEME_TOOLBAR_WIN = 104;
172const int PRS_THEME_TAB_BACKGROUND_WIN = 105;
173const int PRS_THEME_TAB_BACKGROUND_INCOGNITO_WIN = 106;
174
175// Persistent theme to resource id mapping for Windows AURA.
176PersistingImagesTable kPersistingImagesWinDesktopAura[] = {
177  { PRS_THEME_FRAME_WIN, IDR_THEME_FRAME_WIN,
178    "theme_frame" },
179  { PRS_THEME_FRAME_INACTIVE_WIN, IDR_THEME_FRAME_INACTIVE_WIN,
180    "theme_frame_inactive" },
181  { PRS_THEME_FRAME_INCOGNITO_WIN, IDR_THEME_FRAME_INCOGNITO_WIN,
182    "theme_frame_incognito" },
183  { PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN,
184    IDR_THEME_FRAME_INCOGNITO_INACTIVE_WIN,
185    "theme_frame_incognito_inactive" },
186  { PRS_THEME_TOOLBAR_WIN, IDR_THEME_TOOLBAR_WIN,
187    "theme_toolbar" },
188  { PRS_THEME_TAB_BACKGROUND_WIN, IDR_THEME_TAB_BACKGROUND_WIN,
189    "theme_tab_background" },
190  { PRS_THEME_TAB_BACKGROUND_INCOGNITO_WIN,
191    IDR_THEME_TAB_BACKGROUND_INCOGNITO_WIN,
192    "theme_tab_background_incognito" },
193};
194const size_t kPersistingImagesWinDesktopAuraLength =
195    arraysize(kPersistingImagesWinDesktopAura);
196#endif
197
198int GetPersistentIDByNameHelper(const std::string& key,
199                                const PersistingImagesTable* image_table,
200                                size_t image_table_size) {
201  for (size_t i = 0; i < image_table_size; ++i) {
202    if (image_table[i].key != NULL &&
203        base::strcasecmp(key.c_str(), image_table[i].key) == 0) {
204      return image_table[i].persistent_id;
205    }
206  }
207  return -1;
208}
209
210int GetPersistentIDByName(const std::string& key) {
211  return GetPersistentIDByNameHelper(key,
212                                     kPersistingImages,
213                                     kPersistingImagesLength);
214}
215
216int GetPersistentIDByIDR(int idr) {
217  static std::map<int,int>* lookup_table = new std::map<int,int>();
218  if (lookup_table->empty()) {
219    for (size_t i = 0; i < kPersistingImagesLength; ++i) {
220      int idr = kPersistingImages[i].idr_id;
221      int prs_id = kPersistingImages[i].persistent_id;
222      (*lookup_table)[idr] = prs_id;
223    }
224#if defined(OS_WIN)
225    for (size_t i = 0; i < kPersistingImagesWinDesktopAuraLength; ++i) {
226      int idr = kPersistingImagesWinDesktopAura[i].idr_id;
227      int prs_id = kPersistingImagesWinDesktopAura[i].persistent_id;
228      (*lookup_table)[idr] = prs_id;
229    }
230#endif
231  }
232  std::map<int,int>::iterator it = lookup_table->find(idr);
233  return (it == lookup_table->end()) ? -1 : it->second;
234}
235
236// Returns true if the scales in |input| match those in |expected|.
237// The order must match as the index is used in determining the raw id.
238bool InputScalesValid(const base::StringPiece& input,
239                      const std::vector<ui::ScaleFactor>& expected) {
240  size_t scales_size = static_cast<size_t>(input.size() / sizeof(float));
241  if (scales_size != expected.size())
242    return false;
243  scoped_ptr<float[]> scales(new float[scales_size]);
244  // Do a memcpy to avoid misaligned memory access.
245  memcpy(scales.get(), input.data(), input.size());
246  for (size_t index = 0; index < scales_size; ++index) {
247    if (scales[index] != ui::GetImageScale(expected[index]))
248      return false;
249  }
250  return true;
251}
252
253// Returns |scale_factors| as a string to be written to disk.
254std::string GetScaleFactorsAsString(
255    const std::vector<ui::ScaleFactor>& scale_factors) {
256  scoped_ptr<float[]> scales(new float[scale_factors.size()]);
257  for (size_t i = 0; i < scale_factors.size(); ++i)
258    scales[i] = ui::GetImageScale(scale_factors[i]);
259  std::string out_string = std::string(
260      reinterpret_cast<const char*>(scales.get()),
261      scale_factors.size() * sizeof(float));
262  return out_string;
263}
264
265struct StringToIntTable {
266  const char* key;
267  ThemeProperties::OverwritableByUserThemeProperty id;
268};
269
270// Strings used by themes to identify tints in the JSON.
271StringToIntTable kTintTable[] = {
272  { "buttons", ThemeProperties::TINT_BUTTONS },
273  { "frame", ThemeProperties::TINT_FRAME },
274  { "frame_inactive", ThemeProperties::TINT_FRAME_INACTIVE },
275  { "frame_incognito", ThemeProperties::TINT_FRAME_INCOGNITO },
276  { "frame_incognito_inactive",
277    ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE },
278  { "background_tab", ThemeProperties::TINT_BACKGROUND_TAB },
279};
280const size_t kTintTableLength = arraysize(kTintTable);
281
282// Strings used by themes to identify colors in the JSON.
283StringToIntTable kColorTable[] = {
284  { "frame", ThemeProperties::COLOR_FRAME },
285  { "frame_inactive", ThemeProperties::COLOR_FRAME_INACTIVE },
286  { "frame_incognito", ThemeProperties::COLOR_FRAME_INCOGNITO },
287  { "frame_incognito_inactive",
288    ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE },
289  { "toolbar", ThemeProperties::COLOR_TOOLBAR },
290  { "tab_text", ThemeProperties::COLOR_TAB_TEXT },
291  { "tab_background_text", ThemeProperties::COLOR_BACKGROUND_TAB_TEXT },
292  { "bookmark_text", ThemeProperties::COLOR_BOOKMARK_TEXT },
293  { "ntp_background", ThemeProperties::COLOR_NTP_BACKGROUND },
294  { "ntp_text", ThemeProperties::COLOR_NTP_TEXT },
295  { "ntp_link", ThemeProperties::COLOR_NTP_LINK },
296  { "ntp_link_underline", ThemeProperties::COLOR_NTP_LINK_UNDERLINE },
297  { "ntp_header", ThemeProperties::COLOR_NTP_HEADER },
298  { "ntp_section", ThemeProperties::COLOR_NTP_SECTION },
299  { "ntp_section_text", ThemeProperties::COLOR_NTP_SECTION_TEXT },
300  { "ntp_section_link", ThemeProperties::COLOR_NTP_SECTION_LINK },
301  { "ntp_section_link_underline",
302    ThemeProperties::COLOR_NTP_SECTION_LINK_UNDERLINE },
303  { "button_background", ThemeProperties::COLOR_BUTTON_BACKGROUND },
304};
305const size_t kColorTableLength = arraysize(kColorTable);
306
307// Strings used by themes to identify display properties keys in JSON.
308StringToIntTable kDisplayProperties[] = {
309  { "ntp_background_alignment",
310    ThemeProperties::NTP_BACKGROUND_ALIGNMENT },
311  { "ntp_background_repeat", ThemeProperties::NTP_BACKGROUND_TILING },
312  { "ntp_logo_alternate", ThemeProperties::NTP_LOGO_ALTERNATE },
313};
314const size_t kDisplayPropertiesSize = arraysize(kDisplayProperties);
315
316int GetIntForString(const std::string& key,
317                    StringToIntTable* table,
318                    size_t table_length) {
319  for (size_t i = 0; i < table_length; ++i) {
320    if (base::strcasecmp(key.c_str(), table[i].key) == 0) {
321      return table[i].id;
322    }
323  }
324
325  return -1;
326}
327
328struct IntToIntTable {
329  int key;
330  int value;
331};
332
333// Mapping used in CreateFrameImages() to associate frame images with the
334// tint ID that should maybe be applied to it.
335IntToIntTable kFrameTintMap[] = {
336  { PRS_THEME_FRAME, ThemeProperties::TINT_FRAME },
337  { PRS_THEME_FRAME_INACTIVE, ThemeProperties::TINT_FRAME_INACTIVE },
338  { PRS_THEME_FRAME_OVERLAY, ThemeProperties::TINT_FRAME },
339  { PRS_THEME_FRAME_OVERLAY_INACTIVE,
340    ThemeProperties::TINT_FRAME_INACTIVE },
341  { PRS_THEME_FRAME_INCOGNITO, ThemeProperties::TINT_FRAME_INCOGNITO },
342  { PRS_THEME_FRAME_INCOGNITO_INACTIVE,
343    ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE },
344#if defined(OS_WIN)
345  { PRS_THEME_FRAME_WIN, ThemeProperties::TINT_FRAME },
346  { PRS_THEME_FRAME_INACTIVE_WIN, ThemeProperties::TINT_FRAME_INACTIVE },
347  { PRS_THEME_FRAME_INCOGNITO_WIN, ThemeProperties::TINT_FRAME_INCOGNITO },
348  { PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN,
349    ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE },
350#endif
351};
352
353// Mapping used in GenerateTabBackgroundImages() to associate what frame image
354// goes with which tab background.
355IntToIntTable kTabBackgroundMap[] = {
356  { PRS_THEME_TAB_BACKGROUND, PRS_THEME_FRAME },
357  { PRS_THEME_TAB_BACKGROUND_INCOGNITO, PRS_THEME_FRAME_INCOGNITO },
358#if defined(OS_WIN)
359  { PRS_THEME_TAB_BACKGROUND_WIN, PRS_THEME_FRAME_WIN },
360  { PRS_THEME_TAB_BACKGROUND_INCOGNITO_WIN, PRS_THEME_FRAME_INCOGNITO_WIN },
361#endif
362};
363
364struct CropEntry {
365  int prs_id;
366
367  // The maximum useful height of the image at |prs_id|.
368  int max_height;
369
370  // Whether cropping the image at |prs_id| should be skipped on OSes which
371  // have a frame border to the left and right of the web contents.
372  // This should be true for images which can be used to decorate the border to
373  // the left and the right of the web contents.
374  bool skip_if_frame_border;
375};
376
377// The images which should be cropped before being saved to the data pack. The
378// maximum heights are meant to be conservative as to give room for the UI to
379// change without the maximum heights having to be modified.
380// |kThemePackVersion| must be incremented if any of the maximum heights below
381// are modified.
382struct CropEntry kImagesToCrop[] = {
383  { PRS_THEME_FRAME, 120, true },
384  { PRS_THEME_FRAME_INACTIVE, 120, true },
385  { PRS_THEME_FRAME_INCOGNITO, 120, true },
386  { PRS_THEME_FRAME_INCOGNITO_INACTIVE, 120, true },
387  { PRS_THEME_FRAME_OVERLAY, 120, true },
388  { PRS_THEME_FRAME_OVERLAY_INACTIVE, 120, true },
389  { PRS_THEME_TOOLBAR, 200, false },
390  { PRS_THEME_BUTTON_BACKGROUND, 60, false },
391  { PRS_THEME_WINDOW_CONTROL_BACKGROUND, 50, false },
392#if defined(OS_WIN)
393  { PRS_THEME_TOOLBAR_WIN, 200, false }
394#endif
395};
396
397
398// A list of images that don't need tinting or any other modification and can
399// be byte-copied directly into the finished DataPack. This should contain the
400// persistent IDs for all themeable image IDs that aren't in kFrameTintMap,
401// kTabBackgroundMap or kImagesToCrop.
402const int kPreloadIDs[] = {
403  PRS_THEME_NTP_BACKGROUND,
404  PRS_THEME_NTP_ATTRIBUTION,
405};
406
407// Returns true if this OS uses a browser frame which has a non zero width to
408// the left and the right of the web contents.
409bool HasFrameBorder() {
410#if defined(OS_CHROMEOS) || defined(OS_MACOSX)
411  return false;
412#else
413  return true;
414#endif
415}
416
417// Returns a piece of memory with the contents of the file |path|.
418base::RefCountedMemory* ReadFileData(const base::FilePath& path) {
419  if (!path.empty()) {
420    base::File file(path, base::File::FLAG_OPEN | base::File::FLAG_READ);
421    if (file.IsValid()) {
422      int64 length = file.GetLength();
423      if (length > 0 && length < INT_MAX) {
424        int size = static_cast<int>(length);
425        std::vector<unsigned char> raw_data;
426        raw_data.resize(size);
427        char* data = reinterpret_cast<char*>(&(raw_data.front()));
428        if (file.ReadAtCurrentPos(data, size) == length)
429          return base::RefCountedBytes::TakeVector(&raw_data);
430      }
431    }
432  }
433
434  return NULL;
435}
436
437// Shifts an image's HSL values. The caller is responsible for deleting
438// the returned image.
439gfx::Image CreateHSLShiftedImage(const gfx::Image& image,
440                                 const color_utils::HSL& hsl_shift) {
441  const gfx::ImageSkia* src_image = image.ToImageSkia();
442  return gfx::Image(gfx::ImageSkiaOperations::CreateHSLShiftedImage(
443      *src_image, hsl_shift));
444}
445
446// Computes a bitmap at one scale from a bitmap at a different scale.
447SkBitmap CreateLowQualityResizedBitmap(const SkBitmap& source_bitmap,
448                                       ui::ScaleFactor source_scale_factor,
449                                       ui::ScaleFactor desired_scale_factor) {
450  gfx::Size scaled_size = gfx::ToCeiledSize(
451      gfx::ScaleSize(gfx::Size(source_bitmap.width(),
452                               source_bitmap.height()),
453                     ui::GetImageScale(desired_scale_factor) /
454                     ui::GetImageScale(source_scale_factor)));
455  SkBitmap scaled_bitmap;
456  scaled_bitmap.setConfig(SkBitmap::kARGB_8888_Config,
457                          scaled_size.width(),
458                          scaled_size.height());
459  if (!scaled_bitmap.allocPixels())
460    SK_CRASH();
461  scaled_bitmap.eraseARGB(0, 0, 0, 0);
462  SkCanvas canvas(scaled_bitmap);
463  SkRect scaled_bounds = RectToSkRect(gfx::Rect(scaled_size));
464  // Note(oshima): The following scaling code doesn't work with
465  // a mask image.
466  canvas.drawBitmapRect(source_bitmap, NULL, scaled_bounds);
467  return scaled_bitmap;
468}
469
470// A ImageSkiaSource that scales 100P image to the target scale factor
471// if the ImageSkiaRep for the target scale factor isn't available.
472class ThemeImageSource: public gfx::ImageSkiaSource {
473 public:
474  explicit ThemeImageSource(const gfx::ImageSkia& source) : source_(source) {
475  }
476  virtual ~ThemeImageSource() {}
477
478  virtual gfx::ImageSkiaRep GetImageForScale(float scale) OVERRIDE {
479    if (source_.HasRepresentation(scale))
480      return source_.GetRepresentation(scale);
481    const gfx::ImageSkiaRep& rep_100p = source_.GetRepresentation(1.0f);
482    SkBitmap scaled_bitmap = CreateLowQualityResizedBitmap(
483        rep_100p.sk_bitmap(),
484        ui::SCALE_FACTOR_100P,
485        ui::GetSupportedScaleFactor(scale));
486    return gfx::ImageSkiaRep(scaled_bitmap, scale);
487  }
488
489 private:
490  const gfx::ImageSkia source_;
491
492  DISALLOW_COPY_AND_ASSIGN(ThemeImageSource);
493};
494
495// An ImageSkiaSource that delays decoding PNG data into bitmaps until
496// needed. Missing data for a scale factor is computed by scaling data for an
497// available scale factor. Computed bitmaps are stored for future look up.
498class ThemeImagePngSource : public gfx::ImageSkiaSource {
499 public:
500  typedef std::map<ui::ScaleFactor,
501                   scoped_refptr<base::RefCountedMemory> > PngMap;
502
503  explicit ThemeImagePngSource(const PngMap& png_map) : png_map_(png_map) {}
504
505  virtual ~ThemeImagePngSource() {}
506
507 private:
508  virtual gfx::ImageSkiaRep GetImageForScale(float scale) OVERRIDE {
509    ui::ScaleFactor scale_factor = ui::GetSupportedScaleFactor(scale);
510    // Look up the bitmap for |scale factor| in the bitmap map. If found
511    // return it.
512    BitmapMap::const_iterator exact_bitmap_it = bitmap_map_.find(scale_factor);
513    if (exact_bitmap_it != bitmap_map_.end())
514      return gfx::ImageSkiaRep(exact_bitmap_it->second, scale);
515
516    // Look up the raw PNG data for |scale_factor| in the png map. If found,
517    // decode it, store the result in the bitmap map and return it.
518    PngMap::const_iterator exact_png_it = png_map_.find(scale_factor);
519    if (exact_png_it != png_map_.end()) {
520      SkBitmap bitmap;
521      if (!gfx::PNGCodec::Decode(exact_png_it->second->front(),
522                                 exact_png_it->second->size(),
523                                 &bitmap)) {
524        NOTREACHED();
525        return gfx::ImageSkiaRep();
526      }
527      bitmap_map_[scale_factor] = bitmap;
528      return gfx::ImageSkiaRep(bitmap, scale);
529    }
530
531    // Find an available PNG for another scale factor. We want to use the
532    // highest available scale factor.
533    PngMap::const_iterator available_png_it = png_map_.end();
534    for (PngMap::const_iterator png_it = png_map_.begin();
535         png_it != png_map_.end(); ++png_it) {
536      if (available_png_it == png_map_.end() ||
537          ui::GetImageScale(png_it->first) >
538          ui::GetImageScale(available_png_it->first)) {
539        available_png_it = png_it;
540      }
541    }
542    if (available_png_it == png_map_.end())
543      return gfx::ImageSkiaRep();
544    ui::ScaleFactor available_scale_factor = available_png_it->first;
545
546    // Look up the bitmap for |available_scale_factor| in the bitmap map.
547    // If not found, decode the corresponging png data, store the result
548    // in the bitmap map.
549    BitmapMap::const_iterator available_bitmap_it =
550        bitmap_map_.find(available_scale_factor);
551    if (available_bitmap_it == bitmap_map_.end()) {
552      SkBitmap available_bitmap;
553      if (!gfx::PNGCodec::Decode(available_png_it->second->front(),
554                                 available_png_it->second->size(),
555                                 &available_bitmap)) {
556        NOTREACHED();
557        return gfx::ImageSkiaRep();
558      }
559      bitmap_map_[available_scale_factor] = available_bitmap;
560      available_bitmap_it = bitmap_map_.find(available_scale_factor);
561    }
562
563    // Scale the available bitmap to the desired scale factor, store the result
564    // in the bitmap map and return it.
565    SkBitmap scaled_bitmap = CreateLowQualityResizedBitmap(
566        available_bitmap_it->second,
567        available_scale_factor,
568        scale_factor);
569    bitmap_map_[scale_factor] = scaled_bitmap;
570    return gfx::ImageSkiaRep(scaled_bitmap, scale);
571  }
572
573  PngMap png_map_;
574
575  typedef std::map<ui::ScaleFactor, SkBitmap> BitmapMap;
576  BitmapMap bitmap_map_;
577
578  DISALLOW_COPY_AND_ASSIGN(ThemeImagePngSource);
579};
580
581class TabBackgroundImageSource: public gfx::CanvasImageSource {
582 public:
583  TabBackgroundImageSource(const gfx::ImageSkia& image_to_tint,
584                           const gfx::ImageSkia& overlay,
585                           const color_utils::HSL& hsl_shift,
586                           int vertical_offset)
587      : gfx::CanvasImageSource(image_to_tint.size(), false),
588        image_to_tint_(image_to_tint),
589        overlay_(overlay),
590        hsl_shift_(hsl_shift),
591        vertical_offset_(vertical_offset) {
592  }
593
594  virtual ~TabBackgroundImageSource() {
595  }
596
597  // Overridden from CanvasImageSource:
598  virtual void Draw(gfx::Canvas* canvas) OVERRIDE {
599    gfx::ImageSkia bg_tint =
600        gfx::ImageSkiaOperations::CreateHSLShiftedImage(image_to_tint_,
601            hsl_shift_);
602    canvas->TileImageInt(bg_tint, 0, vertical_offset_, 0, 0,
603        size().width(), size().height());
604
605    // If they've provided a custom image, overlay it.
606    if (!overlay_.isNull()) {
607      canvas->TileImageInt(overlay_, 0, 0, size().width(),
608                           overlay_.height());
609    }
610  }
611
612 private:
613  const gfx::ImageSkia image_to_tint_;
614  const gfx::ImageSkia overlay_;
615  const color_utils::HSL hsl_shift_;
616  const int vertical_offset_;
617
618  DISALLOW_COPY_AND_ASSIGN(TabBackgroundImageSource);
619};
620
621}  // namespace
622
623BrowserThemePack::~BrowserThemePack() {
624  if (!data_pack_.get()) {
625    delete header_;
626    delete [] tints_;
627    delete [] colors_;
628    delete [] display_properties_;
629    delete [] source_images_;
630  }
631}
632
633// static
634scoped_refptr<BrowserThemePack> BrowserThemePack::BuildFromExtension(
635    const Extension* extension) {
636  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
637  DCHECK(extension);
638  DCHECK(extension->is_theme());
639
640  scoped_refptr<BrowserThemePack> pack(new BrowserThemePack);
641  pack->BuildHeader(extension);
642  pack->BuildTintsFromJSON(extensions::ThemeInfo::GetTints(extension));
643  pack->BuildColorsFromJSON(extensions::ThemeInfo::GetColors(extension));
644  pack->BuildDisplayPropertiesFromJSON(
645      extensions::ThemeInfo::GetDisplayProperties(extension));
646
647  // Builds the images. (Image building is dependent on tints).
648  FilePathMap file_paths;
649  pack->ParseImageNamesFromJSON(
650      extensions::ThemeInfo::GetImages(extension),
651      extension->path(),
652      &file_paths);
653  pack->BuildSourceImagesArray(file_paths);
654
655  if (!pack->LoadRawBitmapsTo(file_paths, &pack->images_on_ui_thread_))
656    return NULL;
657
658  pack->CreateImages(&pack->images_on_ui_thread_);
659
660  // Make sure the |images_on_file_thread_| has bitmaps for supported
661  // scale factors before passing to FILE thread.
662  pack->images_on_file_thread_ = pack->images_on_ui_thread_;
663  for (ImageCache::iterator it = pack->images_on_file_thread_.begin();
664       it != pack->images_on_file_thread_.end(); ++it) {
665    gfx::ImageSkia* image_skia =
666        const_cast<gfx::ImageSkia*>(it->second.ToImageSkia());
667    image_skia->MakeThreadSafe();
668  }
669
670  // Set ThemeImageSource on |images_on_ui_thread_| to resample the source
671  // image if a caller of BrowserThemePack::GetImageNamed() requests an
672  // ImageSkiaRep for a scale factor not specified by the theme author.
673  // Callers of BrowserThemePack::GetImageNamed() to be able to retrieve
674  // ImageSkiaReps for all supported scale factors.
675  for (ImageCache::iterator it = pack->images_on_ui_thread_.begin();
676       it != pack->images_on_ui_thread_.end(); ++it) {
677    const gfx::ImageSkia source_image_skia = it->second.AsImageSkia();
678    ThemeImageSource* source = new ThemeImageSource(source_image_skia);
679    // image_skia takes ownership of source.
680    gfx::ImageSkia image_skia(source, source_image_skia.size());
681    it->second = gfx::Image(image_skia);
682  }
683
684  // Generate raw images (for new-tab-page attribution and background) for
685  // any missing scale from an available scale image.
686  for (size_t i = 0; i < arraysize(kPreloadIDs); ++i) {
687    pack->GenerateRawImageForAllSupportedScales(kPreloadIDs[i]);
688  }
689
690  // The BrowserThemePack is now in a consistent state.
691  return pack;
692}
693
694// static
695scoped_refptr<BrowserThemePack> BrowserThemePack::BuildFromDataPack(
696    const base::FilePath& path, const std::string& expected_id) {
697  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
698  // Allow IO on UI thread due to deep-seated theme design issues.
699  // (see http://crbug.com/80206)
700  base::ThreadRestrictions::ScopedAllowIO allow_io;
701  scoped_refptr<BrowserThemePack> pack(new BrowserThemePack);
702  // Scale factor parameter is moot as data pack has image resources for all
703  // supported scale factors.
704  pack->data_pack_.reset(
705      new ui::DataPack(ui::SCALE_FACTOR_NONE));
706
707  if (!pack->data_pack_->LoadFromPath(path)) {
708    LOG(ERROR) << "Failed to load theme data pack.";
709    return NULL;
710  }
711
712  base::StringPiece pointer;
713  if (!pack->data_pack_->GetStringPiece(kHeaderID, &pointer))
714    return NULL;
715  pack->header_ = reinterpret_cast<BrowserThemePackHeader*>(const_cast<char*>(
716      pointer.data()));
717
718  if (pack->header_->version != kThemePackVersion) {
719    DLOG(ERROR) << "BuildFromDataPack failure! Version mismatch!";
720    return NULL;
721  }
722  // TODO(erg): Check endianess once DataPack works on the other endian.
723  std::string theme_id(reinterpret_cast<char*>(pack->header_->theme_id),
724                       extensions::id_util::kIdSize);
725  std::string truncated_id =
726      expected_id.substr(0, extensions::id_util::kIdSize);
727  if (theme_id != truncated_id) {
728    DLOG(ERROR) << "Wrong id: " << theme_id << " vs " << expected_id;
729    return NULL;
730  }
731
732  if (!pack->data_pack_->GetStringPiece(kTintsID, &pointer))
733    return NULL;
734  pack->tints_ = reinterpret_cast<TintEntry*>(const_cast<char*>(
735      pointer.data()));
736
737  if (!pack->data_pack_->GetStringPiece(kColorsID, &pointer))
738    return NULL;
739  pack->colors_ =
740      reinterpret_cast<ColorPair*>(const_cast<char*>(pointer.data()));
741
742  if (!pack->data_pack_->GetStringPiece(kDisplayPropertiesID, &pointer))
743    return NULL;
744  pack->display_properties_ = reinterpret_cast<DisplayPropertyPair*>(
745      const_cast<char*>(pointer.data()));
746
747  if (!pack->data_pack_->GetStringPiece(kSourceImagesID, &pointer))
748    return NULL;
749  pack->source_images_ = reinterpret_cast<int*>(
750      const_cast<char*>(pointer.data()));
751
752  if (!pack->data_pack_->GetStringPiece(kScaleFactorsID, &pointer))
753    return NULL;
754
755  if (!InputScalesValid(pointer, pack->scale_factors_)) {
756    DLOG(ERROR) << "BuildFromDataPack failure! The pack scale factors differ "
757                << "from those supported by platform.";
758  }
759  return pack;
760}
761
762// static
763void BrowserThemePack::GetThemeableImageIDRs(std::set<int>* result) {
764  if (!result)
765    return;
766
767  result->clear();
768  for (size_t i = 0; i < kPersistingImagesLength; ++i)
769    result->insert(kPersistingImages[i].idr_id);
770
771#if defined(OS_WIN)
772  for (size_t i = 0; i < kPersistingImagesWinDesktopAuraLength; ++i)
773    result->insert(kPersistingImagesWinDesktopAura[i].idr_id);
774#endif
775}
776
777bool BrowserThemePack::WriteToDisk(const base::FilePath& path) const {
778  // Add resources for each of the property arrays.
779  RawDataForWriting resources;
780  resources[kHeaderID] = base::StringPiece(
781      reinterpret_cast<const char*>(header_), sizeof(BrowserThemePackHeader));
782  resources[kTintsID] = base::StringPiece(
783      reinterpret_cast<const char*>(tints_),
784      sizeof(TintEntry[kTintTableLength]));
785  resources[kColorsID] = base::StringPiece(
786      reinterpret_cast<const char*>(colors_),
787      sizeof(ColorPair[kColorTableLength]));
788  resources[kDisplayPropertiesID] = base::StringPiece(
789      reinterpret_cast<const char*>(display_properties_),
790      sizeof(DisplayPropertyPair[kDisplayPropertiesSize]));
791
792  int source_count = 1;
793  int* end = source_images_;
794  for (; *end != -1 ; end++)
795    source_count++;
796  resources[kSourceImagesID] = base::StringPiece(
797      reinterpret_cast<const char*>(source_images_),
798      source_count * sizeof(*source_images_));
799
800  // Store results of GetScaleFactorsAsString() in std::string as
801  // base::StringPiece does not copy data in constructor.
802  std::string scale_factors_string = GetScaleFactorsAsString(scale_factors_);
803  resources[kScaleFactorsID] = scale_factors_string;
804
805  AddRawImagesTo(image_memory_, &resources);
806
807  RawImages reencoded_images;
808  RepackImages(images_on_file_thread_, &reencoded_images);
809  AddRawImagesTo(reencoded_images, &resources);
810
811  return ui::DataPack::WritePack(path, resources, ui::DataPack::BINARY);
812}
813
814bool BrowserThemePack::GetTint(int id, color_utils::HSL* hsl) const {
815  if (tints_) {
816    for (size_t i = 0; i < kTintTableLength; ++i) {
817      if (tints_[i].id == id) {
818        hsl->h = tints_[i].h;
819        hsl->s = tints_[i].s;
820        hsl->l = tints_[i].l;
821        return true;
822      }
823    }
824  }
825
826  return false;
827}
828
829bool BrowserThemePack::GetColor(int id, SkColor* color) const {
830  if (colors_) {
831    for (size_t i = 0; i < kColorTableLength; ++i) {
832      if (colors_[i].id == id) {
833        *color = colors_[i].color;
834        return true;
835      }
836    }
837  }
838
839  return false;
840}
841
842bool BrowserThemePack::GetDisplayProperty(int id, int* result) const {
843  if (display_properties_) {
844    for (size_t i = 0; i < kDisplayPropertiesSize; ++i) {
845      if (display_properties_[i].id == id) {
846        *result = display_properties_[i].property;
847        return true;
848      }
849    }
850  }
851
852  return false;
853}
854
855gfx::Image BrowserThemePack::GetImageNamed(int idr_id) {
856  int prs_id = GetPersistentIDByIDR(idr_id);
857  if (prs_id == -1)
858    return gfx::Image();
859
860  // Check if the image is cached.
861  ImageCache::const_iterator image_iter = images_on_ui_thread_.find(prs_id);
862  if (image_iter != images_on_ui_thread_.end())
863    return image_iter->second;
864
865  ThemeImagePngSource::PngMap png_map;
866  for (size_t i = 0; i < scale_factors_.size(); ++i) {
867    scoped_refptr<base::RefCountedMemory> memory =
868        GetRawData(idr_id, scale_factors_[i]);
869    if (memory.get())
870      png_map[scale_factors_[i]] = memory;
871  }
872  if (!png_map.empty()) {
873    gfx::ImageSkia image_skia(new ThemeImagePngSource(png_map),
874                              ui::SCALE_FACTOR_100P);
875    // |image_skia| takes ownership of ThemeImagePngSource.
876    gfx::Image ret = gfx::Image(image_skia);
877    images_on_ui_thread_[prs_id] = ret;
878    return ret;
879  }
880
881  return gfx::Image();
882}
883
884base::RefCountedMemory* BrowserThemePack::GetRawData(
885    int idr_id,
886    ui::ScaleFactor scale_factor) const {
887  base::RefCountedMemory* memory = NULL;
888  int prs_id = GetPersistentIDByIDR(idr_id);
889  int raw_id = GetRawIDByPersistentID(prs_id, scale_factor);
890
891  if (raw_id != -1) {
892    if (data_pack_.get()) {
893      memory = data_pack_->GetStaticMemory(raw_id);
894    } else {
895      RawImages::const_iterator it = image_memory_.find(raw_id);
896      if (it != image_memory_.end()) {
897        memory = it->second.get();
898      }
899    }
900  }
901
902  return memory;
903}
904
905bool BrowserThemePack::HasCustomImage(int idr_id) const {
906  int prs_id = GetPersistentIDByIDR(idr_id);
907  if (prs_id == -1)
908    return false;
909
910  int* img = source_images_;
911  for (; *img != -1; ++img) {
912    if (*img == prs_id)
913      return true;
914  }
915
916  return false;
917}
918
919// private:
920
921BrowserThemePack::BrowserThemePack()
922    : CustomThemeSupplier(EXTENSION),
923      header_(NULL),
924      tints_(NULL),
925      colors_(NULL),
926      display_properties_(NULL),
927      source_images_(NULL) {
928  scale_factors_ = ui::GetSupportedScaleFactors();
929}
930
931void BrowserThemePack::BuildHeader(const Extension* extension) {
932  header_ = new BrowserThemePackHeader;
933  header_->version = kThemePackVersion;
934
935  // TODO(erg): Need to make this endian safe on other computers. Prerequisite
936  // is that ui::DataPack removes this same check.
937#if defined(__BYTE_ORDER)
938  // Linux check
939  COMPILE_ASSERT(__BYTE_ORDER == __LITTLE_ENDIAN,
940                 datapack_assumes_little_endian);
941#elif defined(__BIG_ENDIAN__)
942  // Mac check
943  #error DataPack assumes little endian
944#endif
945  header_->little_endian = 1;
946
947  const std::string& id = extension->id();
948  memcpy(header_->theme_id, id.c_str(), extensions::id_util::kIdSize);
949}
950
951void BrowserThemePack::BuildTintsFromJSON(
952    const base::DictionaryValue* tints_value) {
953  tints_ = new TintEntry[kTintTableLength];
954  for (size_t i = 0; i < kTintTableLength; ++i) {
955    tints_[i].id = -1;
956    tints_[i].h = -1;
957    tints_[i].s = -1;
958    tints_[i].l = -1;
959  }
960
961  if (!tints_value)
962    return;
963
964  // Parse the incoming data from |tints_value| into an intermediary structure.
965  std::map<int, color_utils::HSL> temp_tints;
966  for (base::DictionaryValue::Iterator iter(*tints_value); !iter.IsAtEnd();
967       iter.Advance()) {
968    const base::ListValue* tint_list;
969    if (iter.value().GetAsList(&tint_list) &&
970        (tint_list->GetSize() == 3)) {
971      color_utils::HSL hsl = { -1, -1, -1 };
972
973      if (tint_list->GetDouble(0, &hsl.h) &&
974          tint_list->GetDouble(1, &hsl.s) &&
975          tint_list->GetDouble(2, &hsl.l)) {
976        int id = GetIntForString(iter.key(), kTintTable, kTintTableLength);
977        if (id != -1) {
978          temp_tints[id] = hsl;
979        }
980      }
981    }
982  }
983
984  // Copy data from the intermediary data structure to the array.
985  size_t count = 0;
986  for (std::map<int, color_utils::HSL>::const_iterator it =
987           temp_tints.begin();
988       it != temp_tints.end() && count < kTintTableLength;
989       ++it, ++count) {
990    tints_[count].id = it->first;
991    tints_[count].h = it->second.h;
992    tints_[count].s = it->second.s;
993    tints_[count].l = it->second.l;
994  }
995}
996
997void BrowserThemePack::BuildColorsFromJSON(
998    const base::DictionaryValue* colors_value) {
999  colors_ = new ColorPair[kColorTableLength];
1000  for (size_t i = 0; i < kColorTableLength; ++i) {
1001    colors_[i].id = -1;
1002    colors_[i].color = SkColorSetRGB(0, 0, 0);
1003  }
1004
1005  std::map<int, SkColor> temp_colors;
1006  if (colors_value)
1007    ReadColorsFromJSON(colors_value, &temp_colors);
1008  GenerateMissingColors(&temp_colors);
1009
1010  // Copy data from the intermediary data structure to the array.
1011  size_t count = 0;
1012  for (std::map<int, SkColor>::const_iterator it = temp_colors.begin();
1013       it != temp_colors.end() && count < kColorTableLength; ++it, ++count) {
1014    colors_[count].id = it->first;
1015    colors_[count].color = it->second;
1016  }
1017}
1018
1019void BrowserThemePack::ReadColorsFromJSON(
1020    const base::DictionaryValue* colors_value,
1021    std::map<int, SkColor>* temp_colors) {
1022  // Parse the incoming data from |colors_value| into an intermediary structure.
1023  for (base::DictionaryValue::Iterator iter(*colors_value); !iter.IsAtEnd();
1024       iter.Advance()) {
1025    const base::ListValue* color_list;
1026    if (iter.value().GetAsList(&color_list) &&
1027        ((color_list->GetSize() == 3) || (color_list->GetSize() == 4))) {
1028      SkColor color = SK_ColorWHITE;
1029      int r, g, b;
1030      if (color_list->GetInteger(0, &r) &&
1031          color_list->GetInteger(1, &g) &&
1032          color_list->GetInteger(2, &b)) {
1033        if (color_list->GetSize() == 4) {
1034          double alpha;
1035          int alpha_int;
1036          if (color_list->GetDouble(3, &alpha)) {
1037            color = SkColorSetARGB(static_cast<int>(alpha * 255), r, g, b);
1038          } else if (color_list->GetInteger(3, &alpha_int) &&
1039                     (alpha_int == 0 || alpha_int == 1)) {
1040            color = SkColorSetARGB(alpha_int ? 255 : 0, r, g, b);
1041          } else {
1042            // Invalid entry for part 4.
1043            continue;
1044          }
1045        } else {
1046          color = SkColorSetRGB(r, g, b);
1047        }
1048
1049        int id = GetIntForString(iter.key(), kColorTable, kColorTableLength);
1050        if (id != -1) {
1051          (*temp_colors)[id] = color;
1052        }
1053      }
1054    }
1055  }
1056}
1057
1058void BrowserThemePack::GenerateMissingColors(
1059    std::map<int, SkColor>* colors) {
1060  // Generate link colors, if missing. (See GetColor()).
1061  if (!colors->count(ThemeProperties::COLOR_NTP_HEADER) &&
1062      colors->count(ThemeProperties::COLOR_NTP_SECTION)) {
1063    (*colors)[ThemeProperties::COLOR_NTP_HEADER] =
1064        (*colors)[ThemeProperties::COLOR_NTP_SECTION];
1065  }
1066
1067  if (!colors->count(ThemeProperties::COLOR_NTP_SECTION_LINK_UNDERLINE) &&
1068      colors->count(ThemeProperties::COLOR_NTP_SECTION_LINK)) {
1069    SkColor color_section_link =
1070        (*colors)[ThemeProperties::COLOR_NTP_SECTION_LINK];
1071    (*colors)[ThemeProperties::COLOR_NTP_SECTION_LINK_UNDERLINE] =
1072        SkColorSetA(color_section_link, SkColorGetA(color_section_link) / 3);
1073  }
1074
1075  if (!colors->count(ThemeProperties::COLOR_NTP_LINK_UNDERLINE) &&
1076      colors->count(ThemeProperties::COLOR_NTP_LINK)) {
1077    SkColor color_link = (*colors)[ThemeProperties::COLOR_NTP_LINK];
1078    (*colors)[ThemeProperties::COLOR_NTP_LINK_UNDERLINE] =
1079        SkColorSetA(color_link, SkColorGetA(color_link) / 3);
1080  }
1081
1082  // Generate frame colors, if missing. (See GenerateFrameColors()).
1083  SkColor frame;
1084  std::map<int, SkColor>::const_iterator it =
1085      colors->find(ThemeProperties::COLOR_FRAME);
1086  if (it != colors->end()) {
1087    frame = it->second;
1088  } else {
1089    frame = ThemeProperties::GetDefaultColor(
1090        ThemeProperties::COLOR_FRAME);
1091  }
1092
1093  if (!colors->count(ThemeProperties::COLOR_FRAME)) {
1094    (*colors)[ThemeProperties::COLOR_FRAME] =
1095        HSLShift(frame, GetTintInternal(ThemeProperties::TINT_FRAME));
1096  }
1097  if (!colors->count(ThemeProperties::COLOR_FRAME_INACTIVE)) {
1098    (*colors)[ThemeProperties::COLOR_FRAME_INACTIVE] =
1099        HSLShift(frame, GetTintInternal(
1100            ThemeProperties::TINT_FRAME_INACTIVE));
1101  }
1102  if (!colors->count(ThemeProperties::COLOR_FRAME_INCOGNITO)) {
1103    (*colors)[ThemeProperties::COLOR_FRAME_INCOGNITO] =
1104        HSLShift(frame, GetTintInternal(
1105            ThemeProperties::TINT_FRAME_INCOGNITO));
1106  }
1107  if (!colors->count(ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE)) {
1108    (*colors)[ThemeProperties::COLOR_FRAME_INCOGNITO_INACTIVE] =
1109        HSLShift(frame, GetTintInternal(
1110            ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE));
1111  }
1112}
1113
1114void BrowserThemePack::BuildDisplayPropertiesFromJSON(
1115    const base::DictionaryValue* display_properties_value) {
1116  display_properties_ = new DisplayPropertyPair[kDisplayPropertiesSize];
1117  for (size_t i = 0; i < kDisplayPropertiesSize; ++i) {
1118    display_properties_[i].id = -1;
1119    display_properties_[i].property = 0;
1120  }
1121
1122  if (!display_properties_value)
1123    return;
1124
1125  std::map<int, int> temp_properties;
1126  for (base::DictionaryValue::Iterator iter(*display_properties_value);
1127       !iter.IsAtEnd(); iter.Advance()) {
1128    int property_id = GetIntForString(iter.key(), kDisplayProperties,
1129                                      kDisplayPropertiesSize);
1130    switch (property_id) {
1131      case ThemeProperties::NTP_BACKGROUND_ALIGNMENT: {
1132        std::string val;
1133        if (iter.value().GetAsString(&val)) {
1134          temp_properties[ThemeProperties::NTP_BACKGROUND_ALIGNMENT] =
1135              ThemeProperties::StringToAlignment(val);
1136        }
1137        break;
1138      }
1139      case ThemeProperties::NTP_BACKGROUND_TILING: {
1140        std::string val;
1141        if (iter.value().GetAsString(&val)) {
1142          temp_properties[ThemeProperties::NTP_BACKGROUND_TILING] =
1143              ThemeProperties::StringToTiling(val);
1144        }
1145        break;
1146      }
1147      case ThemeProperties::NTP_LOGO_ALTERNATE: {
1148        int val = 0;
1149        if (iter.value().GetAsInteger(&val))
1150          temp_properties[ThemeProperties::NTP_LOGO_ALTERNATE] = val;
1151        break;
1152      }
1153    }
1154  }
1155
1156  // Copy data from the intermediary data structure to the array.
1157  size_t count = 0;
1158  for (std::map<int, int>::const_iterator it = temp_properties.begin();
1159       it != temp_properties.end() && count < kDisplayPropertiesSize;
1160       ++it, ++count) {
1161    display_properties_[count].id = it->first;
1162    display_properties_[count].property = it->second;
1163  }
1164}
1165
1166void BrowserThemePack::ParseImageNamesFromJSON(
1167    const base::DictionaryValue* images_value,
1168    const base::FilePath& images_path,
1169    FilePathMap* file_paths) const {
1170  if (!images_value)
1171    return;
1172
1173  for (base::DictionaryValue::Iterator iter(*images_value); !iter.IsAtEnd();
1174       iter.Advance()) {
1175    if (iter.value().IsType(base::Value::TYPE_DICTIONARY)) {
1176      const base::DictionaryValue* inner_value = NULL;
1177      if (iter.value().GetAsDictionary(&inner_value)) {
1178        for (base::DictionaryValue::Iterator inner_iter(*inner_value);
1179             !inner_iter.IsAtEnd();
1180             inner_iter.Advance()) {
1181          std::string name;
1182          ui::ScaleFactor scale_factor = ui::SCALE_FACTOR_NONE;
1183          if (GetScaleFactorFromManifestKey(inner_iter.key(), &scale_factor) &&
1184              inner_iter.value().IsType(base::Value::TYPE_STRING) &&
1185              inner_iter.value().GetAsString(&name)) {
1186            AddFileAtScaleToMap(iter.key(),
1187                                scale_factor,
1188                                images_path.AppendASCII(name),
1189                                file_paths);
1190          }
1191        }
1192      }
1193    } else if (iter.value().IsType(base::Value::TYPE_STRING)) {
1194      std::string name;
1195      if (iter.value().GetAsString(&name)) {
1196        AddFileAtScaleToMap(iter.key(),
1197                            ui::SCALE_FACTOR_100P,
1198                            images_path.AppendASCII(name),
1199                            file_paths);
1200      }
1201    }
1202  }
1203}
1204
1205void BrowserThemePack::AddFileAtScaleToMap(const std::string& image_name,
1206                                           ui::ScaleFactor scale_factor,
1207                                           const base::FilePath& image_path,
1208                                           FilePathMap* file_paths) const {
1209  int id = GetPersistentIDByName(image_name);
1210  if (id != -1)
1211    (*file_paths)[id][scale_factor] = image_path;
1212#if defined(OS_WIN)
1213  id = GetPersistentIDByNameHelper(image_name,
1214                                   kPersistingImagesWinDesktopAura,
1215                                   kPersistingImagesWinDesktopAuraLength);
1216  if (id != -1)
1217    (*file_paths)[id][scale_factor] = image_path;
1218#endif
1219}
1220
1221void BrowserThemePack::BuildSourceImagesArray(const FilePathMap& file_paths) {
1222  std::vector<int> ids;
1223  for (FilePathMap::const_iterator it = file_paths.begin();
1224       it != file_paths.end(); ++it) {
1225    ids.push_back(it->first);
1226  }
1227
1228  source_images_ = new int[ids.size() + 1];
1229  std::copy(ids.begin(), ids.end(), source_images_);
1230  source_images_[ids.size()] = -1;
1231}
1232
1233bool BrowserThemePack::LoadRawBitmapsTo(
1234    const FilePathMap& file_paths,
1235    ImageCache* image_cache) {
1236  // Themes should be loaded on the file thread, not the UI thread.
1237  // http://crbug.com/61838
1238  base::ThreadRestrictions::ScopedAllowIO allow_io;
1239
1240  for (FilePathMap::const_iterator it = file_paths.begin();
1241       it != file_paths.end(); ++it) {
1242    int prs_id = it->first;
1243    // Some images need to go directly into |image_memory_|. No modification is
1244    // necessary or desirable.
1245    bool is_copyable = false;
1246    for (size_t i = 0; i < arraysize(kPreloadIDs); ++i) {
1247      if (kPreloadIDs[i] == prs_id) {
1248        is_copyable = true;
1249        break;
1250      }
1251    }
1252    gfx::ImageSkia image_skia;
1253    for (int pass = 0; pass < 2; ++pass) {
1254      // Two passes: In the first pass, we process only scale factor
1255      // 100% and in the second pass all other scale factors. We
1256      // process scale factor 100% first because the first image added
1257      // in image_skia.AddRepresentation() determines the DIP size for
1258      // all representations.
1259      for (ScaleFactorToFileMap::const_iterator s2f = it->second.begin();
1260           s2f != it->second.end(); ++s2f) {
1261        ui::ScaleFactor scale_factor = s2f->first;
1262        if ((pass == 0 && scale_factor != ui::SCALE_FACTOR_100P) ||
1263            (pass == 1 && scale_factor == ui::SCALE_FACTOR_100P)) {
1264          continue;
1265        }
1266        scoped_refptr<base::RefCountedMemory> raw_data(
1267            ReadFileData(s2f->second));
1268        if (!raw_data.get() || !raw_data->size()) {
1269          LOG(ERROR) << "Could not load theme image"
1270                     << " prs_id=" << prs_id
1271                     << " scale_factor_enum=" << scale_factor
1272                     << " file=" << s2f->second.value()
1273                     << (raw_data.get() ? " (zero size)" : " (read error)");
1274          return false;
1275        }
1276        if (is_copyable) {
1277          int raw_id = GetRawIDByPersistentID(prs_id, scale_factor);
1278          image_memory_[raw_id] = raw_data;
1279        } else {
1280          SkBitmap bitmap;
1281          if (gfx::PNGCodec::Decode(raw_data->front(), raw_data->size(),
1282                                    &bitmap)) {
1283            image_skia.AddRepresentation(
1284                gfx::ImageSkiaRep(bitmap,
1285                                  ui::GetImageScale(scale_factor)));
1286          } else {
1287            NOTREACHED() << "Unable to decode theme image resource "
1288                         << it->first;
1289          }
1290        }
1291      }
1292    }
1293    if (!is_copyable && !image_skia.isNull())
1294      (*image_cache)[prs_id] = gfx::Image(image_skia);
1295  }
1296
1297  return true;
1298}
1299
1300void BrowserThemePack::CreateImages(ImageCache* images) const {
1301  CropImages(images);
1302  CreateFrameImages(images);
1303  CreateTintedButtons(GetTintInternal(ThemeProperties::TINT_BUTTONS), images);
1304  CreateTabBackgroundImages(images);
1305}
1306
1307void BrowserThemePack::CropImages(ImageCache* images) const {
1308  bool has_frame_border = HasFrameBorder();
1309  for (size_t i = 0; i < arraysize(kImagesToCrop); ++i) {
1310    if (has_frame_border && kImagesToCrop[i].skip_if_frame_border)
1311      continue;
1312
1313    int prs_id = kImagesToCrop[i].prs_id;
1314    ImageCache::iterator it = images->find(prs_id);
1315    if (it == images->end())
1316      continue;
1317
1318    int crop_height = kImagesToCrop[i].max_height;
1319    gfx::ImageSkia image_skia = it->second.AsImageSkia();
1320    (*images)[prs_id] = gfx::Image(gfx::ImageSkiaOperations::ExtractSubset(
1321        image_skia, gfx::Rect(0, 0, image_skia.width(), crop_height)));
1322  }
1323}
1324
1325void BrowserThemePack::CreateFrameImages(ImageCache* images) const {
1326  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
1327
1328  // Create all the output images in a separate cache and move them back into
1329  // the input images because there can be name collisions.
1330  ImageCache temp_output;
1331
1332  for (size_t i = 0; i < arraysize(kFrameTintMap); ++i) {
1333    int prs_id = kFrameTintMap[i].key;
1334    gfx::Image frame;
1335    // If there's no frame image provided for the specified id, then load
1336    // the default provided frame. If that's not provided, skip this whole
1337    // thing and just use the default images.
1338    int prs_base_id = 0;
1339
1340#if defined(OS_WIN)
1341    if (prs_id == PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN) {
1342      prs_base_id = images->count(PRS_THEME_FRAME_INCOGNITO_WIN) ?
1343                    PRS_THEME_FRAME_INCOGNITO_WIN : PRS_THEME_FRAME_WIN;
1344    } else if (prs_id == PRS_THEME_FRAME_INACTIVE_WIN) {
1345      prs_base_id = PRS_THEME_FRAME_WIN;
1346    } else if (prs_id == PRS_THEME_FRAME_INCOGNITO_WIN &&
1347                !images->count(PRS_THEME_FRAME_INCOGNITO_WIN)) {
1348      prs_base_id = PRS_THEME_FRAME_WIN;
1349    }
1350#endif
1351    if (!prs_base_id) {
1352      if (prs_id == PRS_THEME_FRAME_INCOGNITO_INACTIVE) {
1353        prs_base_id = images->count(PRS_THEME_FRAME_INCOGNITO) ?
1354                      PRS_THEME_FRAME_INCOGNITO : PRS_THEME_FRAME;
1355      } else if (prs_id == PRS_THEME_FRAME_OVERLAY_INACTIVE) {
1356        prs_base_id = PRS_THEME_FRAME_OVERLAY;
1357      } else if (prs_id == PRS_THEME_FRAME_INACTIVE) {
1358        prs_base_id = PRS_THEME_FRAME;
1359      } else if (prs_id == PRS_THEME_FRAME_INCOGNITO &&
1360                 !images->count(PRS_THEME_FRAME_INCOGNITO)) {
1361        prs_base_id = PRS_THEME_FRAME;
1362      } else {
1363        prs_base_id = prs_id;
1364      }
1365    }
1366    if (images->count(prs_id)) {
1367      frame = (*images)[prs_id];
1368    } else if (prs_base_id != prs_id && images->count(prs_base_id)) {
1369      frame = (*images)[prs_base_id];
1370    } else if (prs_base_id == PRS_THEME_FRAME_OVERLAY) {
1371#if defined(OS_WIN)
1372      if (images->count(PRS_THEME_FRAME_WIN)) {
1373#else
1374      if (images->count(PRS_THEME_FRAME)) {
1375#endif
1376        // If there is no theme overlay, don't tint the default frame,
1377        // because it will overwrite the custom frame image when we cache and
1378        // reload from disk.
1379        frame = gfx::Image();
1380      }
1381    } else {
1382      // If the theme doesn't specify an image, then apply the tint to
1383      // the default frame.
1384      frame = rb.GetImageNamed(IDR_THEME_FRAME);
1385#if defined(OS_WIN) && defined(USE_AURA)
1386      if (prs_id >= PRS_THEME_FRAME_WIN &&
1387          prs_id <= PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN) {
1388        frame = rb.GetImageNamed(IDR_THEME_FRAME_WIN);
1389      }
1390#endif
1391    }
1392    if (!frame.IsEmpty()) {
1393      temp_output[prs_id] = CreateHSLShiftedImage(
1394          frame, GetTintInternal(kFrameTintMap[i].value));
1395    }
1396  }
1397  MergeImageCaches(temp_output, images);
1398}
1399
1400void BrowserThemePack::CreateTintedButtons(
1401    const color_utils::HSL& button_tint,
1402    ImageCache* processed_images) const {
1403  if (button_tint.h != -1 || button_tint.s != -1 || button_tint.l != -1) {
1404    ResourceBundle& rb = ResourceBundle::GetSharedInstance();
1405    const std::set<int>& idr_ids =
1406        ThemeProperties::GetTintableToolbarButtons();
1407    for (std::set<int>::const_iterator it = idr_ids.begin();
1408         it != idr_ids.end(); ++it) {
1409      int prs_id = GetPersistentIDByIDR(*it);
1410      DCHECK(prs_id > 0);
1411
1412      // Fetch the image by IDR...
1413      gfx::Image& button = rb.GetImageNamed(*it);
1414
1415      // but save a version with the persistent ID.
1416      (*processed_images)[prs_id] =
1417          CreateHSLShiftedImage(button, button_tint);
1418    }
1419  }
1420}
1421
1422void BrowserThemePack::CreateTabBackgroundImages(ImageCache* images) const {
1423  ImageCache temp_output;
1424  for (size_t i = 0; i < arraysize(kTabBackgroundMap); ++i) {
1425    int prs_id = kTabBackgroundMap[i].key;
1426    int prs_base_id = kTabBackgroundMap[i].value;
1427
1428    // We only need to generate the background tab images if we were provided
1429    // with a PRS_THEME_FRAME.
1430    ImageCache::const_iterator it = images->find(prs_base_id);
1431    if (it != images->end()) {
1432      gfx::ImageSkia image_to_tint = (it->second).AsImageSkia();
1433      color_utils::HSL hsl_shift = GetTintInternal(
1434          ThemeProperties::TINT_BACKGROUND_TAB);
1435      int vertical_offset = images->count(prs_id)
1436                            ? kRestoredTabVerticalOffset : 0;
1437
1438      gfx::ImageSkia overlay;
1439      ImageCache::const_iterator overlay_it = images->find(prs_id);
1440      if (overlay_it != images->end())
1441        overlay = overlay_it->second.AsImageSkia();
1442
1443      gfx::ImageSkiaSource* source = new TabBackgroundImageSource(
1444          image_to_tint, overlay, hsl_shift, vertical_offset);
1445      // ImageSkia takes ownership of |source|.
1446      temp_output[prs_id] = gfx::Image(gfx::ImageSkia(source,
1447          image_to_tint.size()));
1448    }
1449  }
1450  MergeImageCaches(temp_output, images);
1451}
1452
1453void BrowserThemePack::RepackImages(const ImageCache& images,
1454                                    RawImages* reencoded_images) const {
1455  typedef std::vector<ui::ScaleFactor> ScaleFactors;
1456  for (ImageCache::const_iterator it = images.begin();
1457       it != images.end(); ++it) {
1458    gfx::ImageSkia image_skia = *it->second.ToImageSkia();
1459
1460    typedef std::vector<gfx::ImageSkiaRep> ImageSkiaReps;
1461    ImageSkiaReps image_reps = image_skia.image_reps();
1462    if (image_reps.empty()) {
1463      NOTREACHED() << "No image reps for resource " << it->first << ".";
1464    }
1465    for (ImageSkiaReps::iterator rep_it = image_reps.begin();
1466         rep_it != image_reps.end(); ++rep_it) {
1467      std::vector<unsigned char> bitmap_data;
1468      if (!gfx::PNGCodec::EncodeBGRASkBitmap(rep_it->sk_bitmap(), false,
1469                                             &bitmap_data)) {
1470        NOTREACHED() << "Image file for resource " << it->first
1471                     << " could not be encoded.";
1472      }
1473      int raw_id = GetRawIDByPersistentID(
1474          it->first,
1475          ui::GetSupportedScaleFactor(rep_it->scale()));
1476      (*reencoded_images)[raw_id] =
1477          base::RefCountedBytes::TakeVector(&bitmap_data);
1478    }
1479  }
1480}
1481
1482void BrowserThemePack::MergeImageCaches(
1483    const ImageCache& source, ImageCache* destination) const {
1484  for (ImageCache::const_iterator it = source.begin(); it != source.end();
1485       ++it) {
1486    (*destination)[it->first] = it->second;
1487  }
1488}
1489
1490void BrowserThemePack::AddRawImagesTo(const RawImages& images,
1491                                      RawDataForWriting* out) const {
1492  for (RawImages::const_iterator it = images.begin(); it != images.end();
1493       ++it) {
1494    (*out)[it->first] = base::StringPiece(
1495        it->second->front_as<char>(), it->second->size());
1496  }
1497}
1498
1499color_utils::HSL BrowserThemePack::GetTintInternal(int id) const {
1500  if (tints_) {
1501    for (size_t i = 0; i < kTintTableLength; ++i) {
1502      if (tints_[i].id == id) {
1503        color_utils::HSL hsl;
1504        hsl.h = tints_[i].h;
1505        hsl.s = tints_[i].s;
1506        hsl.l = tints_[i].l;
1507        return hsl;
1508      }
1509    }
1510  }
1511
1512  return ThemeProperties::GetDefaultTint(id);
1513}
1514
1515int BrowserThemePack::GetRawIDByPersistentID(
1516    int prs_id,
1517    ui::ScaleFactor scale_factor) const {
1518  if (prs_id < 0)
1519    return -1;
1520
1521  for (size_t i = 0; i < scale_factors_.size(); ++i) {
1522    if (scale_factors_[i] == scale_factor)
1523      return static_cast<int>(kPersistingImagesLength * i) + prs_id;
1524  }
1525  return -1;
1526}
1527
1528bool BrowserThemePack::GetScaleFactorFromManifestKey(
1529    const std::string& key,
1530    ui::ScaleFactor* scale_factor) const {
1531  int percent = 0;
1532  if (base::StringToInt(key, &percent)) {
1533    float scale = static_cast<float>(percent) / 100.0f;
1534    for (size_t i = 0; i < scale_factors_.size(); ++i) {
1535      if (fabs(ui::GetImageScale(scale_factors_[i]) - scale) < 0.001) {
1536        *scale_factor = scale_factors_[i];
1537        return true;
1538      }
1539    }
1540  }
1541  return false;
1542}
1543
1544void BrowserThemePack::GenerateRawImageForAllSupportedScales(int prs_id) {
1545  // Compute (by scaling) bitmaps for |prs_id| for any scale factors
1546  // for which the theme author did not provide a bitmap. We compute
1547  // the bitmaps using the highest scale factor that theme author
1548  // provided.
1549  // Note: We use only supported scale factors. For example, if scale
1550  // factor 2x is supported by the current system, but 1.8x is not and
1551  // if the theme author did not provide an image for 2x but one for
1552  // 1.8x, we will not use the 1.8x image here. Here we will only use
1553  // images provided for scale factors supported by the current system.
1554
1555  // See if any image is missing. If not, we're done.
1556  bool image_missing = false;
1557  for (size_t i = 0; i < scale_factors_.size(); ++i) {
1558    int raw_id = GetRawIDByPersistentID(prs_id, scale_factors_[i]);
1559    if (image_memory_.find(raw_id) == image_memory_.end()) {
1560      image_missing = true;
1561      break;
1562    }
1563  }
1564  if (!image_missing)
1565    return;
1566
1567  // Find available scale factor with highest scale.
1568  ui::ScaleFactor available_scale_factor = ui::SCALE_FACTOR_NONE;
1569  for (size_t i = 0; i < scale_factors_.size(); ++i) {
1570    int raw_id = GetRawIDByPersistentID(prs_id, scale_factors_[i]);
1571    if ((available_scale_factor == ui::SCALE_FACTOR_NONE ||
1572         (ui::GetImageScale(scale_factors_[i]) >
1573          ui::GetImageScale(available_scale_factor))) &&
1574        image_memory_.find(raw_id) != image_memory_.end()) {
1575      available_scale_factor = scale_factors_[i];
1576    }
1577  }
1578  // If no scale factor is available, we're done.
1579  if (available_scale_factor == ui::SCALE_FACTOR_NONE)
1580    return;
1581
1582  // Get bitmap for the available scale factor.
1583  int available_raw_id = GetRawIDByPersistentID(prs_id, available_scale_factor);
1584  RawImages::const_iterator it = image_memory_.find(available_raw_id);
1585  SkBitmap available_bitmap;
1586  if (!gfx::PNGCodec::Decode(it->second->front(),
1587                             it->second->size(),
1588                             &available_bitmap)) {
1589    NOTREACHED() << "Unable to decode theme image for prs_id="
1590                 << prs_id << " for scale_factor=" << available_scale_factor;
1591    return;
1592  }
1593
1594  // Fill in all missing scale factors by scaling the available bitmap.
1595  for (size_t i = 0; i < scale_factors_.size(); ++i) {
1596    int scaled_raw_id = GetRawIDByPersistentID(prs_id, scale_factors_[i]);
1597    if (image_memory_.find(scaled_raw_id) != image_memory_.end())
1598      continue;
1599    SkBitmap scaled_bitmap =
1600        CreateLowQualityResizedBitmap(available_bitmap,
1601                                      available_scale_factor,
1602                                      scale_factors_[i]);
1603    std::vector<unsigned char> bitmap_data;
1604    if (!gfx::PNGCodec::EncodeBGRASkBitmap(scaled_bitmap,
1605                                           false,
1606                                           &bitmap_data)) {
1607      NOTREACHED() << "Unable to encode theme image for prs_id="
1608                   << prs_id << " for scale_factor=" << scale_factors_[i];
1609      break;
1610    }
1611    image_memory_[scaled_raw_id] =
1612        base::RefCountedBytes::TakeVector(&bitmap_data);
1613  }
1614}
1615