First pass at NNTP theming....

chrome/browser/browser_theme_provider.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/browser_theme_provider.h"
 
 #include "base/gfx/png_decoder.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/theme_resources_util.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "grit/app_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/file_stream.h"
 #include "net/base/net_errors.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/skia_utils.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkCanvas.h"
 
 #if defined(OS_WIN)
 #include "app/win_util.h"
 #endif
 
 // Strings used by themes to identify colors for different parts of our UI.
 const char* BrowserThemeProvider::kColorFrame = "frame";
 const char* BrowserThemeProvider::kColorFrameInactive = "frame_inactive";
 const char* BrowserThemeProvider::kColorFrameIncognito = "frame_incognito";
 const char* BrowserThemeProvider::kColorFrameIncognitoInactive =
@@ skipping 22 matching lines @@
 const char* BrowserThemeProvider::kTintFrameIncognito = "frame_incognito";
 const char* BrowserThemeProvider::kTintFrameIncognitoInactive =
     "frame_incognito_inactive";
 const char* BrowserThemeProvider::kTintBackgroundTab = "background_tab";
 
 // Strings used by themes to identify miscellaneous numerical properties.
 const char* BrowserThemeProvider::kDisplayPropertyNTPAlignment =
     "ntp_background_alignment";
 const char* BrowserThemeProvider::kDisplayPropertyNTPTiling =
     "ntp_background_repeat";
+const char* BrowserThemeProvider::kDisplayPropertyNTPInverseLogo =
+    "ntp_logo_alternate";
 
 // Strings used in alignment properties.
 const char* BrowserThemeProvider::kAlignmentTop = "top";
 const char* BrowserThemeProvider::kAlignmentBottom = "bottom";
 const char* BrowserThemeProvider::kAlignmentLeft = "left";
 const char* BrowserThemeProvider::kAlignmentRight = "right";
 
 // Strings used in background tiling repetition properties.
 const char* BrowserThemeProvider::kTilingNoRepeat = "no-repeat";
 const char* BrowserThemeProvider::kTilingRepeatX = "repeat-x";
 const char* BrowserThemeProvider::kTilingRepeatY = "repeat-y";
 const char* BrowserThemeProvider::kTilingRepeat = "repeat";
 
 // Default colors.
 const SkColor BrowserThemeProvider::kDefaultColorFrame =
     SkColorSetRGB(77, 139, 217);
 const SkColor BrowserThemeProvider::kDefaultColorFrameInactive =
     SkColorSetRGB(152, 188, 233);
 const SkColor BrowserThemeProvider::kDefaultColorFrameIncognito =
     SkColorSetRGB(83, 106, 139);
 const SkColor BrowserThemeProvider::kDefaultColorFrameIncognitoInactive =
     SkColorSetRGB(126, 139, 156);
 const SkColor BrowserThemeProvider::kDefaultColorToolbar =
     SkColorSetRGB(210, 225, 246);
 const SkColor BrowserThemeProvider::kDefaultColorTabText =
     SkColorSetRGB(0, 0, 0);
 const SkColor BrowserThemeProvider::kDefaultColorBackgroundTabText =
     SkColorSetRGB(64, 64, 64);
 const SkColor BrowserThemeProvider::kDefaultColorBookmarkText =
-    SkColorSetRGB(64, 64, 64);
+    SkColorSetRGB(18, 50, 114);
 const SkColor BrowserThemeProvider::kDefaultColorNTPBackground =
     SkColorSetRGB(255, 255, 255);
 const SkColor BrowserThemeProvider::kDefaultColorNTPText =
     SkColorSetRGB(0, 0, 0);
 const SkColor BrowserThemeProvider::kDefaultColorNTPLink =
-    SkColorSetRGB(0, 0, 204);
+    SkColorSetRGB(0, 0, 0);
 const SkColor BrowserThemeProvider::kDefaultColorNTPSection =
-    SkColorSetRGB(225, 236, 254);
+    SkColorSetRGB(75, 140, 220);
 const SkColor BrowserThemeProvider::kDefaultColorNTPSectionText =
-    SkColorSetRGB(0, 0, 0);
+    SkColorSetRGB(255, 255, 255);
 const SkColor BrowserThemeProvider::kDefaultColorNTPSectionLink =
