Add support for multi resolution icons

chrome/browser/themes/browser_theme_pack.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/themes/browser_theme_pack.h"
 
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "content/browser/browser_thread.h"
 #include "grit/app_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/file_stream.h"
 #include "net/base/net_errors.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/base/resource/data_pack.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/codec/tiff_codec.h"
 #include "ui/gfx/skbitmap_operations.h"
 
 namespace {
 
 // Version number of the current theme pack. We just throw out and rebuild
 // theme packs that aren't int-equal to this.
 const int kThemePackVersion = 15;

[Elliot Glaysher, 2011/04/14 18:33:41]

Are old theme packs binary compatible with this new code? If they aren't, you
need to increment this.

 
 // IDs that are in the DataPack won't clash with the positive integer
 // int32_t. kHeaderID should always have the maximum value because we want the
 // "header" to be written last. That way we can detect whether the pack was
 // successfully written and ignore and regenerate if it was only partially
 // written (i.e. chrome crashed on a different thread while writing the pack).
 const int kHeaderID = UINT_MAX - 1;
 const int kTintsID = UINT_MAX - 2;
 const int kColorsID = UINT_MAX - 3;
 const int kDisplayPropertiesID = UINT_MAX - 4;
@@ skipping 277 matching lines @@
 BrowserThemePack::~BrowserThemePack() {
   if (!data_pack_.get()) {
     delete header_;
     delete [] tints_;
     delete [] colors_;
     delete [] display_properties_;
     delete [] source_images_;
   }
 
   STLDeleteValues(&prepared_images_);
+  for (MultiResImageCache::iterator i = loaded_images_.begin();
+       i != loaded_images_.end(); ++i) {
+    STLDeleteContainerPointers(i->second->begin(), i->second->end());
+  }
   STLDeleteValues(&loaded_images_);
 }
 
 // static
 BrowserThemePack* BrowserThemePack::BuildFromExtension(
     const Extension* extension) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(extension);
   DCHECK(extension->is_theme());
 
@@ skipping 150 matching lines @@
         *result = display_properties_[i].property;
         return true;
       }
     }
   }
 
   return false;
 }
 
 SkBitmap* BrowserThemePack::GetBitmapNamed(int idr_id) const {
+  std::vector<SkBitmap*> bitmaps;
+  if (!GetBitmapsNamed(idr_id, bitmaps))
+    return NULL;
+  if (bitmaps.empty())
+    return NULL;
+  return *bitmaps.begin();
+}
+
+bool BrowserThemePack::GetBitmapsNamed(
+    int idr_id, std::vector<SkBitmap*>& bitmaps) const {
   int prs_id = GetPersistentIDByIDR(idr_id);
   if (prs_id == -1)
-    return NULL;
+    return false;
 
   // Check our cache of prepared images, first.
   ImageCache::const_iterator image_iter = prepared_images_.find(prs_id);
-  if (image_iter != prepared_images_.end())
-    return image_iter->second;
+  if (image_iter != prepared_images_.end()) {
+    bitmaps.push_back(image_iter->second);
+    return true;
+  }
 
   // Check if we've already loaded this image.
-  image_iter = loaded_images_.find(prs_id);
-  if (image_iter != loaded_images_.end())
-    return image_iter->second;
+  MultiResImageCache::const_iterator multi_image_iter =
+      loaded_images_.find(prs_id);
+  if (multi_image_iter != loaded_images_.end()) {
+    bitmaps = *(multi_image_iter->second);
+    return true;
+  }
 
   scoped_refptr<RefCountedMemory> memory;
   if (data_pack_.get()) {
     memory = data_pack_->GetStaticMemory(prs_id);
   } else {
     RawImages::const_iterator it = image_memory_.find(prs_id);
     if (it != image_memory_.end()) {
       memory = it->second;
     }
   }
 
   if (memory.get()) {
-    // Decode the PNG.
+    // Try to decode it as a PNG.
     SkBitmap bitmap;
-    if (!gfx::PNGCodec::Decode(memory->front(), memory->size(),
-                               &bitmap)) {
-      NOTREACHED() << "Unable to decode theme image resource " << idr_id
-                   << " from saved DataPack.";
-      return NULL;
+    if (gfx::PNGCodec::Decode(memory->front(), memory->size(),&bitmap)) {
+      std::vector<SkBitmap*>* bitmaps_ptr = new std::vector<SkBitmap*>;
+      bitmaps_ptr->push_back(new SkBitmap(bitmap));
+      loaded_images_[prs_id] = bitmaps_ptr;
+      return true;
     }
 
-    SkBitmap* ret = new SkBitmap(bitmap);
-    loaded_images_[prs_id] = ret;
+    // Try to decode it as a TIFF.
+    std::vector<SkBitmap> bitmaps;
+    if (gfx::TIFFCodec::Decode(memory->front(), memory->size(), bitmaps)) {
+      std::vector<SkBitmap*>* bitmaps_ptr = new std::vector<SkBitmap*>;
+      for (std::vector<SkBitmap>::iterator it = bitmaps.begin();
+           it != bitmaps.end(); ++it) {
+        bitmaps_ptr->push_back(new SkBitmap(*it));
+      }
+      loaded_images_[prs_id] = bitmaps_ptr;
+      return true;
+    }
 
-    return ret;
+    NOTREACHED() << "Unable to decode theme image resource " << idr_id
+                 << " from saved DataPack.";
   }
 
-  return NULL;
+  return false;
 }
 
 RefCountedMemory* BrowserThemePack::GetRawData(int idr_id) const {
   RefCountedMemory* memory = NULL;
   int prs_id = GetPersistentIDByIDR(idr_id);
 
   if (prs_id != -1) {
     if (data_pack_.get()) {
       memory = data_pack_->GetStaticMemory(prs_id);
     } else {
@@ skipping 494 matching lines @@
         hsl.h = tints_[i].h;
         hsl.s = tints_[i].s;
         hsl.l = tints_[i].l;
         return hsl;
       }
     }
   }
 
   return ThemeService::GetDefaultTint(id);
 }