Theme suppliers: Avoid all Image copying.

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>
 #include <memory>
+#include <utility>
 
 #include "base/files/file.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 591 matching lines @@
       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_))
+  // Create images for use on the FILE thread (which is where these Image
+  // objects will live).
+  if (!pack->LoadRawBitmapsTo(file_paths, &pack->images_on_file_thread_))
     return NULL;
 
-  pack->CreateImages(&pack->images_on_ui_thread_);
+  pack->CreateImages(&pack->images_on_file_thread_);
 
   // 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_;
-  for (ImageCache::iterator it = pack->images_on_file_thread_.begin();
-       it != pack->images_on_file_thread_.end(); ++it) {
+  for (auto& item : pack->images_on_file_thread_) {
     gfx::ImageSkia* image_skia =
-        const_cast<gfx::ImageSkia*>(it->second.ToImageSkia());
+        const_cast<gfx::ImageSkia*>(item.second.ToImageSkia());
     image_skia->MakeThreadSafe();
   }
 
+  // Copy the images over for use on the UI thread. To avoid sharing
+  // thread-unsafe Image objects across threads, new Image objects are created.
+  //
   // Set ThemeImageSource on |images_on_ui_thread_| 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) {
-    const gfx::ImageSkia source_image_skia = it->second.AsImageSkia();
+  for (auto& item : pack->images_on_file_thread_) {
+    const gfx::ImageSkia source_image_skia = item.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);
+    pack->images_on_ui_thread_.insert(
+        std::make_pair(item.first, 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;
@@ skipping 147 matching lines @@
       if (display_properties_[i].id == id) {
         *result = display_properties_[i].property;
         return true;
       }
     }
   }
 
   return false;
 }
 
-gfx::Image BrowserThemePack::GetImageNamed(int idr_id) {
+const gfx::Image& BrowserThemePack::GetImageNamed(int idr_id) {
   int prs_id = GetPersistentIDByIDR(idr_id);
   if (prs_id == -1)
-    return gfx::Image();
+    return empty_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())
     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;
-    return ret;
+    auto result = images_on_ui_thread_.insert(
+        std::make_pair(prs_id, gfx::Image(image_skia)));
+    return result.first->second;
   }
 
