Unpack theme data from extensions off of UI thread.

chrome/browser/themes/browser_theme_pack.cc

 // Copyright (c) 2012 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 <limits.h>
 #include <stddef.h>
 
 #include <limits>
@@ skipping 528 matching lines @@
   if (!data_pack_.get()) {
     delete header_;
     delete [] tints_;
     delete [] colors_;
     delete [] display_properties_;
     delete [] source_images_;
   }
 }
 
 // static
-scoped_refptr<BrowserThemePack> BrowserThemePack::BuildFromExtension(
-    const Extension* extension) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+void BrowserThemePack::BuildFromExtension(
+    const extensions::Extension* extension,
+    scoped_refptr<BrowserThemePack> pack) {
   DCHECK(extension);
   DCHECK(extension->is_theme());
+  DCHECK(!pack->is_valid());
 
-  scoped_refptr<BrowserThemePack> pack(new BrowserThemePack);
   pack->BuildHeader(extension);
   pack->BuildTintsFromJSON(extensions::ThemeInfo::GetTints(extension));
   pack->BuildColorsFromJSON(extensions::ThemeInfo::GetColors(extension));
   pack->BuildDisplayPropertiesFromJSON(
       extensions::ThemeInfo::GetDisplayProperties(extension));
 
   // Builds the images. (Image building is dependent on tints).
   FilePathMap file_paths;
   pack->ParseImageNamesFromJSON(
       extensions::ThemeInfo::GetImages(extension),
       extension->path(),
       &file_paths);
   pack->BuildSourceImagesArray(file_paths);
 
-  if (!pack->LoadRawBitmapsTo(file_paths, &pack->images_on_ui_thread_))
-    return NULL;
+  if (!pack->LoadRawBitmapsTo(file_paths, &pack->images_))
+    return;
 
-  pack->CreateImages(&pack->images_on_ui_thread_);
+  pack->CreateImages(&pack->images_);
 
   // Make sure the |images_on_file_thread_| has bitmaps for supported
   // scale factors before passing to FILE thread.
-  pack->images_on_file_thread_ = pack->images_on_ui_thread_;
+  pack->images_on_file_thread_ = pack->images_;
   for (ImageCache::iterator it = pack->images_on_file_thread_.begin();
        it != pack->images_on_file_thread_.end(); ++it) {
     gfx::ImageSkia* image_skia =
         const_cast<gfx::ImageSkia*>(it->second.ToImageSkia());
     image_skia->MakeThreadSafe();
   }
 
-  // Set ThemeImageSource on |images_on_ui_thread_| to resample the source
+  // Set ThemeImageSource on |images_| to resample the source
   // image if a caller of BrowserThemePack::GetImageNamed() requests an
   // ImageSkiaRep for a scale factor not specified by the theme author.
   // Callers of BrowserThemePack::GetImageNamed() to be able to retrieve
   // ImageSkiaReps for all supported scale factors.
-  for (ImageCache::iterator it = pack->images_on_ui_thread_.begin();
-       it != pack->images_on_ui_thread_.end(); ++it) {
+  for (ImageCache::iterator it = pack->images_.begin();
+       it != pack->images_.end(); ++it) {
     const gfx::ImageSkia source_image_skia = it->second.AsImageSkia();
     ThemeImageSource* source = new ThemeImageSource(source_image_skia);
     // image_skia takes ownership of source.
     gfx::ImageSkia image_skia(source, source_image_skia.size());
     it->second = gfx::Image(image_skia);
   }
 
   // Generate raw images (for new-tab-page attribution and background) for
   // any missing scale from an available scale image.
   for (size_t i = 0; i < arraysize(kPreloadIDs); ++i) {
     pack->GenerateRawImageForAllSupportedScales(kPreloadIDs[i]);
   }
 
   // The BrowserThemePack is now in a consistent state.
-  return pack;
+  pack->is_valid_ = true;
 }
 
 // static
 scoped_refptr<BrowserThemePack> BrowserThemePack::BuildFromDataPack(
     const base::FilePath& path, const std::string& expected_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Allow IO on UI thread due to deep-seated theme design issues.
   // (see http://crbug.com/80206)
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   scoped_refptr<BrowserThemePack> pack(new BrowserThemePack);
@@ skipping 47 matching lines @@
       const_cast<char*>(pointer.data()));
 
   if (!pack->data_pack_->GetStringPiece(kScaleFactorsID, &pointer))
     return NULL;
 
   if (!InputScalesValid(pointer, pack->scale_factors_)) {
     DLOG(ERROR) << "BuildFromDataPack failure! The pack scale factors differ "
                 << "from those supported by platform.";
     return NULL;
   }
+  pack->is_valid_ = true;
   return pack;
 }
 
 // static
 bool BrowserThemePack::IsPersistentImageID(int id) {
   for (size_t i = 0; i < kPersistingImagesLength; ++i)
     if (kPersistingImages[i].idr_id == id)
       return true;
 
   return false;
 }
 
