Load 2x resources on demand

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>
 
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 418 matching lines @@
   pack->BuildSourceImagesArray(file_paths);
 
   if (!pack->LoadRawBitmapsTo(file_paths, &pack->images_on_ui_thread_))
     return NULL;
 
   pack->CopyImagesTo(pack->images_on_ui_thread_, &pack->images_on_file_thread_);
 
   pack->CreateImages(&pack->images_on_ui_thread_);
   pack->CreateImages(&pack->images_on_file_thread_);
 
-  // For M22, as it is not possible to easily determine which scale factors are
-  // in use, assume that the 1x scale factor is in use.
-  std::vector<ui::ScaleFactor> scale_factors_in_use;
-  scale_factors_in_use.push_back(ui::SCALE_FACTOR_100P);
-  pack->GenerateImageReps(scale_factors_in_use);
+  // Make sure the |images_on_file_thread_| has bitmaps for supported
+  // scale factors before passing to FILE thread.
+  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();
+  }
 
   // The BrowserThemePack is now in a consistent state.
   return pack;
 }
 
 // static
 scoped_refptr<BrowserThemePack> BrowserThemePack::BuildFromDataPack(
     const FilePath& path, const std::string& expected_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Allow IO on UI thread due to deep-seated theme design issues.
@@ skipping 656 matching lines @@
 void BrowserThemePack::RepackImages(const ImageCache& images,
                                     RawImages* reencoded_images) const {
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   typedef std::vector<ui::ScaleFactor> ScaleFactors;
   for (ImageCache::const_iterator it = images.begin();
        it != images.end(); ++it) {
     gfx::ImageSkia image_skia = *it->second->ToImageSkia();
 
-    // Attempt to generate image reps for all supported scale factors.
-    for (ScaleFactors::const_iterator factor_it = scale_factors_.begin();
-         factor_it != scale_factors_.end(); ++factor_it) {
-      // Ask for representation to force the representation to be generated
-      // if it wasn't already.
-      image_skia.GetRepresentation(*factor_it);
-    }
-
     typedef std::vector<gfx::ImageSkiaRep> ImageSkiaReps;
     ImageSkiaReps image_reps = image_skia.image_reps();
     if (image_reps.empty()) {
       NOTREACHED() << "No image reps for resource " << it->first << ".";
     }
     for (ImageSkiaReps::iterator rep_it = image_reps.begin();
          rep_it != image_reps.end(); ++rep_it) {
       std::vector<unsigned char> bitmap_data;
       if (!gfx::PNGCodec::EncodeBGRASkBitmap(rep_it->sk_bitmap(), false,
                                              &bitmap_data)) {
         NOTREACHED() << "Image file for resource " << it->first
                      << " could not be encoded.";
       }
       int raw_id = GetRawIDByPersistentID(it->first, rep_it->scale_factor());
       (*reencoded_images)[raw_id] =
           base::RefCountedBytes::TakeVector(&bitmap_data);
     }
   }
 }
 
-void BrowserThemePack::GenerateImageReps(
-    const std::vector<ui::ScaleFactor>& scale_factors) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  for (ImageCache::const_iterator it = images_on_ui_thread_.begin();
-       it != images_on_ui_thread_.end();
-       ++it) {
-    const gfx::ImageSkia* image1 = it->second->ToImageSkia();
-    const gfx::ImageSkia* image2 =
-        images_on_file_thread_[it->first]->ToImageSkia();
-
-    // Ensure that image reps are generated and cached in |image1| by
-    // calling GetRepresentation().
-    for (size_t i = 0; i < scale_factors.size(); ++i)
-      image1->GetRepresentation(scale_factors[i]);
-
-    // |image1| and |image2| have ImageSkiaSources which produce pixel
-    // equivalent output. Instead of regenerating again, copy the image reps
-    // which were generated for |image1| into |image2|.
-    // Don't do a deep copy of the SkBitmaps as SkBitmap is thread safe.
-    std::vector<gfx::ImageSkiaRep> image1_reps = image1->image_reps();
-    for (size_t i = 0; i < image1_reps.size(); ++i) {
-      gfx::ImageSkiaRep image1_rep = image1_reps[i];
-      const_cast<gfx::ImageSkia*>(image2)->AddRepresentation(gfx::ImageSkiaRep(
-          image1_rep.sk_bitmap(), image1_rep.scale_factor()));
-    }
-  }
-}
-
 void BrowserThemePack::MergeImageCaches(
     const ImageCache& source, ImageCache* destination) const {
   for (ImageCache::const_iterator it = source.begin(); it != source.end();
        ++it) {
     ImageCache::const_iterator image_it = destination->find(it->first);
     if (image_it != destination->end())
       delete image_it->second;
 
     (*destination)[it->first] = it->second;
   }
@@ skipping 38 matching lines @@
     ui::ScaleFactor scale_factor) const {
   if (prs_id < 0)
     return -1;
 
   for (size_t i = 0; i < scale_factors_.size(); ++i) {
     if (scale_factors_[i] == scale_factor)
       return static_cast<int>(kPersistingImagesLength * i) + prs_id;
   }
   return -1;
 }