-    SkColorSetRGB(0, 0, 204);
+    SkColorSetRGB(127, 148, 173);
 const SkColor BrowserThemeProvider::kDefaultColorControlBackground = NULL;
 const SkColor BrowserThemeProvider::kDefaultColorButtonBackground = NULL;
 
 // Default tints.
 const skia::HSL BrowserThemeProvider::kDefaultTintButtons = { -1, -1, -1 };
 const skia::HSL BrowserThemeProvider::kDefaultTintFrame = { -1, -1, -1 };
 const skia::HSL BrowserThemeProvider::kDefaultTintFrameInactive =
     { -1, -1, 0.75f };
 const skia::HSL BrowserThemeProvider::kDefaultTintFrameIncognito =
     { -1, 0.2f, 0.35f };
 const skia::HSL BrowserThemeProvider::kDefaultTintFrameIncognitoInactive =
     { -1, 0.3f, 0.6f };
 const skia::HSL BrowserThemeProvider::kDefaultTintBackgroundTab =
     { -1, 0.5, 0.75 };
 
 // Default display properties.
 static const int kDefaultDisplayPropertyNTPAlignment =
     BrowserThemeProvider::ALIGN_BOTTOM;
 static const int kDefaultDisplayPropertyNTPTiling =
     BrowserThemeProvider::NO_REPEAT;
+static const int kDefaultDisplayPropertyNTPInverseLogo = 0;
 
 // The image resources that will be tinted by the 'button' tint value.
 static const int kToolbarButtonIDs[] = {
   IDR_BACK, IDR_BACK_D, IDR_BACK_H, IDR_BACK_P,
   IDR_FORWARD, IDR_FORWARD_D, IDR_FORWARD_H, IDR_FORWARD_P,
   IDR_RELOAD, IDR_RELOAD_H, IDR_RELOAD_P,
   IDR_HOME, IDR_HOME_H, IDR_HOME_P,
   IDR_STAR, IDR_STAR_NOBORDER, IDR_STAR_D, IDR_STAR_H, IDR_STAR_P,
   IDR_STARRED, IDR_STARRED_NOBORDER, IDR_STARRED_H, IDR_STARRED_P,
   IDR_GO, IDR_GO_H, IDR_GO_P,
   IDR_STOP, IDR_STOP_H, IDR_STOP_P,
   IDR_MENU_PAGE, IDR_MENU_PAGE_RTL,
   IDR_MENU_CHROME, IDR_MENU_CHROME_RTL,
   IDR_MENU_DROPARROW,
-  IDR_THROBBER, IDR_THROBBER_WAITING, IDR_THROBBER_LIGHT
+  IDR_THROBBER, IDR_THROBBER_WAITING, IDR_THROBBER_LIGHT,
+  IDR_LOCATIONBG
 };
 
 // A map for kToolbarButtonIDs.
 static std::map<const int, bool> button_images_;
 
