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
NullImageRep()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:
Matcher(float scale)47 explicit Matcher(float scale) : scale_(scale) {
48 }
49
operator ()(const ImageSkiaRep & rep) const50 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:
ImageSkiaStorage(ImageSkiaSource * source,const gfx::Size & size)69 ImageSkiaStorage(ImageSkiaSource* source, const gfx::Size& size)
70 : source_(source),
71 size_(size),
72 read_only_(false) {
73 }
74
ImageSkiaStorage(ImageSkiaSource * source,float scale)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
has_source() const85 bool has_source() const { return source_.get() != NULL; }
86
image_reps()87 std::vector<gfx::ImageSkiaRep>& image_reps() { return image_reps_; }
88
size() const89 const gfx::Size& size() const { return size_; }
90
read_only() const91 bool read_only() const { return read_only_; }
92
DeleteSource()93 void DeleteSource() {
94 source_.reset();
95 }
96
SetReadOnly()97 void SetReadOnly() {
98 read_only_ = true;
99 }
100
DetachFromThread()101 void DetachFromThread() {
102 base::NonThreadSafe::DetachFromThread();
103 }
104
105 // Checks if the current thread can safely modify the storage.
CanModify() const106 bool CanModify() const {
107 return !read_only_ && CalledOnValidThread();
108 }
109
110 // Checks if the current thread can safely read the storage.
CanRead() const111 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.
AddRepresentation(const ImageSkiaRep & image)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.
FindRepresentation(float scale,bool fetch_new_image) const145 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:
~ImageSkiaStorage()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
ImageSkia()260 ImageSkia::ImageSkia() : storage_(NULL) {
261 }
262
ImageSkia(ImageSkiaSource * source,const gfx::Size & size)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
ImageSkia(ImageSkiaSource * source,float scale)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
ImageSkia(const ImageSkiaRep & image_rep)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
ImageSkia(const ImageSkia & other)285 ImageSkia::ImageSkia(const ImageSkia& other) : storage_(other.storage_) {
286 }
287
operator =(const ImageSkia & other)288 ImageSkia& ImageSkia::operator=(const ImageSkia& other) {
289 storage_ = other.storage_;
290 return *this;
291 }
292
~ImageSkia()293 ImageSkia::~ImageSkia() {
294 }
295
296 // static
SetSupportedScales(const std::vector<float> & supported_scales)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
GetSupportedScales()305 const std::vector<float>& ImageSkia::GetSupportedScales() {
306 DCHECK(g_supported_scales != NULL);
307 return *g_supported_scales;
308 }
309
310 // static
GetMaxSupportedScale()311 float ImageSkia::GetMaxSupportedScale() {
312 return g_supported_scales->back();
313 }
314
315 // static
CreateFrom1xBitmap(const SkBitmap & bitmap)316 ImageSkia ImageSkia::CreateFrom1xBitmap(const SkBitmap& bitmap) {
317 return ImageSkia(ImageSkiaRep(bitmap, 0.0f));
318 }
319
IsDSFScalingInImageSkiaEnabled()320 bool ImageSkia::IsDSFScalingInImageSkiaEnabled() {
321 base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
322 return !command_line->HasSwitch(
323 switches::kDisableArbitraryScaleFactorInImageSkia);
324 }
325
DeepCopy() const326 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
BackedBySameObjectAs(const gfx::ImageSkia & other) const345 bool ImageSkia::BackedBySameObjectAs(const gfx::ImageSkia& other) const {
346 return storage_.get() == other.storage_.get();
347 }
348
AddRepresentation(const ImageSkiaRep & image_rep)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
RemoveRepresentation(float scale)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
HasRepresentation(float scale) const379 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
GetRepresentation(float scale) const388 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
SetReadOnly()401 void ImageSkia::SetReadOnly() {
402 CHECK(storage_.get());
403 storage_->SetReadOnly();
404 DetachStorageFromThread();
405 }
406
MakeThreadSafe()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
IsThreadSafe() const417 bool ImageSkia::IsThreadSafe() const {
418 return !storage_.get() || (storage_->read_only() && !storage_->has_source());
419 }
420
width() const421 int ImageSkia::width() const {
422 return isNull() ? 0 : storage_->size().width();
423 }
424
size() const425 gfx::Size ImageSkia::size() const {
426 return gfx::Size(width(), height());
427 }
428
height() const429 int ImageSkia::height() const {
430 return isNull() ? 0 : storage_->size().height();
431 }
432
image_reps() const433 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
EnsureRepsForSupportedScales() const452 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
Init(const ImageSkiaRep & image_rep)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
GetBitmap() const475 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
CanRead() const494 bool ImageSkia::CanRead() const {
495 return !storage_.get() || storage_->CanRead();
496 }
497
CanModify() const498 bool ImageSkia::CanModify() const {
499 return !storage_.get() || storage_->CanModify();
500 }
501
DetachStorageFromThread()502 void ImageSkia::DetachStorageFromThread() {
503 if (storage_.get())
504 storage_->DetachFromThread();
505 }
506
507 } // namespace gfx
508