1// Copyright (c) 2011 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 "base/stl_util-inl.h"
8#include "base/string_util.h"
9#include "base/threading/thread_restrictions.h"
10#include "base/utf_string_conversions.h"
11#include "base/values.h"
12#include "chrome/browser/themes/theme_service.h"
13#include "content/browser/browser_thread.h"
14#include "grit/app_resources.h"
15#include "grit/theme_resources.h"
16#include "net/base/file_stream.h"
17#include "net/base/net_errors.h"
18#include "third_party/skia/include/core/SkCanvas.h"
19#include "ui/base/resource/data_pack.h"
20#include "ui/base/resource/resource_bundle.h"
21#include "ui/gfx/codec/png_codec.h"
22#include "ui/gfx/skbitmap_operations.h"
23
24namespace {
25
26// Version number of the current theme pack. We just throw out and rebuild
27// theme packs that aren't int-equal to this.
28const int kThemePackVersion = 15;
29
30// IDs that are in the DataPack won't clash with the positive integer
31// int32_t. kHeaderID should always have the maximum value because we want the
32// "header" to be written last. That way we can detect whether the pack was
33// successfully written and ignore and regenerate if it was only partially
34// written (i.e. chrome crashed on a different thread while writing the pack).
35const int kHeaderID = UINT_MAX - 1;
36const int kTintsID = UINT_MAX - 2;
37const int kColorsID = UINT_MAX - 3;
38const int kDisplayPropertiesID = UINT_MAX - 4;
39const int kSourceImagesID = UINT_MAX - 5;
40
41// Static size of the tint/color/display property arrays that are mmapped.
42const int kTintArraySize = 6;
43const int kColorArraySize = 19;
44const int kDisplayPropertySize = 3;
45
46// The sum of kFrameBorderThickness and kNonClientRestoredExtraThickness from
47// OpaqueBrowserFrameView.
48const int kRestoredTabVerticalOffset = 15;
49
50// Persistent constants for the main images that we need. These have the same
51// names as their IDR_* counterparts but these values will always stay the
52// same.
53const int PRS_THEME_FRAME = 1;
54const int PRS_THEME_FRAME_INACTIVE = 2;
55const int PRS_THEME_FRAME_INCOGNITO = 3;
56const int PRS_THEME_FRAME_INCOGNITO_INACTIVE = 4;
57const int PRS_THEME_TOOLBAR = 5;
58const int PRS_THEME_TAB_BACKGROUND = 6;
59const int PRS_THEME_TAB_BACKGROUND_INCOGNITO = 7;
60const int PRS_THEME_TAB_BACKGROUND_V = 8;
61const int PRS_THEME_NTP_BACKGROUND = 9;
62const int PRS_THEME_FRAME_OVERLAY = 10;
63const int PRS_THEME_FRAME_OVERLAY_INACTIVE = 11;
64const int PRS_THEME_BUTTON_BACKGROUND = 12;
65const int PRS_THEME_NTP_ATTRIBUTION = 13;
66const int PRS_THEME_WINDOW_CONTROL_BACKGROUND = 14;
67
68struct PersistingImagesTable {
69  // A non-changing integer ID meant to be saved in theme packs. This ID must
70  // not change between versions of chrome.
71  int persistent_id;
72
73  // The IDR that depends on the whims of GRIT and therefore changes whenever
74  // someone adds a new resource.
75  int idr_id;
76
77  // String to check for when parsing theme manifests or NULL if this isn't
78  // supposed to be changeable by the user.
79  const char* key;
80};
81
82// IDR_* resource names change whenever new resources are added; use persistent
83// IDs when storing to a cached pack.
84PersistingImagesTable kPersistingImages[] = {
85  { PRS_THEME_FRAME, IDR_THEME_FRAME,
86    "theme_frame" },
87  { PRS_THEME_FRAME_INACTIVE, IDR_THEME_FRAME_INACTIVE,
88    "theme_frame_inactive" },
89  { PRS_THEME_FRAME_INCOGNITO, IDR_THEME_FRAME_INCOGNITO,
90    "theme_frame_incognito" },
91  { PRS_THEME_FRAME_INCOGNITO_INACTIVE, IDR_THEME_FRAME_INCOGNITO_INACTIVE,
92    "theme_frame_incognito_inactive" },
93  { PRS_THEME_TOOLBAR, IDR_THEME_TOOLBAR,
94    "theme_toolbar" },
95  { PRS_THEME_TAB_BACKGROUND, IDR_THEME_TAB_BACKGROUND,
96    "theme_tab_background" },
97  { PRS_THEME_TAB_BACKGROUND_INCOGNITO, IDR_THEME_TAB_BACKGROUND_INCOGNITO,
98    "theme_tab_background_incognito" },
99  { PRS_THEME_TAB_BACKGROUND_V, IDR_THEME_TAB_BACKGROUND_V,
100    "theme_tab_background_v"},
101  { PRS_THEME_NTP_BACKGROUND, IDR_THEME_NTP_BACKGROUND,
102    "theme_ntp_background" },
103  { PRS_THEME_FRAME_OVERLAY, IDR_THEME_FRAME_OVERLAY,
104    "theme_frame_overlay" },
105  { PRS_THEME_FRAME_OVERLAY_INACTIVE, IDR_THEME_FRAME_OVERLAY_INACTIVE,
106    "theme_frame_overlay_inactive" },
107  { PRS_THEME_BUTTON_BACKGROUND, IDR_THEME_BUTTON_BACKGROUND,
108    "theme_button_background" },
109  { PRS_THEME_NTP_ATTRIBUTION, IDR_THEME_NTP_ATTRIBUTION,
110    "theme_ntp_attribution" },
111  { PRS_THEME_WINDOW_CONTROL_BACKGROUND, IDR_THEME_WINDOW_CONTROL_BACKGROUND,
112    "theme_window_control_background"},
113
114  // The rest of these entries have no key because they can't be overridden
115  // from the json manifest.
116  { 15, IDR_BACK, NULL },
117  { 16, IDR_BACK_D, NULL },
118  { 17, IDR_BACK_H, NULL },
119  { 18, IDR_BACK_P, NULL },
120  { 19, IDR_FORWARD, NULL },
121  { 20, IDR_FORWARD_D, NULL },
122  { 21, IDR_FORWARD_H, NULL },
123  { 22, IDR_FORWARD_P, NULL },
124  { 23, IDR_HOME, NULL },
125  { 24, IDR_HOME_H, NULL },
126  { 25, IDR_HOME_P, NULL },
127  { 26, IDR_RELOAD, NULL },
128  { 27, IDR_RELOAD_H, NULL },
129  { 28, IDR_RELOAD_P, NULL },
130  { 29, IDR_STOP, NULL },
131  { 30, IDR_STOP_D, NULL },
132  { 31, IDR_STOP_H, NULL },
133  { 32, IDR_STOP_P, NULL },
134  { 33, IDR_LOCATIONBG_C, NULL },
135  { 34, IDR_LOCATIONBG_L, NULL },
136  { 35, IDR_LOCATIONBG_R, NULL },
137  { 36, IDR_BROWSER_ACTIONS_OVERFLOW, NULL },
138  { 37, IDR_BROWSER_ACTIONS_OVERFLOW_H, NULL },
139  { 38, IDR_BROWSER_ACTIONS_OVERFLOW_P, NULL },
140  { 39, IDR_TOOLS, NULL },
141  { 40, IDR_TOOLS_H, NULL },
142  { 41, IDR_TOOLS_P, NULL },
143  { 42, IDR_MENU_DROPARROW, NULL },
144  { 43, IDR_THROBBER, NULL },
145  { 44, IDR_THROBBER_WAITING, NULL },
146  { 45, IDR_THROBBER_LIGHT, NULL },
147};
148
149int GetPersistentIDByName(const std::string& key) {
150  for (size_t i = 0; i < arraysize(kPersistingImages); ++i) {
151    if (kPersistingImages[i].key != NULL &&
152        base::strcasecmp(key.c_str(), kPersistingImages[i].key) == 0) {
153      return kPersistingImages[i].persistent_id;
154    }
155  }
156
157  return -1;
158}
159
160int GetPersistentIDByIDR(int idr) {
161  for (size_t i = 0; i < arraysize(kPersistingImages); ++i) {
162    if (kPersistingImages[i].idr_id == idr) {
163      return kPersistingImages[i].persistent_id;
164    }
165  }
166
167  return -1;
168}
169
170struct StringToIntTable {
171  const char* key;
172  int id;
173};
174
175// Strings used by themes to identify tints in the JSON.
176StringToIntTable kTintTable[] = {
177  { "buttons", ThemeService::TINT_BUTTONS },
178  { "frame", ThemeService::TINT_FRAME },
179  { "frame_inactive", ThemeService::TINT_FRAME_INACTIVE },
180  { "frame_incognito", ThemeService::TINT_FRAME_INCOGNITO },
181  { "frame_incognito_inactive",
182    ThemeService::TINT_FRAME_INCOGNITO_INACTIVE },
183  { "background_tab", ThemeService::TINT_BACKGROUND_TAB },
184  { NULL, 0 }
185};
186
187// Strings used by themes to identify colors in the JSON.
188StringToIntTable kColorTable[] = {
189  { "frame", ThemeService::COLOR_FRAME },
190  { "frame_inactive", ThemeService::COLOR_FRAME_INACTIVE },
191  { "frame_incognito", ThemeService::COLOR_FRAME_INCOGNITO },
192  { "frame_incognito_inactive",
193    ThemeService::COLOR_FRAME_INCOGNITO_INACTIVE },
194  { "toolbar", ThemeService::COLOR_TOOLBAR },
195  { "tab_text", ThemeService::COLOR_TAB_TEXT },
196  { "tab_background_text", ThemeService::COLOR_BACKGROUND_TAB_TEXT },
197  { "bookmark_text", ThemeService::COLOR_BOOKMARK_TEXT },
198  { "ntp_background", ThemeService::COLOR_NTP_BACKGROUND },
199  { "ntp_text", ThemeService::COLOR_NTP_TEXT },
200  { "ntp_link", ThemeService::COLOR_NTP_LINK },
201  { "ntp_link_underline", ThemeService::COLOR_NTP_LINK_UNDERLINE },
202  { "ntp_header", ThemeService::COLOR_NTP_HEADER },
203  { "ntp_section", ThemeService::COLOR_NTP_SECTION },
204  { "ntp_section_text", ThemeService::COLOR_NTP_SECTION_TEXT },
205  { "ntp_section_link", ThemeService::COLOR_NTP_SECTION_LINK },
206  { "ntp_section_link_underline",
207    ThemeService::COLOR_NTP_SECTION_LINK_UNDERLINE },
208  { "control_background", ThemeService::COLOR_CONTROL_BACKGROUND },
209  { "button_background", ThemeService::COLOR_BUTTON_BACKGROUND },
210  { NULL, 0 }
211};
212
213// Strings used by themes to identify display properties keys in JSON.
214StringToIntTable kDisplayProperties[] = {
215  { "ntp_background_alignment",
216    ThemeService::NTP_BACKGROUND_ALIGNMENT },
217  { "ntp_background_repeat", ThemeService::NTP_BACKGROUND_TILING },
218  { "ntp_logo_alternate", ThemeService::NTP_LOGO_ALTERNATE },
219  { NULL, 0 }
220};
221
222// Strings used by the tiling values in JSON.
223StringToIntTable kTilingStrings[] = {
224  { "no-repeat", ThemeService::NO_REPEAT },
225  { "repeat-x", ThemeService::REPEAT_X },
226  { "repeat-y", ThemeService::REPEAT_Y },
227  { "repeat", ThemeService::REPEAT },
228  { NULL, 0 }
229};
230
231int GetIntForString(const std::string& key, StringToIntTable* table) {
232  for (int i = 0; table[i].key != NULL; ++i) {
233    if (base::strcasecmp(key.c_str(), table[i].key) == 0) {
234      return table[i].id;
235    }
236  }
237
238  return -1;
239}
240
241struct IntToIntTable {
242  int key;
243  int value;
244};
245
246// Mapping used in GenerateFrameImages() to associate frame images with the
247// tint ID that should maybe be applied to it.
248IntToIntTable kFrameTintMap[] = {
249  { PRS_THEME_FRAME, ThemeService::TINT_FRAME },
250  { PRS_THEME_FRAME_INACTIVE, ThemeService::TINT_FRAME_INACTIVE },
251  { PRS_THEME_FRAME_OVERLAY, ThemeService::TINT_FRAME },
252  { PRS_THEME_FRAME_OVERLAY_INACTIVE,
253    ThemeService::TINT_FRAME_INACTIVE },
254  { PRS_THEME_FRAME_INCOGNITO, ThemeService::TINT_FRAME_INCOGNITO },
255  { PRS_THEME_FRAME_INCOGNITO_INACTIVE,
256    ThemeService::TINT_FRAME_INCOGNITO_INACTIVE }
257};
258
259// Mapping used in GenerateTabBackgroundImages() to associate what frame image
260// goes with which tab background.
261IntToIntTable kTabBackgroundMap[] = {
262  { PRS_THEME_TAB_BACKGROUND, PRS_THEME_FRAME },
263  { PRS_THEME_TAB_BACKGROUND_INCOGNITO, PRS_THEME_FRAME_INCOGNITO }
264};
265
266// A list of images that don't need tinting or any other modification and can
267// be byte-copied directly into the finished DataPack. This should contain the
268// persistent IDs for all themeable image IDs that aren't in kFrameTintMap or
269// kTabBackgroundMap.
270const int kPreloadIDs[] = {
271  PRS_THEME_TOOLBAR,
272  PRS_THEME_NTP_BACKGROUND,
273  PRS_THEME_BUTTON_BACKGROUND,
274  PRS_THEME_NTP_ATTRIBUTION,
275  PRS_THEME_WINDOW_CONTROL_BACKGROUND
276};
277
278// Returns a piece of memory with the contents of the file |path|.
279RefCountedMemory* ReadFileData(const FilePath& path) {
280  if (!path.empty()) {
281    net::FileStream file;
282    int flags = base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ;
283    if (file.Open(path, flags) == net::OK) {
284      int64 avail = file.Available();
285      if (avail > 0 && avail < INT_MAX) {
286        size_t size = static_cast<size_t>(avail);
287        std::vector<unsigned char> raw_data;
288        raw_data.resize(size);
289        char* data = reinterpret_cast<char*>(&(raw_data.front()));
290        if (file.ReadUntilComplete(data, size) == avail)
291          return RefCountedBytes::TakeVector(&raw_data);
292      }
293    }
294  }
295
296  return NULL;
297}
298
299// Does error checking for invalid incoming data while trying to read an
300// floating point value.
301bool ValidDoubleValue(ListValue* tint_list, int index, double* out) {
302  if (tint_list->GetDouble(index, out))
303    return true;
304
305  int value = 0;
306  if (tint_list->GetInteger(index, &value)) {
307    *out = value;
308    return true;
309  }
310
311  return false;
312}
313
314}  // namespace
315
316BrowserThemePack::~BrowserThemePack() {
317  if (!data_pack_.get()) {
318    delete header_;
319    delete [] tints_;
320    delete [] colors_;
321    delete [] display_properties_;
322    delete [] source_images_;
323  }
324
325  STLDeleteValues(&prepared_images_);
326  STLDeleteValues(&loaded_images_);
327}
328
329// static
330BrowserThemePack* BrowserThemePack::BuildFromExtension(
331    const Extension* extension) {
332  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
333  DCHECK(extension);
334  DCHECK(extension->is_theme());
335
336  BrowserThemePack* pack = new BrowserThemePack;
337  pack->BuildHeader(extension);
338  pack->BuildTintsFromJSON(extension->GetThemeTints());
339  pack->BuildColorsFromJSON(extension->GetThemeColors());
340  pack->BuildDisplayPropertiesFromJSON(extension->GetThemeDisplayProperties());
341
342  // Builds the images. (Image building is dependent on tints).
343  FilePathMap file_paths;
344  pack->ParseImageNamesFromJSON(extension->GetThemeImages(),
345                                extension->path(),
346                                &file_paths);
347  pack->BuildSourceImagesArray(file_paths);
348
349  if (!pack->LoadRawBitmapsTo(file_paths, &pack->prepared_images_))
350    return NULL;
351
352  pack->GenerateFrameImages(&pack->prepared_images_);
353
354#if !defined(OS_MACOSX)
355  // OSX uses its own special buttons that are PDFs that do odd sorts of vector
356  // graphics tricks. Other platforms use bitmaps and we must pre-tint them.
357  pack->GenerateTintedButtons(
358      pack->GetTintInternal(ThemeService::TINT_BUTTONS),
359      &pack->prepared_images_);
360#endif
361
362  pack->GenerateTabBackgroundImages(&pack->prepared_images_);
363
364  // The BrowserThemePack is now in a consistent state.
365  return pack;
366}
367
368// static
369scoped_refptr<BrowserThemePack> BrowserThemePack::BuildFromDataPack(
370    FilePath path, const std::string& expected_id) {
371  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
372  scoped_refptr<BrowserThemePack> pack(new BrowserThemePack);
373  pack->data_pack_.reset(new ui::DataPack);
374
375  if (!pack->data_pack_->Load(path)) {
376    LOG(ERROR) << "Failed to load theme data pack.";
377    return NULL;
378  }
379
380  base::StringPiece pointer;
381  if (!pack->data_pack_->GetStringPiece(kHeaderID, &pointer))
382    return NULL;
383  pack->header_ = reinterpret_cast<BrowserThemePackHeader*>(const_cast<char*>(
384      pointer.data()));
385
386  if (pack->header_->version != kThemePackVersion) {
387    DLOG(ERROR) << "BuildFromDataPack failure! Version mismatch!";
388    return NULL;
389  }
390  // TODO(erg): Check endianess once DataPack works on the other endian.
391  std::string theme_id(reinterpret_cast<char*>(pack->header_->theme_id),
392                       Extension::kIdSize);
393  std::string truncated_id = expected_id.substr(0, Extension::kIdSize);
394  if (theme_id != truncated_id) {
395    DLOG(ERROR) << "Wrong id: " << theme_id << " vs " << expected_id;
396    return NULL;
397  }
398
399  if (!pack->data_pack_->GetStringPiece(kTintsID, &pointer))
400    return NULL;
401  pack->tints_ = reinterpret_cast<TintEntry*>(const_cast<char*>(
402      pointer.data()));
403
404  if (!pack->data_pack_->GetStringPiece(kColorsID, &pointer))
405    return NULL;
406  pack->colors_ =
407      reinterpret_cast<ColorPair*>(const_cast<char*>(pointer.data()));
408
409  if (!pack->data_pack_->GetStringPiece(kDisplayPropertiesID, &pointer))
410    return NULL;
411  pack->display_properties_ = reinterpret_cast<DisplayPropertyPair*>(
412      const_cast<char*>(pointer.data()));
413
414  if (!pack->data_pack_->GetStringPiece(kSourceImagesID, &pointer))
415    return NULL;
416  pack->source_images_ = reinterpret_cast<int*>(
417      const_cast<char*>(pointer.data()));
418
419  return pack;
420}
421
422bool BrowserThemePack::WriteToDisk(FilePath path) const {
423  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
424  // Add resources for each of the property arrays.
425  RawDataForWriting resources;
426  resources[kHeaderID] = base::StringPiece(
427      reinterpret_cast<const char*>(header_), sizeof(BrowserThemePackHeader));
428  resources[kTintsID] = base::StringPiece(
429      reinterpret_cast<const char*>(tints_), sizeof(TintEntry[kTintArraySize]));
430  resources[kColorsID] = base::StringPiece(
431      reinterpret_cast<const char*>(colors_),
432      sizeof(ColorPair[kColorArraySize]));
433  resources[kDisplayPropertiesID] = base::StringPiece(
434      reinterpret_cast<const char*>(display_properties_),
435      sizeof(DisplayPropertyPair[kDisplayPropertySize]));
436
437  int source_count = 1;
438  int* end = source_images_;
439  for (; *end != -1 ; end++)
440    source_count++;
441  resources[kSourceImagesID] = base::StringPiece(
442      reinterpret_cast<const char*>(source_images_),
443      source_count * sizeof(*source_images_));
444
445  AddRawImagesTo(image_memory_, &resources);
446
447  RawImages reencoded_images;
448  RepackImages(prepared_images_, &reencoded_images);
449  AddRawImagesTo(reencoded_images, &resources);
450
451  return ui::DataPack::WritePack(path, resources);
452}
453
454bool BrowserThemePack::GetTint(int id, color_utils::HSL* hsl) const {
455  if (tints_) {
456    for (int i = 0; i < kTintArraySize; ++i) {
457      if (tints_[i].id == id) {
458        hsl->h = tints_[i].h;
459        hsl->s = tints_[i].s;
460        hsl->l = tints_[i].l;
461        return true;
462      }
463    }
464  }
465
466  return false;
467}
468
469bool BrowserThemePack::GetColor(int id, SkColor* color) const {
470  if (colors_) {
471    for (int i = 0; i < kColorArraySize; ++i) {
472      if (colors_[i].id == id) {
473        *color = colors_[i].color;
474        return true;
475      }
476    }
477  }
478
479  return false;
480}
481
482bool BrowserThemePack::GetDisplayProperty(int id, int* result) const {
483  if (display_properties_) {
484    for (int i = 0; i < kDisplayPropertySize; ++i) {
485      if (display_properties_[i].id == id) {
486        *result = display_properties_[i].property;
487        return true;
488      }
489    }
490  }
491
492  return false;
493}
494
495SkBitmap* BrowserThemePack::GetBitmapNamed(int idr_id) const {
496  int prs_id = GetPersistentIDByIDR(idr_id);
497  if (prs_id == -1)
498    return NULL;
499
500  // Check our cache of prepared images, first.
501  ImageCache::const_iterator image_iter = prepared_images_.find(prs_id);
502  if (image_iter != prepared_images_.end())
503    return image_iter->second;
504
505  // Check if we've already loaded this image.
506  image_iter = loaded_images_.find(prs_id);
507  if (image_iter != loaded_images_.end())
508    return image_iter->second;
509
510  scoped_refptr<RefCountedMemory> memory;
511  if (data_pack_.get()) {
512    memory = data_pack_->GetStaticMemory(prs_id);
513  } else {
514    RawImages::const_iterator it = image_memory_.find(prs_id);
515    if (it != image_memory_.end()) {
516      memory = it->second;
517    }
518  }
519
520  if (memory.get()) {
521    // Decode the PNG.
522    SkBitmap bitmap;
523    if (!gfx::PNGCodec::Decode(memory->front(), memory->size(),
524                               &bitmap)) {
525      NOTREACHED() << "Unable to decode theme image resource " << idr_id
526                   << " from saved DataPack.";
527      return NULL;
528    }
529
530    SkBitmap* ret = new SkBitmap(bitmap);
531    loaded_images_[prs_id] = ret;
532
533    return ret;
534  }
535
536  return NULL;
537}
538
539RefCountedMemory* BrowserThemePack::GetRawData(int idr_id) const {
540  RefCountedMemory* memory = NULL;
541  int prs_id = GetPersistentIDByIDR(idr_id);
542
543  if (prs_id != -1) {
544    if (data_pack_.get()) {
545      memory = data_pack_->GetStaticMemory(prs_id);
546    } else {
547      RawImages::const_iterator it = image_memory_.find(prs_id);
548      if (it != image_memory_.end()) {
549        memory = it->second;
550      }
551    }
552  }
553
554  return memory;
555}
556
557bool BrowserThemePack::HasCustomImage(int idr_id) const {
558  int prs_id = GetPersistentIDByIDR(idr_id);
559  if (prs_id == -1)
560    return false;
561
562  int* img = source_images_;
563  for (; *img != -1; ++img) {
564    if (*img == prs_id)
565      return true;
566  }
567
568  return false;
569}
570
571// private:
572
573BrowserThemePack::BrowserThemePack()
574    : header_(NULL),
575      tints_(NULL),
576      colors_(NULL),
577      display_properties_(NULL),
578      source_images_(NULL) {
579}
580
581void BrowserThemePack::BuildHeader(const Extension* extension) {
582  header_ = new BrowserThemePackHeader;
583  header_->version = kThemePackVersion;
584
585  // TODO(erg): Need to make this endian safe on other computers. Prerequisite
586  // is that ui::DataPack removes this same check.
587#if defined(__BYTE_ORDER)
588  // Linux check
589  COMPILE_ASSERT(__BYTE_ORDER == __LITTLE_ENDIAN,
590                 datapack_assumes_little_endian);
591#elif defined(__BIG_ENDIAN__)
592  // Mac check
593  #error DataPack assumes little endian
594#endif
595  header_->little_endian = 1;
596
597  const std::string& id = extension->id();
598  memcpy(header_->theme_id, id.c_str(), Extension::kIdSize);
599}
600
601void BrowserThemePack::BuildTintsFromJSON(DictionaryValue* tints_value) {
602  tints_ = new TintEntry[kTintArraySize];
603  for (int i = 0; i < kTintArraySize; ++i) {
604    tints_[i].id = -1;
605    tints_[i].h = -1;
606    tints_[i].s = -1;
607    tints_[i].l = -1;
608  }
609
610  if (!tints_value)
611    return;
612
613  // Parse the incoming data from |tints_value| into an intermediary structure.
614  std::map<int, color_utils::HSL> temp_tints;
615  for (DictionaryValue::key_iterator iter(tints_value->begin_keys());
616       iter != tints_value->end_keys(); ++iter) {
617    ListValue* tint_list;
618    if (tints_value->GetList(*iter, &tint_list) &&
619        (tint_list->GetSize() == 3)) {
620      color_utils::HSL hsl = { -1, -1, -1 };
621
622      if (ValidDoubleValue(tint_list, 0, &hsl.h) &&
623          ValidDoubleValue(tint_list, 1, &hsl.s) &&
624          ValidDoubleValue(tint_list, 2, &hsl.l)) {
625        int id = GetIntForString(*iter, kTintTable);
626        if (id != -1) {
627          temp_tints[id] = hsl;
628        }
629      }
630    }
631  }
632
633  // Copy data from the intermediary data structure to the array.
634  int count = 0;
635  for (std::map<int, color_utils::HSL>::const_iterator it =
636           temp_tints.begin(); it != temp_tints.end() && count < kTintArraySize;
637       ++it, ++count) {
638    tints_[count].id = it->first;
639    tints_[count].h = it->second.h;
640    tints_[count].s = it->second.s;
641    tints_[count].l = it->second.l;
642  }
643}
644
645void BrowserThemePack::BuildColorsFromJSON(DictionaryValue* colors_value) {
646  colors_ = new ColorPair[kColorArraySize];
647  for (int i = 0; i < kColorArraySize; ++i) {
648    colors_[i].id = -1;
649    colors_[i].color = SkColorSetRGB(0, 0, 0);
650  }
651
652  std::map<int, SkColor> temp_colors;
653  if (colors_value)
654    ReadColorsFromJSON(colors_value, &temp_colors);
655  GenerateMissingColors(&temp_colors);
656
657  // Copy data from the intermediary data structure to the array.
658  int count = 0;
659  for (std::map<int, SkColor>::const_iterator it = temp_colors.begin();
660       it != temp_colors.end() && count < kColorArraySize; ++it, ++count) {
661    colors_[count].id = it->first;
662    colors_[count].color = it->second;
663  }
664}
665
666void BrowserThemePack::ReadColorsFromJSON(
667    DictionaryValue* colors_value,
668    std::map<int, SkColor>* temp_colors) {
669  // Parse the incoming data from |colors_value| into an intermediary structure.
670  for (DictionaryValue::key_iterator iter(colors_value->begin_keys());
671       iter != colors_value->end_keys(); ++iter) {
672    ListValue* color_list;
673    if (colors_value->GetList(*iter, &color_list) &&
674        ((color_list->GetSize() == 3) || (color_list->GetSize() == 4))) {
675      SkColor color = SK_ColorWHITE;
676      int r, g, b;
677      if (color_list->GetInteger(0, &r) &&
678          color_list->GetInteger(1, &g) &&
679          color_list->GetInteger(2, &b)) {
680        if (color_list->GetSize() == 4) {
681          double alpha;
682          int alpha_int;
683          if (color_list->GetDouble(3, &alpha)) {
684            color = SkColorSetARGB(static_cast<int>(alpha * 255), r, g, b);
685          } else if (color_list->GetInteger(3, &alpha_int) &&
686                     (alpha_int == 0 || alpha_int == 1)) {
687            color = SkColorSetARGB(alpha_int ? 255 : 0, r, g, b);
688          } else {
689            // Invalid entry for part 4.
690            continue;
691          }
692        } else {
693          color = SkColorSetRGB(r, g, b);
694        }
695
696        int id = GetIntForString(*iter, kColorTable);
697        if (id != -1) {
698          (*temp_colors)[id] = color;
699        }
700      }
701    }
702  }
703}
704
705void BrowserThemePack::GenerateMissingColors(
706    std::map<int, SkColor>* colors) {
707  // Generate link colors, if missing. (See GetColor()).
708  if (!colors->count(ThemeService::COLOR_NTP_HEADER) &&
709      colors->count(ThemeService::COLOR_NTP_SECTION)) {
710    (*colors)[ThemeService::COLOR_NTP_HEADER] =
711        (*colors)[ThemeService::COLOR_NTP_SECTION];
712  }
713
714  if (!colors->count(ThemeService::COLOR_NTP_SECTION_LINK_UNDERLINE) &&
715      colors->count(ThemeService::COLOR_NTP_SECTION_LINK)) {
716    SkColor color_section_link =
717        (*colors)[ThemeService::COLOR_NTP_SECTION_LINK];
718    (*colors)[ThemeService::COLOR_NTP_SECTION_LINK_UNDERLINE] =
719        SkColorSetA(color_section_link, SkColorGetA(color_section_link) / 3);
720  }
721
722  if (!colors->count(ThemeService::COLOR_NTP_LINK_UNDERLINE) &&
723      colors->count(ThemeService::COLOR_NTP_LINK)) {
724    SkColor color_link = (*colors)[ThemeService::COLOR_NTP_LINK];
725    (*colors)[ThemeService::COLOR_NTP_LINK_UNDERLINE] =
726        SkColorSetA(color_link, SkColorGetA(color_link) / 3);
727  }
728
729  // Generate frame colors, if missing. (See GenerateFrameColors()).
730  SkColor frame;
731  std::map<int, SkColor>::const_iterator it =
732      colors->find(ThemeService::COLOR_FRAME);
733  if (it != colors->end()) {
734    frame = it->second;
735  } else {
736    frame = ThemeService::GetDefaultColor(
737        ThemeService::COLOR_FRAME);
738  }
739
740  if (!colors->count(ThemeService::COLOR_FRAME)) {
741    (*colors)[ThemeService::COLOR_FRAME] =
742        HSLShift(frame, GetTintInternal(ThemeService::TINT_FRAME));
743  }
744  if (!colors->count(ThemeService::COLOR_FRAME_INACTIVE)) {
745    (*colors)[ThemeService::COLOR_FRAME_INACTIVE] =
746        HSLShift(frame, GetTintInternal(
747            ThemeService::TINT_FRAME_INACTIVE));
748  }
749  if (!colors->count(ThemeService::COLOR_FRAME_INCOGNITO)) {
750    (*colors)[ThemeService::COLOR_FRAME_INCOGNITO] =
751        HSLShift(frame, GetTintInternal(
752            ThemeService::TINT_FRAME_INCOGNITO));
753  }
754  if (!colors->count(ThemeService::COLOR_FRAME_INCOGNITO_INACTIVE)) {
755    (*colors)[ThemeService::COLOR_FRAME_INCOGNITO_INACTIVE] =
756        HSLShift(frame, GetTintInternal(
757            ThemeService::TINT_FRAME_INCOGNITO_INACTIVE));
758  }
759}
760
761void BrowserThemePack::BuildDisplayPropertiesFromJSON(
762    DictionaryValue* display_properties_value) {
763  display_properties_ = new DisplayPropertyPair[kDisplayPropertySize];
764  for (int i = 0; i < kDisplayPropertySize; ++i) {
765    display_properties_[i].id = -1;
766    display_properties_[i].property = 0;
767  }
768
769  if (!display_properties_value)
770    return;
771
772  std::map<int, int> temp_properties;
773  for (DictionaryValue::key_iterator iter(
774       display_properties_value->begin_keys());
775       iter != display_properties_value->end_keys(); ++iter) {
776    int property_id = GetIntForString(*iter, kDisplayProperties);
777    switch (property_id) {
778      case ThemeService::NTP_BACKGROUND_ALIGNMENT: {
779        std::string val;
780        if (display_properties_value->GetString(*iter, &val)) {
781          temp_properties[ThemeService::NTP_BACKGROUND_ALIGNMENT] =
782              ThemeService::StringToAlignment(val);
783        }
784        break;
785      }
786      case ThemeService::NTP_BACKGROUND_TILING: {
787        std::string val;
788        if (display_properties_value->GetString(*iter, &val)) {
789          temp_properties[ThemeService::NTP_BACKGROUND_TILING] =
790              GetIntForString(val, kTilingStrings);
791        }
792        break;
793      }
794      case ThemeService::NTP_LOGO_ALTERNATE: {
795        int val = 0;
796        if (display_properties_value->GetInteger(*iter, &val))
797          temp_properties[ThemeService::NTP_LOGO_ALTERNATE] = val;
798        break;
799      }
800    }
801  }
802
803  // Copy data from the intermediary data structure to the array.
804  int count = 0;
805  for (std::map<int, int>::const_iterator it = temp_properties.begin();
806       it != temp_properties.end() && count < kDisplayPropertySize;
807       ++it, ++count) {
808    display_properties_[count].id = it->first;
809    display_properties_[count].property = it->second;
810  }
811}
812
813void BrowserThemePack::ParseImageNamesFromJSON(
814    DictionaryValue* images_value,
815    const FilePath& images_path,
816    FilePathMap* file_paths) const {
817  if (!images_value)
818    return;
819
820  for (DictionaryValue::key_iterator iter(images_value->begin_keys());
821       iter != images_value->end_keys(); ++iter) {
822    std::string val;
823    if (images_value->GetString(*iter, &val)) {
824      int id = GetPersistentIDByName(*iter);
825      if (id != -1)
826        (*file_paths)[id] = images_path.AppendASCII(val);
827    }
828  }
829}
830
831void BrowserThemePack::BuildSourceImagesArray(const FilePathMap& file_paths) {
832  std::vector<int> ids;
833  for (FilePathMap::const_iterator it = file_paths.begin();
834       it != file_paths.end(); ++it) {
835    ids.push_back(it->first);
836  }
837
838  source_images_ = new int[ids.size() + 1];
839  std::copy(ids.begin(), ids.end(), source_images_);
840  source_images_[ids.size()] = -1;
841}
842
843bool BrowserThemePack::LoadRawBitmapsTo(
844    const FilePathMap& file_paths,
845    ImageCache* raw_bitmaps) {
846  // Themes should be loaded on the file thread, not the UI thread.
847  // http://crbug.com/61838
848  base::ThreadRestrictions::ScopedAllowIO allow_io;
849
850  for (FilePathMap::const_iterator it = file_paths.begin();
851       it != file_paths.end(); ++it) {
852    scoped_refptr<RefCountedMemory> raw_data(ReadFileData(it->second));
853    if (!raw_data.get()) {
854      LOG(ERROR) << "Could not load theme image";
855      return false;
856    }
857
858    int id = it->first;
859
860    // Some images need to go directly into |image_memory_|. No modification is
861    // necessary or desirable.
862    bool is_copyable = false;
863    for (size_t i = 0; i < arraysize(kPreloadIDs); ++i) {
864      if (kPreloadIDs[i] == id) {
865        is_copyable = true;
866        break;
867      }
868    }
869
870    if (is_copyable) {
871      image_memory_[id] = raw_data;
872    } else if (raw_data.get() && raw_data->size()) {
873      // Decode the PNG.
874      SkBitmap bitmap;
875      if (gfx::PNGCodec::Decode(raw_data->front(), raw_data->size(),
876                                &bitmap)) {
877        (*raw_bitmaps)[it->first] = new SkBitmap(bitmap);
878      } else {
879        NOTREACHED() << "Unable to decode theme image resource " << it->first;
880      }
881    }
882  }
883
884  return true;
885}
886
887void BrowserThemePack::GenerateFrameImages(ImageCache* bitmaps) const {
888  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
889
890  // Create all the output bitmaps in a separate cache and move them back into
891  // the input bitmaps because there can be name collisions.
892  ImageCache temp_output;
893
894  for (size_t i = 0; i < arraysize(kFrameTintMap); ++i) {
895    int prs_id = kFrameTintMap[i].key;
896    scoped_ptr<SkBitmap> frame;
897    // If there's no frame image provided for the specified id, then load
898    // the default provided frame. If that's not provided, skip this whole
899    // thing and just use the default images.
900    int prs_base_id;
901
902    if (prs_id == PRS_THEME_FRAME_INCOGNITO_INACTIVE) {
903      prs_base_id = bitmaps->count(PRS_THEME_FRAME_INCOGNITO) ?
904                    PRS_THEME_FRAME_INCOGNITO : PRS_THEME_FRAME;
905    } else if (prs_id == PRS_THEME_FRAME_OVERLAY_INACTIVE) {
906      prs_base_id = PRS_THEME_FRAME_OVERLAY;
907    } else if (prs_id == PRS_THEME_FRAME_INACTIVE) {
908      prs_base_id = PRS_THEME_FRAME;
909    } else if (prs_id == PRS_THEME_FRAME_INCOGNITO &&
910               !bitmaps->count(PRS_THEME_FRAME_INCOGNITO)) {
911      prs_base_id = PRS_THEME_FRAME;
912    } else {
913      prs_base_id = prs_id;
914    }
915
916    if (bitmaps->count(prs_id)) {
917      frame.reset(new SkBitmap(*(*bitmaps)[prs_id]));
918    } else if (prs_base_id != prs_id && bitmaps->count(prs_base_id)) {
919      frame.reset(new SkBitmap(*(*bitmaps)[prs_base_id]));
920    } else if (prs_base_id == PRS_THEME_FRAME_OVERLAY &&
921               bitmaps->count(PRS_THEME_FRAME)) {
922      // If there is no theme overlay, don't tint the default frame,
923      // because it will overwrite the custom frame image when we cache and
924      // reload from disk.
925      frame.reset(NULL);
926    } else {
927      // If the theme doesn't specify an image, then apply the tint to
928      // the default frame.
929      frame.reset(new SkBitmap(*rb.GetBitmapNamed(IDR_THEME_FRAME)));
930    }
931
932    if (frame.get()) {
933      temp_output[prs_id] = new SkBitmap(
934          SkBitmapOperations::CreateHSLShiftedBitmap(
935              *frame, GetTintInternal(kFrameTintMap[i].value)));
936    }
937  }
938
939  MergeImageCaches(temp_output, bitmaps);
940}
941
942void BrowserThemePack::GenerateTintedButtons(
943    const color_utils::HSL& button_tint,
944    ImageCache* processed_bitmaps) const {
945  if (button_tint.h != -1 || button_tint.s != -1 || button_tint.l != -1) {
946    ResourceBundle& rb = ResourceBundle::GetSharedInstance();
947    const std::set<int>& idr_ids =
948        ThemeService::GetTintableToolbarButtons();
949    for (std::set<int>::const_iterator it = idr_ids.begin();
950         it != idr_ids.end(); ++it) {
951      int prs_id = GetPersistentIDByIDR(*it);
952      DCHECK(prs_id > 0);
953
954      // Fetch the image by IDR...
955      scoped_ptr<SkBitmap> button(new SkBitmap(*rb.GetBitmapNamed(*it)));
956
957      // but save a version with the persistent ID.
958      (*processed_bitmaps)[prs_id] = new SkBitmap(
959          SkBitmapOperations::CreateHSLShiftedBitmap(*button, button_tint));
960    }
961  }
962}
963
964void BrowserThemePack::GenerateTabBackgroundImages(ImageCache* bitmaps) const {
965  ImageCache temp_output;
966  for (size_t i = 0; i < arraysize(kTabBackgroundMap); ++i) {
967    int prs_id = kTabBackgroundMap[i].key;
968    int prs_base_id = kTabBackgroundMap[i].value;
969
970    // We only need to generate the background tab images if we were provided
971    // with a PRS_THEME_FRAME.
972    ImageCache::const_iterator it = bitmaps->find(prs_base_id);
973    if (it != bitmaps->end()) {
974      SkBitmap bg_tint = SkBitmapOperations::CreateHSLShiftedBitmap(
975          *(it->second), GetTintInternal(
976              ThemeService::TINT_BACKGROUND_TAB));
977      int vertical_offset = bitmaps->count(prs_id)
978                            ? kRestoredTabVerticalOffset : 0;
979      SkBitmap* bg_tab = new SkBitmap(SkBitmapOperations::CreateTiledBitmap(
980          bg_tint, 0, vertical_offset, bg_tint.width(), bg_tint.height()));
981
982      // If they've provided a custom image, overlay it.
983      ImageCache::const_iterator overlay_it = bitmaps->find(prs_id);
984      if (overlay_it != bitmaps->end()) {
985        SkBitmap* overlay = overlay_it->second;
986        SkCanvas canvas(*bg_tab);
987        for (int x = 0; x < bg_tab->width(); x += overlay->width())
988          canvas.drawBitmap(*overlay, static_cast<SkScalar>(x), 0, NULL);
989      }
990
991      temp_output[prs_id] = bg_tab;
992    }
993  }
994
995  MergeImageCaches(temp_output, bitmaps);
996}
997
998void BrowserThemePack::RepackImages(const ImageCache& images,
999                                    RawImages* reencoded_images) const {
1000  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
1001  for (ImageCache::const_iterator it = images.begin();
1002       it != images.end(); ++it) {
1003    std::vector<unsigned char> image_data;
1004    if (!gfx::PNGCodec::EncodeBGRASkBitmap(*(it->second), false, &image_data)) {
1005      NOTREACHED() << "Image file for resource " << it->first
1006                   << " could not be encoded.";
1007    } else {
1008      (*reencoded_images)[it->first] = RefCountedBytes::TakeVector(&image_data);
1009    }
1010  }
1011}
1012
1013void BrowserThemePack::MergeImageCaches(
1014    const ImageCache& source, ImageCache* destination) const {
1015
1016  for (ImageCache::const_iterator it = source.begin(); it != source.end();
1017       ++it) {
1018    ImageCache::const_iterator bitmap_it = destination->find(it->first);
1019    if (bitmap_it != destination->end())
1020      delete bitmap_it->second;
1021
1022    (*destination)[it->first] = it->second;
1023  }
1024}
1025
1026void BrowserThemePack::AddRawImagesTo(const RawImages& images,
1027                                      RawDataForWriting* out) const {
1028  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
1029  for (RawImages::const_iterator it = images.begin(); it != images.end();
1030       ++it) {
1031    (*out)[it->first] = base::StringPiece(
1032        reinterpret_cast<const char*>(it->second->front()), it->second->size());
1033  }
1034}
1035
1036color_utils::HSL BrowserThemePack::GetTintInternal(int id) const {
1037  if (tints_) {
1038    for (int i = 0; i < kTintArraySize; ++i) {
1039      if (tints_[i].id == id) {
1040        color_utils::HSL hsl;
1041        hsl.h = tints_[i].h;
1042        hsl.s = tints_[i].s;
1043        hsl.l = tints_[i].l;
1044        return hsl;
1045      }
1046    }
1047  }
1048
1049  return ThemeService::GetDefaultTint(id);
1050}
1051