+// The image resources we will allow people to theme.
+static const int kThemeableImages[] = {
+  IDR_THEME_FRAME,
+  IDR_THEME_FRAME_INACTIVE,
+  IDR_THEME_FRAME_INCOGNITO,
+  IDR_THEME_FRAME_INCOGNITO_INACTIVE,
+  IDR_THEME_TOOLBAR,
+  IDR_THEME_TAB_BACKGROUND,
+  IDR_THEME_TAB_BACKGROUND_INCOGNITO,
+  IDR_THEME_TAB_BACKGROUND_V,
+  IDR_THEME_NTP_BACKGROUND,
+  IDR_THEME_FRAME_OVERLAY,
+  IDR_THEME_FRAME_OVERLAY_INACTIVE,
+  IDR_THEME_BUTTON_BACKGROUND,
+  IDR_THEME_NTP_ATTRIBUTION,
+  IDR_THEME_WINDOW_CONTROL_BACKGROUND
+};
+
+// A map for kThemeableImages.
+static std::map<const int, bool> themeable_images_;
+
 // A map of frame image IDs to the tints for those ids.
 static std::map<const int, int> frame_tints_;
 
 BrowserThemeProvider::BrowserThemeProvider()
     : rb_(ResourceBundle::GetSharedInstance()) {
   static bool initialized = false;
   if (!initialized) {
     for (size_t i = 0; i < arraysize(kToolbarButtonIDs); ++i) {
       button_images_[kToolbarButtonIDs[i]] = true;
     }
+    for (size_t i = 0; i < arraysize(kThemeableImages); ++i) {
+      themeable_images_[kThemeableImages[i]] = true;
+    }
     frame_tints_[IDR_THEME_FRAME] = TINT_FRAME;
     frame_tints_[IDR_THEME_FRAME_INACTIVE] = TINT_FRAME_INACTIVE;
+    frame_tints_[IDR_THEME_FRAME_OVERLAY] = TINT_FRAME;
+    frame_tints_[IDR_THEME_FRAME_OVERLAY_INACTIVE] = TINT_FRAME_INACTIVE;
     frame_tints_[IDR_THEME_FRAME_INCOGNITO] = TINT_FRAME_INCOGNITO;
     frame_tints_[IDR_THEME_FRAME_INCOGNITO_INACTIVE] =
         TINT_FRAME_INCOGNITO_INACTIVE;
   }
 }
 
 BrowserThemeProvider::~BrowserThemeProvider() {
   ClearCaches();
 }
 
 void BrowserThemeProvider::Init(Profile* profile) {
   DCHECK(CalledOnValidThread());
   profile_ = profile;
   LoadThemePrefs();
 }
 
 SkBitmap* BrowserThemeProvider::GetBitmapNamed(int id) {
   DCHECK(CalledOnValidThread());
 
+  // Check to see whether we should substitute some images.
+  int ntp_alternate;
+  GetDisplayProperty(NTP_LOGO_ALTERNATE, &ntp_alternate);
+  if (id == IDR_PRODUCT_LOGO && ntp_alternate != 0)
+    id = IDR_PRODUCT_LOGO_WHITE;
+
   // Check to see if we already have the Skia image in the cache.
   ImageCache::const_iterator found = image_cache_.find(id);
   if (found != image_cache_.end())
     return found->second;
 
   scoped_ptr<SkBitmap> result;
 
   // Try to load the image from the extension.
   result.reset(LoadThemeBitmap(id));
 
@@ skipping 83 matching lines @@
       }
       return true;
     case NTP_BACKGROUND_TILING:
       if (display_properties_.find(kDisplayPropertyNTPTiling) !=
           display_properties_.end()) {
         *result = display_properties_[kDisplayPropertyNTPTiling];
       } else {
         *result = kDefaultDisplayPropertyNTPTiling;
       }
       return true;
+    case NTP_LOGO_ALTERNATE:
+      if (display_properties_.find(kDisplayPropertyNTPInverseLogo) !=
+          display_properties_.end()) {
+        *result = display_properties_[kDisplayPropertyNTPInverseLogo];
+      } else {
+        *result = kDefaultDisplayPropertyNTPInverseLogo;
+      }
+      return true;
     default:
       NOTREACHED() << "Unknown property requested";
   }
   return false;
 }
 
 bool BrowserThemeProvider::ShouldUseNativeFrame() {
-  if (images_.find(IDR_THEME_FRAME) != images_.end())
+  if (HasCustomImage(IDR_THEME_FRAME))
     return false;
 #if defined(OS_WIN)
   return win_util::ShouldUseVistaFrame();
 #else
   return false;
 #endif
 }
 
 bool BrowserThemeProvider::HasCustomImage(int id) {
+  if (!themeable_images_[id])
+    return false;
+
   return (images_.find(id) != images_.end());
 }
 
 void BrowserThemeProvider::SetTheme(Extension* extension) {
   // Clear our image cache.
   ClearCaches();
 
   DCHECK(extension);
   DCHECK(extension->IsTheme());
   SetImageData(extension->GetThemeImages(),
                extension->path());
   SetColorData(extension->GetThemeColors());
   SetTintData(extension->GetThemeTints());
   SetDisplayPropertyData(extension->GetThemeDisplayProperties());
   GenerateFrameColors();
   GenerateFrameImages();
+  GenerateTabImages();
 
   SaveImageData(extension->GetThemeImages());
   SaveColorData();
   SaveTintData();
   SaveDisplayPropertyData();
 
   NotifyThemeChanged();
   UserMetrics::RecordAction(L"Themes_Installed", profile_);
 }
 