+BrowserThemePack::BrowserThemePack() : CustomThemeSupplier(EXTENSION) {
+  scale_factors_ = ui::GetSupportedScaleFactors();
+  // On Windows HiDPI SCALE_FACTOR_100P may not be supported by default.
+  if (!base::ContainsValue(scale_factors_, ui::SCALE_FACTOR_100P))
+    scale_factors_.push_back(ui::SCALE_FACTOR_100P);
+}
+
 bool BrowserThemePack::WriteToDisk(const base::FilePath& path) const {
   // Add resources for each of the property arrays.
   RawDataForWriting resources;
   resources[kHeaderID] = base::StringPiece(
       reinterpret_cast<const char*>(header_), sizeof(BrowserThemePackHeader));
   resources[kTintsID] = base::StringPiece(
       reinterpret_cast<const char*>(tints_),
       sizeof(TintEntry[kTintTableLength]));
   resources[kColorsID] = base::StringPiece(
       reinterpret_cast<const char*>(colors_),
@@ skipping 68 matching lines @@
 
   return false;
 }
 
 gfx::Image BrowserThemePack::GetImageNamed(int idr_id) {
   int prs_id = GetPersistentIDByIDR(idr_id);
   if (prs_id == -1)
     return gfx::Image();
 
   // Check if the image is cached.
-  ImageCache::const_iterator image_iter = images_on_ui_thread_.find(prs_id);
-  if (image_iter != images_on_ui_thread_.end())
+  ImageCache::const_iterator image_iter = images_.find(prs_id);
+  if (image_iter != images_.end())
     return image_iter->second;
 
   ThemeImagePngSource::PngMap png_map;
   for (size_t i = 0; i < scale_factors_.size(); ++i) {
     scoped_refptr<base::RefCountedMemory> memory =
         GetRawData(idr_id, scale_factors_[i]);
     if (memory.get())
       png_map[scale_factors_[i]] = memory;
   }
   if (!png_map.empty()) {
     gfx::ImageSkia image_skia(new ThemeImagePngSource(png_map), 1.0f);
     // |image_skia| takes ownership of ThemeImagePngSource.
     gfx::Image ret = gfx::Image(image_skia);
-    images_on_ui_thread_[prs_id] = ret;
+    images_[prs_id] = ret;
     return ret;
   }
 
   return gfx::Image();
 }
 
 base::RefCountedMemory* BrowserThemePack::GetRawData(
     int idr_id,
     ui::ScaleFactor scale_factor) const {
   base::RefCountedMemory* memory = NULL;
@@ skipping 23 matching lines @@
   for (; *img != -1; ++img) {
     if (*img == prs_id)
       return true;
   }
 
   return false;
 }
 
 // private:
 
-BrowserThemePack::BrowserThemePack()
-    : CustomThemeSupplier(EXTENSION),
-      header_(NULL),
-      tints_(NULL),
-      colors_(NULL),
-      display_properties_(NULL),
-      source_images_(NULL) {
-  scale_factors_ = ui::GetSupportedScaleFactors();
-  // On Windows HiDPI SCALE_FACTOR_100P may not be supported by default.
-  if (!base::ContainsValue(scale_factors_, ui::SCALE_FACTOR_100P))
-    scale_factors_.push_back(ui::SCALE_FACTOR_100P);
-}
-
 void BrowserThemePack::BuildHeader(const Extension* extension) {
   header_ = new BrowserThemePackHeader;
   header_->version = kThemePackVersion;
 
   // TODO(erg): Need to make this endian safe on other computers. Prerequisite
   // is that ui::DataPack removes this same check.
 #if defined(__BYTE_ORDER)
   // Linux check
   static_assert(__BYTE_ORDER == __LITTLE_ENDIAN,
                 "datapack assumes little endian");
@@ skipping 574 matching lines @@
                                            false,
                                            &bitmap_data)) {
       NOTREACHED() << "Unable to encode theme image for prs_id="
                    << prs_id << " for scale_factor=" << scale_factors_[i];
       break;
     }
     image_memory_[scaled_raw_id] =
         base::RefCountedBytes::TakeVector(&bitmap_data);
   }
 }