-  return gfx::Image();
+  return empty_image();
 }
 
 base::RefCountedMemory* BrowserThemePack::GetRawData(
     int idr_id,
     ui::ScaleFactor scale_factor) const {
   base::RefCountedMemory* memory = NULL;
   int prs_id = GetPersistentIDByIDR(idr_id);
   int raw_id = GetRawIDByPersistentID(prs_id, scale_factor);
 
   if (raw_id != -1) {
@@ skipping 429 matching lines @@
 
 void BrowserThemePack::CreateFrameImages(ImageCache* images) const {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 
   // Create all the output images in a separate cache and move them back into
   // the input images because there can be name collisions.
   ImageCache temp_output;
 
   for (size_t i = 0; i < arraysize(kFrameTintMap); ++i) {
     int prs_id = kFrameTintMap[i].key;
-    gfx::Image frame;
+    const gfx::Image* frame = &empty_image();
     // 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 prs_base_id = 0;
 
     if (!prs_base_id) {
       if (prs_id == PRS_THEME_FRAME_INCOGNITO_INACTIVE) {
         prs_base_id = images->count(PRS_THEME_FRAME_INCOGNITO) ?
                       PRS_THEME_FRAME_INCOGNITO : PRS_THEME_FRAME;
       } else if (prs_id == PRS_THEME_FRAME_OVERLAY_INACTIVE) {
         prs_base_id = PRS_THEME_FRAME_OVERLAY;
       } else if (prs_id == PRS_THEME_FRAME_INACTIVE) {
         prs_base_id = PRS_THEME_FRAME;
       } else if (prs_id == PRS_THEME_FRAME_INCOGNITO &&
                  !images->count(PRS_THEME_FRAME_INCOGNITO)) {
         prs_base_id = PRS_THEME_FRAME;
       } else {
         prs_base_id = prs_id;
       }
     }
     if (images->count(prs_id)) {
-      frame = (*images)[prs_id];
+      frame = &(*images)[prs_id];
     } else if (prs_base_id != prs_id && images->count(prs_base_id)) {
-      frame = (*images)[prs_base_id];
-    } else if (prs_base_id == PRS_THEME_FRAME_OVERLAY) {
-      if (images->count(PRS_THEME_FRAME)) {
-        // If there is no theme overlay, don't tint the default frame,
-        // because it will overwrite the custom frame image when we cache and
-        // reload from disk.
-        frame = gfx::Image();
-      }
-    } else {
-      // If the theme doesn't specify an image, then apply the tint to
-      // the default frame.
-      frame = rb.GetImageNamed(IDR_THEME_FRAME);
+      frame = &(*images)[prs_base_id];
+    } else if (prs_base_id != PRS_THEME_FRAME_OVERLAY) {
+      // If there is no theme overlay, don't tint the default frame,
+      // because it will overwrite the custom frame image when we cache and
+      // reload from disk. If the theme doesn't specify an image, then apply the
+      // tint to the default frame.
+      frame = &rb.GetImageNamed(IDR_THEME_FRAME);
     }
-    if (!frame.IsEmpty()) {
+    if (!frame->IsEmpty()) {
       temp_output[prs_id] = CreateHSLShiftedImage(
-          frame, GetTintInternal(kFrameTintMap[i].value));
+          *frame, GetTintInternal(kFrameTintMap[i].value));
     }
   }
-  MergeImageCaches(temp_output, images);
+  MergeImageCaches(std::move(temp_output), images);
 }
 
 void BrowserThemePack::CreateTintedButtons(
     const color_utils::HSL& button_tint,
     ImageCache* processed_images) const {
   if (button_tint.h != -1 || button_tint.s != -1 || button_tint.l != -1) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     const std::set<int>& idr_ids =
         ThemeProperties::GetTintableToolbarButtons();
     for (std::set<int>::const_iterator it = idr_ids.begin();
@@ skipping 32 matching lines @@
       if (overlay_it != images->end())
         overlay = overlay_it->second.AsImageSkia();
 
       gfx::ImageSkiaSource* source = new TabBackgroundImageSource(
           image_to_tint, overlay, hsl_shift, vertical_offset);
       // ImageSkia takes ownership of |source|.
       temp_output[prs_id] = gfx::Image(gfx::ImageSkia(source,
           image_to_tint.size()));
     }
   }
-  MergeImageCaches(temp_output, images);
+  MergeImageCaches(std::move(temp_output), images);
 }
 
 void BrowserThemePack::RepackImages(const ImageCache& images,
                                     RawImages* reencoded_images) const {
   for (ImageCache::const_iterator it = images.begin();
        it != images.end(); ++it) {
     gfx::ImageSkia image_skia = *it->second.ToImageSkia();
 
     typedef std::vector<gfx::ImageSkiaRep> ImageSkiaReps;
     ImageSkiaReps image_reps = image_skia.image_reps();
@@ skipping 10 matching lines @@
       }
       int raw_id = GetRawIDByPersistentID(
           it->first,
           ui::GetSupportedScaleFactor(rep_it->scale()));
       (*reencoded_images)[raw_id] =
           base::RefCountedBytes::TakeVector(&bitmap_data);
     }
   }
 }
 
-void BrowserThemePack::MergeImageCaches(
-    const ImageCache& source, ImageCache* destination) const {
-  for (ImageCache::const_iterator it = source.begin(); it != source.end();
-       ++it) {
-    (*destination)[it->first] = it->second;
-  }
+void BrowserThemePack::MergeImageCaches(ImageCache source,
+                                        ImageCache* destination) const {
+  for (auto& item : source)
+    (*destination)[item.first] = std::move(item.second);
 }
 
 void BrowserThemePack::AddRawImagesTo(const RawImages& images,
                                       RawDataForWriting* out) const {
   for (RawImages::const_iterator it = images.begin(); it != images.end();
        ++it) {
     (*out)[it->first] = base::StringPiece(
         it->second->front_as<char>(), it->second->size());
   }
 }
@@ skipping 106 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);
   }
 }