@@ skipping 27 matching lines @@
         }
       }
     }
   }
 
   return false;
 }
 
 SkBitmap* BrowserThemeProvider::LoadThemeBitmap(int id) {
   DCHECK(CalledOnValidThread());
+
+  if (!themeable_images_[id])
+    return NULL;
+
   // Attempt to find the image in our theme bundle.
   std::vector<unsigned char> raw_data, png_data;
   if (ReadThemeFileData(id, &raw_data)) {
     // Decode the PNG.
     int image_width = 0;
     int image_height = 0;
 
     if (!PNGDecoder::Decode(&raw_data.front(), raw_data.size(),
         PNGDecoder::FORMAT_BGRA, &png_data,
         &image_width, &image_height)) {
@@ skipping 157 matching lines @@
       if (display_properties_value->GetString(*iter, &val))
         display_properties_[kDisplayPropertyNTPAlignment] =
             StringToAlignment(val);
     } else if (base::strcasecmp(WideToUTF8(*iter).c_str(),
                kDisplayPropertyNTPTiling) == 0) {
       std::string val;
       if (display_properties_value->GetString(*iter, &val))
         display_properties_[kDisplayPropertyNTPTiling] =
             StringToTiling(val);
     }
+    if (base::strcasecmp(WideToUTF8(*iter).c_str(),
+        kDisplayPropertyNTPInverseLogo) == 0) {
+      std::string val;
+      if (display_properties_value->GetString(*iter, &val))
+        display_properties_[kDisplayPropertyNTPInverseLogo] = StringToInt(val);
+    }
     ++iter;
   }
 }
 
 // static
 int BrowserThemeProvider::StringToAlignment(const std::string& alignment) {
   std::vector<std::wstring> split;
   SplitStringAlongWhitespace(UTF8ToWide(alignment), &split);
 
   std::vector<std::wstring>::iterator alignments = split.begin();
@@ skipping 96 matching lines @@
 }
 
 void BrowserThemeProvider::GenerateFrameImages() {
   std::map<const int, int>::iterator iter = frame_tints_.begin();
   while (iter != frame_tints_.end()) {
     int id = iter->first;
     scoped_ptr<SkBitmap> frame;
     // If there's no frame image provided for the specified id, then load
     // the default provided frame. If that's not provided, skip this whole
     // thing and just use the default images.
-    int base_id = (id == IDR_THEME_FRAME_INCOGNITO ||
-                   id == IDR_THEME_FRAME_INCOGNITO_INACTIVE) ?
-        IDR_THEME_FRAME_INCOGNITO : IDR_THEME_FRAME;
+    int base_id;
+    if (id == IDR_THEME_FRAME_INCOGNITO_INACTIVE)
+      base_id = (HasCustomImage(IDR_THEME_FRAME_INCOGNITO)) ?
+          IDR_THEME_FRAME_INCOGNITO :
+          IDR_THEME_FRAME;
+    else if (id == IDR_THEME_FRAME_OVERLAY_INACTIVE)
+      base_id = IDR_THEME_FRAME_OVERLAY;
+    else if (id == IDR_THEME_FRAME_INACTIVE)
+      base_id = IDR_THEME_FRAME;
+    else if (id == IDR_THEME_FRAME_INCOGNITO &&
+             !HasCustomImage(IDR_THEME_FRAME_INCOGNITO))
+      base_id = IDR_THEME_FRAME;
+    else
+      base_id = id;
 
-    if (images_.find(id) != images_.end()) {
+    if (HasCustomImage(id)) {
       frame.reset(LoadThemeBitmap(id));
-    } else if (base_id != id && images_.find(base_id) != images_.end()) {
+    } else if (base_id != id && HasCustomImage(base_id)) {
       frame.reset(LoadThemeBitmap(base_id));
     } else {
       // If the theme doesn't specify an image, then apply the tint to
       // the default frame. Note that the default theme provides default
       // bitmaps for all frame types, so this isn't strictly necessary
       // in the case where no tint is provided either.
       frame.reset(new SkBitmap(*rb_.GetBitmapNamed(IDR_THEME_FRAME)));
     }
 
     if (frame.get()) {
       SkBitmap* tinted = new SkBitmap(TintBitmap(*frame, iter->second));
       image_cache_[id] = tinted;
     }
     ++iter;
   }
 }
 
+void BrowserThemeProvider::GenerateTabImages() {
+  GenerateBitmap(IDR_THEME_TAB_BACKGROUND);
+  GenerateBitmap(IDR_THEME_TAB_BACKGROUND_INCOGNITO);
+}
+
 void BrowserThemeProvider::ClearAllThemeData() {
   // Clear our image cache.
   ClearCaches();
 
   images_.clear();
   colors_.clear();
   tints_.clear();
   display_properties_.clear();
 
   SaveImageData(NULL);
   SaveColorData();
   SaveTintData();
   SaveDisplayPropertyData();
 }
 
 SkBitmap* BrowserThemeProvider::GenerateBitmap(int id) {
   if (id == IDR_THEME_TAB_BACKGROUND ||
       id == IDR_THEME_TAB_BACKGROUND_INCOGNITO) {
     // The requested image is a background tab. Get a frame to create the
     // tab against. As themes don't use the glass frame, we don't have to
     // worry about compositing them together, as our default theme provides
     // the necessary bitmaps.
     int base_id = (id == IDR_THEME_TAB_BACKGROUND) ?
         IDR_THEME_FRAME : IDR_THEME_FRAME_INCOGNITO;
 
     std::map<int, SkBitmap*>::iterator it = image_cache_.find(base_id);
     if (it != image_cache_.end()) {
       SkBitmap* frame = it->second;
+      int blur_amount = (HasCustomImage(id)) ? 1 : 5;
       SkBitmap blurred =
-          skia::ImageOperations::CreateBlurredBitmap(*frame, 5);
+          skia::ImageOperations::CreateBlurredBitmap(*frame, blur_amount);
       SkBitmap* bg_tab =
           new SkBitmap(TintBitmap(blurred, TINT_BACKGROUND_TAB));
+
+      // If they've provided a custom image, overlay it.
+      if (HasCustomImage(id)) {
+        SkBitmap* overlay = LoadThemeBitmap(id);
+        SkCanvas canvas(*bg_tab);
+        for (int x = 0; x < bg_tab->width(); x += overlay->width())
+          canvas.drawBitmap(*overlay, static_cast<SkScalar>(x), 0, NULL);
+      }
+
+      image_cache_[id] = bg_tab;
       return bg_tab;
     }
   }
 
   return NULL;
 }
 
 void BrowserThemeProvider::SaveImageData(DictionaryValue* images_value) {
   // Save our images data.
   DictionaryValue* pref_images =
@@ skipping 21 matching lines @@
   pref_colors->Clear();
   if (colors_.size()) {
     ColorMap::iterator iter = colors_.begin();
     while (iter != colors_.end()) {
       SkColor rgba = (*iter).second;
       ListValue* rgb_list = new ListValue();
       rgb_list->Set(0, Value::CreateIntegerValue(SkColorGetR(rgba)));
       rgb_list->Set(1, Value::CreateIntegerValue(SkColorGetG(rgba)));
       rgb_list->Set(2, Value::CreateIntegerValue(SkColorGetB(rgba)));
       if (SkColorGetA(rgba) != 255)
-        rgb_list->Set(3, Value::CreateRealValue(SkColorGetA(rgba)));
+        rgb_list->Set(3, Value::CreateRealValue(SkColorGetA(rgba) / 255.0));
       pref_colors->Set(UTF8ToWide((*iter).first), rgb_list);
       ++iter;
     }
   }
 }
 
 void BrowserThemeProvider::SaveTintData() {
   // Save our tint data.
   DictionaryValue* pref_tints =
       profile_->GetPrefs()->GetMutableDictionary(prefs::kCurrentThemeTints);
@@ skipping 26 matching lines @@
                            kDisplayPropertyNTPAlignment) == 0) {
         pref_display_properties->
             SetString(UTF8ToWide((*iter).first), AlignmentToString(
                 (*iter).second));
       } else if (base::strcasecmp((*iter).first.c_str(),
                                   kDisplayPropertyNTPTiling) == 0) {
         pref_display_properties->
             SetString(UTF8ToWide((*iter).first), TilingToString(
                 (*iter).second));
       }
+      if (base::strcasecmp((*iter).first.c_str(),
+                           kDisplayPropertyNTPInverseLogo) == 0) {
+        pref_display_properties->
+            SetInteger(UTF8ToWide((*iter).first), (*iter).second);
+      }
       ++iter;
     }
   }
 }
 
 void BrowserThemeProvider::NotifyThemeChanged() {
   // Redraw!
   NotificationService* service = NotificationService::current();
   service->Notify(NotificationType::BROWSER_THEME_CHANGED,
                   Source<BrowserThemeProvider>(this),
@@ skipping 34 matching lines @@
     delete i->second;
   }
   image_cache_.clear();
 }
 
 #if defined(TOOLKIT_VIEWS)
 void BrowserThemeProvider::FreePlatformCaches() {
   // Views (Skia) has no platform image cache to clear.
 }
 #endif