ui/gfx/image/image_skia.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/gfx/image/image_skia.h"
   6
   7 #include <algorithm>
   8 #include <cmath>
   9 #include <limits>
  10
  11 #include "base/command_line.h"
  12 #include "base/logging.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/threading/non_thread_safe.h"
  15 #include "ui/gfx/geometry/size_conversions.h"
  16 #include "ui/gfx/image/image_skia_operations.h"
  17 #include "ui/gfx/image/image_skia_source.h"
  18 #include "ui/gfx/rect.h"
  19 #include "ui/gfx/size.h"
  20 #include "ui/gfx/skia_util.h"
  21 #include "ui/gfx/switches.h"
  22
  23 namespace gfx {
  24 namespace {
  25
  26 // static
  27 gfx::ImageSkiaRep& NullImageRep() {
  28   CR_DEFINE_STATIC_LOCAL(ImageSkiaRep, null_image_rep, ());
  29   return null_image_rep;
  30 }
  31
  32 std::vector<float>* g_supported_scales = NULL;
  33
  34 // The difference to fall back to the smaller scale factor rather than the
  35 // larger one. For example, assume 1.20 is requested but only 1.0 and 2.0 are
  36 // supported. In that case, not fall back to 2.0 but 1.0, and then expand
  37 // the image to 1.25.
  38 const float kFallbackToSmallerScaleDiff = 0.20f;
  39
  40 }  // namespace
  41
  42 namespace internal {
  43 namespace {
  44
  45 class Matcher {
  46  public:
  47   explicit Matcher(float scale) : scale_(scale) {
  48   }
  49
  50   bool operator()(const ImageSkiaRep& rep) const {
  51     return rep.scale() == scale_;
  52   }
  53
  54  private:
  55   float scale_;
  56 };
  57
  58 }  // namespace
  59
  60 // A helper class such that ImageSkia can be cheaply copied. ImageSkia holds a
  61 // refptr instance of ImageSkiaStorage, which in turn holds all of ImageSkia's
  62 // information. Having both |base::RefCountedThreadSafe| and
  63 // |base::NonThreadSafe| may sounds strange but necessary to turn
  64 // the 'thread-non-safe modifiable ImageSkiaStorage' into
  65 // the 'thread-safe read-only ImageSkiaStorage'.
  66 class ImageSkiaStorage : public base::RefCountedThreadSafe<ImageSkiaStorage>,
  67                          public base::NonThreadSafe {
  68  public:
  69   ImageSkiaStorage(ImageSkiaSource* source, const gfx::Size& size)
  70       : source_(source),
  71         size_(size),
  72         read_only_(false) {
  73   }
  74
  75   ImageSkiaStorage(ImageSkiaSource* source, float scale)
  76       : source_(source),
  77         read_only_(false) {
  78     ImageSkia::ImageSkiaReps::iterator it = FindRepresentation(scale, true);
  79     if (it == image_reps_.end() || it->is_null())
  80       source_.reset();
  81     else
  82       size_.SetSize(it->GetWidth(), it->GetHeight());
  83   }
  84
  85   bool has_source() const { return source_.get() != NULL; }
  86
  87   std::vector<gfx::ImageSkiaRep>& image_reps() { return image_reps_; }
  88
  89   const gfx::Size& size() const { return size_; }
  90
  91   bool read_only() const { return read_only_; }
  92
  93   void DeleteSource() {
  94     source_.reset();
  95   }
  96
  97   void SetReadOnly() {
  98     read_only_ = true;
  99   }
 100
 101   void DetachFromThread() {
 102     base::NonThreadSafe::DetachFromThread();
 103   }
 104
 105   // Checks if the current thread can safely modify the storage.
 106   bool CanModify() const {
 107     return !read_only_ && CalledOnValidThread();
 108   }
 109
 110   // Checks if the current thread can safely read the storage.
 111   bool CanRead() const {
 112     return (read_only_ && !source_.get()) || CalledOnValidThread();
 113   }
 114
 115   // Add a new representation. This checks if the scale of the added image
 116   // is not 1.0f, and mark the existing rep as scaled to make
 117   // the image high DPI aware.
 118   void AddRepresentation(const ImageSkiaRep& image) {
 119     if (image.scale() != 1.0f) {
 120       for (ImageSkia::ImageSkiaReps::iterator it = image_reps_.begin();
 121            it < image_reps_.end();
 122            ++it) {
 123         if (it->unscaled()) {
 124           DCHECK_EQ(1.0f, it->scale());
 125           it->SetScaled();
 126           break;
 127         }
 128       }
 129     }
 130     image_reps_.push_back(image);
 131   }
 132
 133   // Returns the iterator of the image rep whose density best matches
 134   // |scale|. If the image for the |scale| doesn't exist in the storage and
 135   // |storage| is set, it fetches new image by calling
 136   // |ImageSkiaSource::GetImageForScale|. There are two modes to deal with
 137   // arbitrary scale factors.
 138   // 1: Invoke GetImageForScale with requested scale and if the source
 139   //   returns the image with different scale (if the image doesn't exist in
 140   //   resource, for example), it will fallback to closest image rep.
 141   // 2: Invoke GetImageForScale with the closest known scale to the requested
 142   //   one and rescale the image.
 143   // Right now only Windows uses 2 and other platforms use 1 by default.
 144   // TODO(mukai, oshima): abandon 1 code path and use 2 for every platforms.
 145   std::vector<ImageSkiaRep>::iterator FindRepresentation(
 146       float scale, bool fetch_new_image) const {
 147     ImageSkiaStorage* non_const = const_cast<ImageSkiaStorage*>(this);
 148
 149     ImageSkia::ImageSkiaReps::iterator closest_iter =
 150         non_const->image_reps().end();
 151     ImageSkia::ImageSkiaReps::iterator exact_iter =
 152         non_const->image_reps().end();
 153     float smallest_diff = std::numeric_limits<float>::max();
 154     for (ImageSkia::ImageSkiaReps::iterator it =
 155              non_const->image_reps().begin();
 156          it < image_reps_.end(); ++it) {
 157       if (it->scale() == scale) {
 158         // found exact match
 159         fetch_new_image = false;
 160         if (it->is_null())
 161           continue;
 162         exact_iter = it;
 163         break;
 164       }
 165       float diff = std::abs(it->scale() - scale);
 166       if (diff < smallest_diff && !it->is_null()) {
 167         closest_iter = it;
 168         smallest_diff = diff;
 169       }
 170     }
 171
 172     if (fetch_new_image && source_.get()) {
 173       DCHECK(CalledOnValidThread()) <<
 174           "An ImageSkia with the source must be accessed by the same thread.";
 175
 176       ImageSkiaRep image;
 177       float resource_scale = scale;
 178       if (ImageSkia::IsDSFScalingInImageSkiaEnabled() && g_supported_scales) {
 179         if (g_supported_scales->back() <= scale) {
 180           resource_scale = g_supported_scales->back();
 181         } else {
 182           for (size_t i = 0; i < g_supported_scales->size(); ++i) {
 183             if ((*g_supported_scales)[i] + kFallbackToSmallerScaleDiff >=
 184                 scale) {
 185               resource_scale = (*g_supported_scales)[i];
 186               break;
 187             }
 188           }
 189         }
 190       }
 191       if (ImageSkia::IsDSFScalingInImageSkiaEnabled() &&
 192           scale != resource_scale) {
 193         std::vector<ImageSkiaRep>::iterator iter = FindRepresentation(
 194             resource_scale, fetch_new_image);
 195
 196         DCHECK(iter != image_reps_.end());
 197
 198         if (!iter->unscaled()) {
 199           SkBitmap scaled_image;
 200           gfx::Size unscaled_size(iter->pixel_width(), iter->pixel_height());
 201           gfx::Size scaled_size = ToCeiledSize(
 202               gfx::ScaleSize(unscaled_size, scale / iter->scale()));
 203
 204           image = ImageSkiaRep(skia::ImageOperations::Resize(
 205               iter->sk_bitmap(),
 206               skia::ImageOperations::RESIZE_LANCZOS3,
 207               scaled_size.width(),
 208               scaled_size.height()), scale);
 209           DCHECK_EQ(image.pixel_width(), scaled_size.width());
 210           DCHECK_EQ(image.pixel_height(), scaled_size.height());
 211         } else {
 212           image = *iter;
 213         }
 214       } else {
 215         image = source_->GetImageForScale(scale);
 216       }
 217
 218       // If the source returned the new image, store it.
 219       if (!image.is_null() &&
 220           std::find_if(image_reps_.begin(), image_reps_.end(),
 221                        Matcher(image.scale())) == image_reps_.end()) {
 222         non_const->image_reps().push_back(image);
 223       }
 224
 225       // If the result image's scale isn't same as the expected scale, create
 226       // null ImageSkiaRep with the |scale| so that the next lookup will
 227       // fallback to the closest scale.
 228       if (image.is_null() || image.scale() != scale) {
 229         non_const->image_reps().push_back(ImageSkiaRep(SkBitmap(), scale));
 230       }
 231
 232       // image_reps_ must have the exact much now, so find again.
 233       return FindRepresentation(scale, false);
 234     }
 235     return exact_iter != image_reps_.end() ? exact_iter : closest_iter;
 236   }
 237
 238  private:
 239   virtual ~ImageSkiaStorage() {
 240     // We only care if the storage is modified by the same thread.
 241     // Don't blow up even if someone else deleted the ImageSkia.
 242     DetachFromThread();
 243   }
 244
 245   // Vector of bitmaps and their associated scale.
 246   std::vector<gfx::ImageSkiaRep> image_reps_;
 247
 248   scoped_ptr<ImageSkiaSource> source_;
 249
 250   // Size of the image in DIP.
 251   gfx::Size size_;
 252
 253   bool read_only_;
 254
 255   friend class base::RefCountedThreadSafe<ImageSkiaStorage>;
 256 };
 257
 258 }  // internal
 259
 260 ImageSkia::ImageSkia() : storage_(NULL) {
 261 }
 262
 263 ImageSkia::ImageSkia(ImageSkiaSource* source, const gfx::Size& size)
 264     : storage_(new internal::ImageSkiaStorage(source, size)) {
 265   DCHECK(source);
 266   // No other thread has reference to this, so it's safe to detach the thread.
 267   DetachStorageFromThread();
 268 }
 269
 270 ImageSkia::ImageSkia(ImageSkiaSource* source, float scale)
 271     : storage_(new internal::ImageSkiaStorage(source, scale)) {
 272   DCHECK(source);
 273   if (!storage_->has_source())
 274     storage_ = NULL;
 275   // No other thread has reference to this, so it's safe to detach the thread.
 276   DetachStorageFromThread();
 277 }
 278
 279 ImageSkia::ImageSkia(const ImageSkiaRep& image_rep) {
 280   Init(image_rep);
 281   // No other thread has reference to this, so it's safe to detach the thread.
 282   DetachStorageFromThread();
 283 }
 284
 285 ImageSkia::ImageSkia(const ImageSkia& other) : storage_(other.storage_) {
 286 }
 287
 288 ImageSkia& ImageSkia::operator=(const ImageSkia& other) {
 289   storage_ = other.storage_;
 290   return *this;
 291 }
 292
 293 ImageSkia::~ImageSkia() {
 294 }
 295
 296 // static
 297 void ImageSkia::SetSupportedScales(const std::vector<float>& supported_scales) {
 298   if (g_supported_scales != NULL)
 299     delete g_supported_scales;
 300   g_supported_scales = new std::vector<float>(supported_scales);
 301   std::sort(g_supported_scales->begin(), g_supported_scales->end());
 302 }
 303
 304 // static
 305 const std::vector<float>& ImageSkia::GetSupportedScales() {
 306   DCHECK(g_supported_scales != NULL);
 307   return *g_supported_scales;
 308 }
 309
 310 // static
 311 float ImageSkia::GetMaxSupportedScale() {
 312   return g_supported_scales->back();
 313 }
 314
 315 // static
 316 ImageSkia ImageSkia::CreateFrom1xBitmap(const SkBitmap& bitmap) {
 317   return ImageSkia(ImageSkiaRep(bitmap, 0.0f));
 318 }
 319
 320 bool ImageSkia::IsDSFScalingInImageSkiaEnabled() {
 321   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 322   return !command_line->HasSwitch(
 323       switches::kDisableArbitraryScaleFactorInImageSkia);
 324 }
 325
 326 scoped_ptr<ImageSkia> ImageSkia::DeepCopy() const {
 327   ImageSkia* copy = new ImageSkia;
 328   if (isNull())
 329     return scoped_ptr<ImageSkia>(copy);
 330
 331   CHECK(CanRead());
 332
 333   std::vector<gfx::ImageSkiaRep>& reps = storage_->image_reps();
 334   for (std::vector<gfx::ImageSkiaRep>::iterator iter = reps.begin();
 335        iter != reps.end(); ++iter) {
 336     copy->AddRepresentation(*iter);
 337   }
 338   // The copy has its own storage. Detach the copy from the current
 339   // thread so that other thread can use this.
 340   if (!copy->isNull())
 341     copy->storage_->DetachFromThread();
 342   return scoped_ptr<ImageSkia>(copy);
 343 }
 344
 345 bool ImageSkia::BackedBySameObjectAs(const gfx::ImageSkia& other) const {
 346   return storage_.get() == other.storage_.get();
 347 }
 348
 349 void ImageSkia::AddRepresentation(const ImageSkiaRep& image_rep) {
 350   DCHECK(!image_rep.is_null());
 351
 352   // TODO(oshima): This method should be called |SetRepresentation|
 353   // and replace the existing rep if there is already one with the
 354   // same scale so that we can guarantee that a ImageSkia instance contains only
 355   // one image rep per scale. This is not possible now as ImageLoader currently
 356   // stores need this feature, but this needs to be fixed.
 357   if (isNull()) {
 358     Init(image_rep);
 359   } else {
 360     CHECK(CanModify());
 361     // If someone is adding ImageSkia explicitly, check if we should
 362     // make the image high DPI aware.
 363     storage_->AddRepresentation(image_rep);
 364   }
 365 }
 366
 367 void ImageSkia::RemoveRepresentation(float scale) {
 368   if (isNull())
 369     return;
 370   CHECK(CanModify());
 371
 372   ImageSkiaReps& image_reps = storage_->image_reps();
 373   ImageSkiaReps::iterator it =
 374       storage_->FindRepresentation(scale, false);
 375   if (it != image_reps.end() && it->scale() == scale)
 376     image_reps.erase(it);
 377 }
 378
 379 bool ImageSkia::HasRepresentation(float scale) const {
 380   if (isNull())
 381     return false;
 382   CHECK(CanRead());
 383
 384   ImageSkiaReps::iterator it = storage_->FindRepresentation(scale, false);
 385   return (it != storage_->image_reps().end() && it->scale() == scale);
 386 }
 387
 388 const ImageSkiaRep& ImageSkia::GetRepresentation(float scale) const {
 389   if (isNull())
 390     return NullImageRep();
 391
 392   CHECK(CanRead());
 393
 394   ImageSkiaReps::iterator it = storage_->FindRepresentation(scale, true);
 395   if (it == storage_->image_reps().end())
 396     return NullImageRep();
 397
 398   return *it;
 399 }
 400
 401 void ImageSkia::SetReadOnly() {
 402   CHECK(storage_.get());
 403   storage_->SetReadOnly();
 404   DetachStorageFromThread();
 405 }
 406
 407 void ImageSkia::MakeThreadSafe() {
 408   CHECK(storage_.get());
 409   EnsureRepsForSupportedScales();
 410   // Delete source as we no longer needs it.
 411   if (storage_.get())
 412     storage_->DeleteSource();
 413   storage_->SetReadOnly();
 414   CHECK(IsThreadSafe());
 415 }
 416
 417 bool ImageSkia::IsThreadSafe() const {
 418   return !storage_.get() || (storage_->read_only() && !storage_->has_source());
 419 }
 420
 421 int ImageSkia::width() const {
 422   return isNull() ? 0 : storage_->size().width();
 423 }
 424
 425 gfx::Size ImageSkia::size() const {
 426   return gfx::Size(width(), height());
 427 }
 428
 429 int ImageSkia::height() const {
 430   return isNull() ? 0 : storage_->size().height();
 431 }
 432
 433 std::vector<ImageSkiaRep> ImageSkia::image_reps() const {
 434   if (isNull())
 435     return std::vector<ImageSkiaRep>();
 436
 437   CHECK(CanRead());
 438
 439   ImageSkiaReps internal_image_reps = storage_->image_reps();
 440   // Create list of image reps to return, skipping null image reps which were
 441   // added for caching purposes only.
 442   ImageSkiaReps image_reps;
 443   for (ImageSkiaReps::iterator it = internal_image_reps.begin();
 444        it != internal_image_reps.end(); ++it) {
 445     if (!it->is_null())
 446       image_reps.push_back(*it);
 447   }
 448
 449   return image_reps;
 450 }
 451
 452 void ImageSkia::EnsureRepsForSupportedScales() const {
 453   DCHECK(g_supported_scales != NULL);
 454   // Don't check ReadOnly because the source may generate images
 455   // even for read only ImageSkia. Concurrent access will be protected
 456   // by |DCHECK(CalledOnValidThread())| in FindRepresentation.
 457   if (storage_.get() && storage_->has_source()) {
 458     for (std::vector<float>::const_iterator it = g_supported_scales->begin();
 459          it != g_supported_scales->end(); ++it)
 460       storage_->FindRepresentation(*it, true);
 461   }
 462 }
 463
 464 void ImageSkia::Init(const ImageSkiaRep& image_rep) {
 465   // TODO(pkotwicz): The image should be null whenever image rep is null.
 466   if (image_rep.sk_bitmap().empty()) {
 467     storage_ = NULL;
 468     return;
 469   }
 470   storage_ = new internal::ImageSkiaStorage(
 471       NULL, gfx::Size(image_rep.GetWidth(), image_rep.GetHeight()));
 472   storage_->image_reps().push_back(image_rep);
 473 }
 474
 475 SkBitmap& ImageSkia::GetBitmap() const {
 476   if (isNull()) {
 477     // Callers expect a ImageSkiaRep even if it is |isNull()|.
 478     // TODO(pkotwicz): Fix this.
 479     return NullImageRep().mutable_sk_bitmap();
 480   }
 481
 482   // TODO(oshima): This made a few tests flaky on Windows.
 483   // Fix the root cause and re-enable this. crbug.com/145623.
 484 #if !defined(OS_WIN)
 485   CHECK(CanRead());
 486 #endif
 487
 488   ImageSkiaReps::iterator it = storage_->FindRepresentation(1.0f, true);
 489   if (it != storage_->image_reps().end())
 490     return it->mutable_sk_bitmap();
 491   return NullImageRep().mutable_sk_bitmap();
 492 }
 493
 494 bool ImageSkia::CanRead() const {
 495   return !storage_.get() || storage_->CanRead();
 496 }
 497
 498 bool ImageSkia::CanModify() const {
 499   return !storage_.get() || storage_->CanModify();
 500 }
 501
 502 void ImageSkia::DetachStorageFromThread() {
 503   if (storage_.get())
 504     storage_->DetachFromThread();
 505 }
 506
 507 }  // namespace gfx