| OLD | NEW |
|---|
| (Empty) |
| 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 ImageSkiaRep ScaleImageSkiaRep(const ImageSkiaRep& rep, float target_scale) { | |
| 59 if (rep.is_null() || rep.scale() == target_scale) | |
| 60 return rep; | |
| 61 | |
| 62 gfx::Size scaled_size = ToCeiledSize( | |
| 63 gfx::ScaleSize(rep.pixel_size(), target_scale / rep.scale())); | |
| 64 return ImageSkiaRep(skia::ImageOperations::Resize( | |
| 65 rep.sk_bitmap(), | |
| 66 skia::ImageOperations::RESIZE_LANCZOS3, | |
| 67 scaled_size.width(), | |
| 68 scaled_size.height()), target_scale); | |
| 69 } | |
| 70 | |
| 71 } // namespace | |
| 72 | |
| 73 // A helper class such that ImageSkia can be cheaply copied. ImageSkia holds a | |
| 74 // refptr instance of ImageSkiaStorage, which in turn holds all of ImageSkia's | |
| 75 // information. Having both |base::RefCountedThreadSafe| and | |
| 76 // |base::NonThreadSafe| may sounds strange but necessary to turn | |
| 77 // the 'thread-non-safe modifiable ImageSkiaStorage' into | |
| 78 // the 'thread-safe read-only ImageSkiaStorage'. | |
| 79 class ImageSkiaStorage : public base::RefCountedThreadSafe<ImageSkiaStorage>, | |
| 80 public base::NonThreadSafe { | |
| 81 public: | |
| 82 ImageSkiaStorage(ImageSkiaSource* source, const gfx::Size& size) | |
| 83 : source_(source), | |
| 84 size_(size), | |
| 85 read_only_(false) { | |
| 86 } | |
| 87 | |
| 88 ImageSkiaStorage(ImageSkiaSource* source, float scale) | |
| 89 : source_(source), | |
| 90 read_only_(false) { | |
| 91 ImageSkia::ImageSkiaReps::iterator it = FindRepresentation(scale, true); | |
| 92 if (it == image_reps_.end() || it->is_null()) | |
| 93 source_.reset(); | |
| 94 else | |
| 95 size_.SetSize(it->GetWidth(), it->GetHeight()); | |
| 96 } | |
| 97 | |
| 98 bool has_source() const { return source_.get() != NULL; } | |
| 99 | |
| 100 std::vector<gfx::ImageSkiaRep>& image_reps() { return image_reps_; } | |
| 101 | |
| 102 const gfx::Size& size() const { return size_; } | |
| 103 | |
| 104 bool read_only() const { return read_only_; } | |
| 105 | |
| 106 void DeleteSource() { | |
| 107 source_.reset(); | |
| 108 } | |
| 109 | |
| 110 void SetReadOnly() { | |
| 111 read_only_ = true; | |
| 112 } | |
| 113 | |
| 114 void DetachFromThread() { | |
| 115 base::NonThreadSafe::DetachFromThread(); | |
| 116 } | |
| 117 | |
| 118 // Checks if the current thread can safely modify the storage. | |
| 119 bool CanModify() const { | |
| 120 return !read_only_ && CalledOnValidThread(); | |
| 121 } | |
| 122 | |
| 123 // Checks if the current thread can safely read the storage. | |
| 124 bool CanRead() const { | |
| 125 return (read_only_ && !source_.get()) || CalledOnValidThread(); | |
| 126 } | |
| 127 | |
| 128 // Add a new representation. This checks if the scale of the added image | |
| 129 // is not 1.0f, and mark the existing rep as scaled to make | |
| 130 // the image high DPI aware. | |
| 131 void AddRepresentation(const ImageSkiaRep& image) { | |
| 132 if (image.scale() != 1.0f) { | |
| 133 for (ImageSkia::ImageSkiaReps::iterator it = image_reps_.begin(); | |
| 134 it < image_reps_.end(); | |
| 135 ++it) { | |
| 136 if (it->unscaled()) { | |
| 137 DCHECK_EQ(1.0f, it->scale()); | |
| 138 it->SetScaled(); | |
| 139 break; | |
| 140 } | |
| 141 } | |
| 142 } | |
| 143 image_reps_.push_back(image); | |
| 144 } | |
| 145 | |
| 146 // Returns the iterator of the image rep whose density best matches | |
| 147 // |scale|. If the image for the |scale| doesn't exist in the storage and | |
| 148 // |storage| is set, it fetches new image by calling | |
| 149 // |ImageSkiaSource::GetImageForScale|. There are two modes to deal with | |
| 150 // arbitrary scale factors. | |
| 151 // 1: Invoke GetImageForScale with requested scale and if the source | |
| 152 // returns the image with different scale (if the image doesn't exist in | |
| 153 // resource, for example), it will fallback to closest image rep. | |
| 154 // 2: Invoke GetImageForScale with the closest known scale to the requested | |
| 155 // one and rescale the image. | |
| 156 // Right now only Windows uses 2 and other platforms use 1 by default. | |
| 157 // TODO(mukai, oshima): abandon 1 code path and use 2 for every platforms. | |
| 158 std::vector<ImageSkiaRep>::iterator FindRepresentation( | |
| 159 float scale, bool fetch_new_image) const { | |
| 160 ImageSkiaStorage* non_const = const_cast<ImageSkiaStorage*>(this); | |
| 161 | |
| 162 ImageSkia::ImageSkiaReps::iterator closest_iter = | |
| 163 non_const->image_reps().end(); | |
| 164 ImageSkia::ImageSkiaReps::iterator exact_iter = | |
| 165 non_const->image_reps().end(); | |
| 166 float smallest_diff = std::numeric_limits<float>::max(); | |
| 167 for (ImageSkia::ImageSkiaReps::iterator it = | |
| 168 non_const->image_reps().begin(); | |
| 169 it < image_reps_.end(); ++it) { | |
| 170 if (it->scale() == scale) { | |
| 171 // found exact match | |
| 172 fetch_new_image = false; | |
| 173 if (it->is_null()) | |
| 174 continue; | |
| 175 exact_iter = it; | |
| 176 break; | |
| 177 } | |
| 178 float diff = std::abs(it->scale() - scale); | |
| 179 if (diff < smallest_diff && !it->is_null()) { | |
| 180 closest_iter = it; | |
| 181 smallest_diff = diff; | |
| 182 } | |
| 183 } | |
| 184 | |
| 185 if (fetch_new_image && source_.get()) { | |
| 186 DCHECK(CalledOnValidThread()) << | |
| 187 "An ImageSkia with the source must be accessed by the same thread."; | |
| 188 | |
| 189 ImageSkiaRep image; | |
| 190 float resource_scale = scale; | |
| 191 if (g_supported_scales) { | |
| 192 if (g_supported_scales->back() <= scale) { | |
| 193 resource_scale = g_supported_scales->back(); | |
| 194 } else { | |
| 195 for (size_t i = 0; i < g_supported_scales->size(); ++i) { | |
| 196 if ((*g_supported_scales)[i] + kFallbackToSmallerScaleDiff >= | |
| 197 scale) { | |
| 198 resource_scale = (*g_supported_scales)[i]; | |
| 199 break; | |
| 200 } | |
| 201 } | |
| 202 } | |
| 203 } | |
| 204 if (scale != resource_scale) { | |
| 205 std::vector<ImageSkiaRep>::iterator iter = FindRepresentation( | |
| 206 resource_scale, fetch_new_image); | |
| 207 DCHECK(iter != image_reps_.end()); | |
| 208 image = iter->unscaled() ? (*iter) : ScaleImageSkiaRep(*iter, scale); | |
| 209 } else { | |
| 210 image = source_->GetImageForScale(scale); | |
| 211 // Image may be missing for the specified scale in some cases, such like | |
| 212 // looking up 2x resources but the 2x resource pack is missing. Falls | |
| 213 // back to 1x and re-scale it. | |
| 214 if (image.is_null() && scale != 1.0f) | |
| 215 image = ScaleImageSkiaRep(source_->GetImageForScale(1.0f), 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 scoped_ptr<ImageSkia> ImageSkia::DeepCopy() const { | |
| 321 ImageSkia* copy = new ImageSkia; | |
| 322 if (isNull()) | |
| 323 return scoped_ptr<ImageSkia>(copy); | |
| 324 | |
| 325 CHECK(CanRead()); | |
| 326 | |
| 327 std::vector<gfx::ImageSkiaRep>& reps = storage_->image_reps(); | |
| 328 for (std::vector<gfx::ImageSkiaRep>::iterator iter = reps.begin(); | |
| 329 iter != reps.end(); ++iter) { | |
| 330 copy->AddRepresentation(*iter); | |
| 331 } | |
| 332 // The copy has its own storage. Detach the copy from the current | |
| 333 // thread so that other thread can use this. | |
| 334 if (!copy->isNull()) | |
| 335 copy->storage_->DetachFromThread(); | |
| 336 return scoped_ptr<ImageSkia>(copy); | |
| 337 } | |
| 338 | |
| 339 bool ImageSkia::BackedBySameObjectAs(const gfx::ImageSkia& other) const { | |
| 340 return storage_.get() == other.storage_.get(); | |
| 341 } | |
| 342 | |
| 343 void ImageSkia::AddRepresentation(const ImageSkiaRep& image_rep) { | |
| 344 DCHECK(!image_rep.is_null()); | |
| 345 | |
| 346 // TODO(oshima): This method should be called |SetRepresentation| | |
| 347 // and replace the existing rep if there is already one with the | |
| 348 // same scale so that we can guarantee that a ImageSkia instance contains only | |
| 349 // one image rep per scale. This is not possible now as ImageLoader currently | |
| 350 // stores need this feature, but this needs to be fixed. | |
| 351 if (isNull()) { | |
| 352 Init(image_rep); | |
| 353 } else { | |
| 354 CHECK(CanModify()); | |
| 355 // If someone is adding ImageSkia explicitly, check if we should | |
| 356 // make the image high DPI aware. | |
| 357 storage_->AddRepresentation(image_rep); | |
| 358 } | |
| 359 } | |
| 360 | |
| 361 void ImageSkia::RemoveRepresentation(float scale) { | |
| 362 if (isNull()) | |
| 363 return; | |
| 364 CHECK(CanModify()); | |
| 365 | |
| 366 ImageSkiaReps& image_reps = storage_->image_reps(); | |
| 367 ImageSkiaReps::iterator it = | |
| 368 storage_->FindRepresentation(scale, false); | |
| 369 if (it != image_reps.end() && it->scale() == scale) | |
| 370 image_reps.erase(it); | |
| 371 } | |
| 372 | |
| 373 bool ImageSkia::HasRepresentation(float scale) const { | |
| 374 if (isNull()) | |
| 375 return false; | |
| 376 CHECK(CanRead()); | |
| 377 | |
| 378 ImageSkiaReps::iterator it = storage_->FindRepresentation(scale, false); | |
| 379 return (it != storage_->image_reps().end() && it->scale() == scale); | |
| 380 } | |
| 381 | |
| 382 const ImageSkiaRep& ImageSkia::GetRepresentation(float scale) const { | |
| 383 if (isNull()) | |
| 384 return NullImageRep(); | |
| 385 | |
| 386 CHECK(CanRead()); | |
| 387 | |
| 388 ImageSkiaReps::iterator it = storage_->FindRepresentation(scale, true); | |
| 389 if (it == storage_->image_reps().end()) | |
| 390 return NullImageRep(); | |
| 391 | |
| 392 return *it; | |
| 393 } | |
| 394 | |
| 395 void ImageSkia::SetReadOnly() { | |
| 396 CHECK(storage_.get()); | |
| 397 storage_->SetReadOnly(); | |
| 398 DetachStorageFromThread(); | |
| 399 } | |
| 400 | |
| 401 void ImageSkia::MakeThreadSafe() { | |
| 402 CHECK(storage_.get()); | |
| 403 EnsureRepsForSupportedScales(); | |
| 404 // Delete source as we no longer needs it. | |
| 405 if (storage_.get()) | |
| 406 storage_->DeleteSource(); | |
| 407 storage_->SetReadOnly(); | |
| 408 CHECK(IsThreadSafe()); | |
| 409 } | |
| 410 | |
| 411 bool ImageSkia::IsThreadSafe() const { | |
| 412 return !storage_.get() || (storage_->read_only() && !storage_->has_source()); | |
| 413 } | |
| 414 | |
| 415 int ImageSkia::width() const { | |
| 416 return isNull() ? 0 : storage_->size().width(); | |
| 417 } | |
| 418 | |
| 419 gfx::Size ImageSkia::size() const { | |
| 420 return gfx::Size(width(), height()); | |
| 421 } | |
| 422 | |
| 423 int ImageSkia::height() const { | |
| 424 return isNull() ? 0 : storage_->size().height(); | |
| 425 } | |
| 426 | |
| 427 std::vector<ImageSkiaRep> ImageSkia::image_reps() const { | |
| 428 if (isNull()) | |
| 429 return std::vector<ImageSkiaRep>(); | |
| 430 | |
| 431 CHECK(CanRead()); | |
| 432 | |
| 433 ImageSkiaReps internal_image_reps = storage_->image_reps(); | |
| 434 // Create list of image reps to return, skipping null image reps which were | |
| 435 // added for caching purposes only. | |
| 436 ImageSkiaReps image_reps; | |
| 437 for (ImageSkiaReps::iterator it = internal_image_reps.begin(); | |
| 438 it != internal_image_reps.end(); ++it) { | |
| 439 if (!it->is_null()) | |
| 440 image_reps.push_back(*it); | |
| 441 } | |
| 442 | |
| 443 return image_reps; | |
| 444 } | |
| 445 | |
| 446 void ImageSkia::EnsureRepsForSupportedScales() const { | |
| 447 DCHECK(g_supported_scales != NULL); | |
| 448 // Don't check ReadOnly because the source may generate images | |
| 449 // even for read only ImageSkia. Concurrent access will be protected | |
| 450 // by |DCHECK(CalledOnValidThread())| in FindRepresentation. | |
| 451 if (storage_.get() && storage_->has_source()) { | |
| 452 for (std::vector<float>::const_iterator it = g_supported_scales->begin(); | |
| 453 it != g_supported_scales->end(); ++it) | |
| 454 storage_->FindRepresentation(*it, true); | |
| 455 } | |
| 456 } | |
| 457 | |
| 458 void ImageSkia::Init(const ImageSkiaRep& image_rep) { | |
| 459 // TODO(pkotwicz): The image should be null whenever image rep is null. | |
| 460 if (image_rep.sk_bitmap().empty()) { | |
| 461 storage_ = NULL; | |
| 462 return; | |
| 463 } | |
| 464 storage_ = new internal::ImageSkiaStorage( | |
| 465 NULL, gfx::Size(image_rep.GetWidth(), image_rep.GetHeight())); | |
| 466 storage_->image_reps().push_back(image_rep); | |
| 467 } | |
| 468 | |
| 469 SkBitmap& ImageSkia::GetBitmap() const { | |
| 470 if (isNull()) { | |
| 471 // Callers expect a ImageSkiaRep even if it is |isNull()|. | |
| 472 // TODO(pkotwicz): Fix this. | |
| 473 return NullImageRep().mutable_sk_bitmap(); | |
| 474 } | |
| 475 | |
| 476 // TODO(oshima): This made a few tests flaky on Windows. | |
| 477 // Fix the root cause and re-enable this. crbug.com/145623. | |
| 478 #if !defined(OS_WIN) | |
| 479 CHECK(CanRead()); | |
| 480 #endif | |
| 481 | |
| 482 ImageSkiaReps::iterator it = storage_->FindRepresentation(1.0f, true); | |
| 483 if (it != storage_->image_reps().end()) | |
| 484 return it->mutable_sk_bitmap(); | |
| 485 return NullImageRep().mutable_sk_bitmap(); | |
| 486 } | |
| 487 | |
| 488 bool ImageSkia::CanRead() const { | |
| 489 return !storage_.get() || storage_->CanRead(); | |
| 490 } | |
| 491 | |
| 492 bool ImageSkia::CanModify() const { | |
| 493 return !storage_.get() || storage_->CanModify(); | |
| 494 } | |
| 495 | |
| 496 void ImageSkia::DetachStorageFromThread() { | |
| 497 if (storage_.get()) | |
| 498 storage_->DetachFromThread(); | |
| 499 } | |
| 500 | |
| 501 } // namespace gfx | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 854713003:
More old files deletion. (Closed)
Base URL: https://github.com/domokit/mojo.git@master