Load 2x resources on demand

ui/gfx/image/image_skia.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/gfx/image/image_skia.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/threading/non_thread_safe.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/skia_util.h"
 
 namespace gfx {
 namespace {
 
 // static
@@ skipping 18 matching lines @@
 
  private:
   ui::ScaleFactor scale_factor_;
 };
 
 }  // namespace
 
 // A helper class such that ImageSkia can be cheaply copied. ImageSkia holds a
 // refptr instance of ImageSkiaStorage, which in turn holds all of ImageSkia's
 // information.
-class ImageSkiaStorage : public base::RefCounted<ImageSkiaStorage> {
+class ImageSkiaStorage : public base::RefCounted<ImageSkiaStorage>,
+                         public base::NonThreadSafe {
  public:
   ImageSkiaStorage(ImageSkiaSource* source, const gfx::Size& size)
       : source_(source),
         size_(size) {
+    // We only care if the storage is modified by the same thread.
+    // Don't blow up even if someone else created/deleted the ImageSkia.
+    DetachFromThread();
   }
 
   bool has_source() const { return source_.get() != NULL; }
 
   std::vector<gfx::ImageSkiaRep>& image_reps() { return image_reps_; }
 
   const gfx::Size& size() const { return size_; }
 
+  void DeleteSource() {
+    source_.reset();
+  }
+
   // Returns the iterator of the image rep whose density best matches
   // |scale_factor|. If the image for the |scale_factor| doesn't exist
   // in the storage and |storage| is set, it fetches new image by calling
   // |ImageSkiaSource::GetImageForScale|. If the source returns the
   // image with different scale factor (if the image doesn't exist in
   // resource, for example), it will fallback to closest image rep.
   std::vector<ImageSkiaRep>::iterator FindRepresentation(
       ui::ScaleFactor scale_factor, bool fetch_new_image) const {
     ImageSkiaStorage* non_const = const_cast<ImageSkiaStorage*>(this);
 
@@ skipping 15 matching lines @@
         break;
       }
       float diff = std::abs(it->GetScale() - scale);
       if (diff < smallest_diff && !it->is_null()) {
         closest_iter = it;
         smallest_diff = diff;
       }
     }
 
     if (fetch_new_image && source_.get()) {
+      DCHECK(CalledOnValidThread()) <<
+          "An ImageSkia with an ImageSkiaSource is accessed "
+          "by more than one thread.";
+
       ImageSkiaRep image = source_->GetImageForScale(scale_factor);
 
       // If the source returned the new image, store it.
       if (!image.is_null() &&
           std::find_if(image_reps_.begin(), image_reps_.end(),
                        Matcher(image.scale_factor())) == image_reps_.end()) {
         non_const->image_reps().push_back(image);
       }
 
       // If the result image's scale factor isn't same as the expected
       // scale factor, create null ImageSkiaRep with the |scale_factor|
       // so that the next lookup will fallback to the closest scale.
       if (image.is_null() || image.scale_factor() != scale_factor) {
         non_const->image_reps().push_back(
             ImageSkiaRep(SkBitmap(), scale_factor));
       }
 
       // image_reps_ must have the exact much now, so find again.
       return FindRepresentation(scale_factor, false);
     }
     return exact_iter != image_reps_.end() ? exact_iter : closest_iter;
   }
 
  private:
-  ~ImageSkiaStorage() {
+  virtual ~ImageSkiaStorage() {
+    DetachFromThread();
   }
 
   // Vector of bitmaps and their associated scale factor.
   std::vector<gfx::ImageSkiaRep> image_reps_;
 
   scoped_ptr<ImageSkiaSource> source_;
 
   // Size of the image in DIP.
   const gfx::Size size_;
 
@@ skipping 34 matching lines @@
 ImageSkia::~ImageSkia() {
 }
 
 bool ImageSkia::BackedBySameObjectAs(const gfx::ImageSkia& other) const {
   return storage_.get() == other.storage_.get();
 }
 
 void ImageSkia::AddRepresentation(const ImageSkiaRep& image_rep) {
   DCHECK(!image_rep.is_null());
 
+  // TODO(oshima): This method should be called |SetRepresentation|
+  // and replace the existing rep if there is already one with the
+  // same scale factor so that we can guarantee that a ImageSkia
+  // instance contians only one image rep per scale factor. This is
+  // not possible now as ImageLoadingTracker currently stores need
+  // this feature, but this needs to be fixed.
+
   if (isNull())
     Init(image_rep);
   else
     storage_->image_reps().push_back(image_rep);
 }
 
 void ImageSkia::RemoveRepresentation(ui::ScaleFactor scale_factor) {
   if (isNull())
     return;
 
@@ skipping 27 matching lines @@
 }
 
 #if defined(OS_MACOSX)
 
 std::vector<ImageSkiaRep> ImageSkia::GetRepresentations() const {
   if (isNull())
     return std::vector<ImageSkiaRep>();
 
   if (!storage_->has_source())
     return image_reps();
-
-  // Attempt to generate image reps for as many scale factors supported by
-  // this platform as possible.
-  // Do not build return array here because the mapping from scale factor to
-  // image rep is one to many in some cases.
-  std::vector<ui::ScaleFactor> supported_scale_factors =
-      ui::GetSupportedScaleFactors();
-  for (size_t i = 0; i < supported_scale_factors.size(); ++i)
-    storage_->FindRepresentation(supported_scale_factors[i], true);
+  EnsureRepsForSupportedScaleFactors();
 
   return image_reps();
 }
 
 #endif  // OS_MACOSX
 
 int ImageSkia::width() const {
   return isNull() ? 0 : storage_->size().width();
 }
 
@@ skipping 15 matching lines @@
   ImageSkiaReps image_reps;
   for (ImageSkiaReps::iterator it = internal_image_reps.begin();
        it != internal_image_reps.end(); ++it) {
     if (!it->is_null())
       image_reps.push_back(*it);
   }
 
   return image_reps;
 }
 
+void ImageSkia::DeleteSource() {
+  if (storage_)
+    storage_->DeleteSource();
+}
+
+void ImageSkia::EnsureRepsForSupportedScaleFactors() const {
+  if (storage_ && storage_->has_source()) {
+    std::vector<ui::ScaleFactor> supported_scale_factors =
+        ui::GetSupportedScaleFactors();
+    for (size_t i = 0; i < supported_scale_factors.size(); ++i)
+      storage_->FindRepresentation(supported_scale_factors[i], true);
+  }
+}
+
 void ImageSkia::Init(const ImageSkiaRep& image_rep) {
   // TODO(pkotwicz): The image should be null whenever image rep is null.
   if (image_rep.sk_bitmap().empty()) {
     storage_ = NULL;
     return;
   }
   storage_ = new internal::ImageSkiaStorage(
       NULL, gfx::Size(image_rep.GetWidth(), image_rep.GetHeight()));
   storage_->image_reps().push_back(image_rep);
 }
 
 SkBitmap& ImageSkia::GetBitmap() const {
   if (isNull()) {
     // Callers expect a ImageSkiaRep even if it is |isNull()|.
     // TODO(pkotwicz): Fix this.
     return NullImageRep().mutable_sk_bitmap();
   }
 
   ImageSkiaReps::iterator it =
       storage_->FindRepresentation(ui::SCALE_FACTOR_100P, true);
   if (it != storage_->image_reps().end())
     return it->mutable_sk_bitmap();
   return NullImageRep().mutable_sk_bitmap();
 }
 
 }  // namespace gfx