Restrict cross-thread access to gfx::Image and gfx::Font in ResourceBundle

ui/base/resource/resource_bundle.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 "ui/base/resource/resource_bundle.h"
 
 #include <stdint.h>
 
 #include <limits>
 #include <utility>
@@ skipping 384 matching lines @@
   base::AutoLock lock_scope(*locale_resources_data_lock_);
 
   // Remove all overriden strings, as they will not be valid for the new locale.
   overridden_locale_strings_.clear();
 
   UnloadLocaleResources();
   return LoadLocaleResources(pref_locale);
 }
 
 gfx::ImageSkia* ResourceBundle::GetImageSkiaNamed(int resource_id) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
+
   const gfx::ImageSkia* image = GetImageNamed(resource_id).ToImageSkia();
   return const_cast<gfx::ImageSkia*>(image);
 }
 
 gfx::Image& ResourceBundle::GetImageNamed(int resource_id) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
+
   // Check to see if the image is already in the cache.
-  {
-    base::AutoLock lock_scope(*images_and_fonts_lock_);
-    if (images_.count(resource_id))
-      return images_[resource_id];
-  }
+  if (images_.count(resource_id))
+    return images_[resource_id];
 
   gfx::Image image;
   if (delegate_)
     image = delegate_->GetImageNamed(resource_id);
 
   if (image.IsEmpty()) {
     DCHECK(!data_packs_.empty()) <<
         "Missing call to SetResourcesDataDLL?";
 
 #if defined(OS_CHROMEOS)
@@ skipping 17 matching lines @@
       LOG(WARNING) << "Unable to load image with id " << resource_id;
       NOTREACHED();  // Want to assert in debug mode.
       // The load failed to retrieve the image; show a debugging red square.
       return GetEmptyImage();
     }
     image_skia.SetReadOnly();
     image = gfx::Image(image_skia);
   }
 
   // The load was successful, so cache the image.
-  base::AutoLock lock_scope(*images_and_fonts_lock_);
-
-  // Another thread raced the load and has already cached the image.
-  if (images_.count(resource_id))
-    return images_[resource_id];
-
   images_[resource_id] = image;
   return images_[resource_id];
 }
 
 base::RefCountedMemory* ResourceBundle::LoadDataResourceBytes(
     int resource_id) const {
   return LoadDataResourceBytesForScale(resource_id, ui::SCALE_FACTOR_NONE);
 }
 
 base::RefCountedMemory* ResourceBundle::LoadDataResourceBytesForScale(
@@ skipping 110 matching lines @@
     }
   }
   // Release lock_scope and fall back to main data pack.
   return LoadDataResourceBytes(resource_id);
 }
 
 const gfx::FontList& ResourceBundle::GetFontListWithDelta(
     int size_delta,
     gfx::Font::FontStyle style,
     gfx::Font::Weight weight) {
-  base::AutoLock lock_scope(*images_and_fonts_lock_);
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   const FontKey styled_key(size_delta, style, weight);
 
   auto found = font_cache_.find(styled_key);
   if (found != font_cache_.end())
     return found->second;
 
   const FontKey base_key(0, gfx::Font::NORMAL, gfx::Font::Weight::NORMAL);
   gfx::FontList& base = font_cache_[base_key];
   if (styled_key == base_key)
@@ skipping 15 matching lines @@
   DCHECK(styled.second);  // Otherwise font_cache_.find(..) would have found it.
   styled.first->second = sized.first->second.Derive(
       0, sized.first->second.GetFontStyle() | style, weight);
 
   return styled.first->second;
 }
 
 const gfx::Font& ResourceBundle::GetFontWithDelta(int size_delta,
                                                   gfx::Font::FontStyle style,
                                                   gfx::Font::Weight weight) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   return GetFontListWithDelta(size_delta, style, weight).GetPrimaryFont();
 }
 
 const gfx::FontList& ResourceBundle::GetFontList(FontStyle legacy_style) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   gfx::Font::Weight font_weight = gfx::Font::Weight::NORMAL;
   if (legacy_style == BoldFont || legacy_style == MediumBoldFont)
     font_weight = gfx::Font::Weight::BOLD;
 
   int size_delta = 0;
   switch (legacy_style) {
     case SmallFont:
       size_delta = kSmallFontDelta;
       break;
     case MediumFont:
     case MediumBoldFont:
       size_delta = kMediumFontDelta;
       break;
     case LargeFont:
       size_delta = kLargeFontDelta;
       break;
     case BaseFont:
     case BoldFont:
       break;
   }
 
   return GetFontListWithDelta(size_delta, gfx::Font::NORMAL, font_weight);
 }
 
 const gfx::Font& ResourceBundle::GetFont(FontStyle style) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   return GetFontList(style).GetPrimaryFont();
 }
 
 void ResourceBundle::ReloadFonts() {
-  base::AutoLock lock_scope(*images_and_fonts_lock_);
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   InitDefaultFontList();
   font_cache_.clear();
 }
 
 ScaleFactor ResourceBundle::GetMaxScaleFactor() const {
 #if defined(OS_CHROMEOS) || defined(OS_WIN) || defined(OS_LINUX)
   return max_scale_factor_;
 #else
   return GetSupportedScaleFactors().back();
 #endif
 }
 
 bool ResourceBundle::IsScaleFactorSupported(ScaleFactor scale_factor) {
   const std::vector<ScaleFactor>& supported_scale_factors =
       ui::GetSupportedScaleFactors();
   return std::find(supported_scale_factors.begin(),
                    supported_scale_factors.end(),
                    scale_factor) != supported_scale_factors.end();
 }
 
 ResourceBundle::ResourceBundle(Delegate* delegate)
     : delegate_(delegate),
-      images_and_fonts_lock_(new base::Lock),
       locale_resources_data_lock_(new base::Lock),
       max_scale_factor_(SCALE_FACTOR_100P) {
 }
 
 ResourceBundle::~ResourceBundle() {
   FreeImages();
   UnloadLocaleResources();
 }
 
 // static
@@ skipping 163 matching lines @@
         *fell_back_to_1x = true;
         return true;
       }
     }
   }
 
   return false;
 }
 
 gfx::Image& ResourceBundle::GetEmptyImage() {
-  base::AutoLock lock(*images_and_fonts_lock_);
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (empty_image_.IsEmpty()) {
     // The placeholder bitmap is bright red so people notice the problem.
     SkBitmap bitmap = CreateEmptyBitmap();
     empty_image_ = gfx::Image::CreateFrom1xBitmap(bitmap);
   }
   return empty_image_;
 }
 
 // static
@@ skipping 34 matching lines @@
 // static
 bool ResourceBundle::DecodePNG(const unsigned char* buf,
                                size_t size,
                                SkBitmap* bitmap,
                                bool* fell_back_to_1x) {
   *fell_back_to_1x = PNGContainsFallbackMarker(buf, size);
   return gfx::PNGCodec::Decode(buf, size, bitmap);
 }
 
 }  // namespace ui