ui/gfx/image/image_skia_unittest.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 "base/logging.h"
   8 #include "base/threading/simple_thread.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "third_party/skia/include/core/SkBitmap.h"
  11 #include "ui/base/layout.h"
  12 #include "ui/gfx/image/image_skia_rep.h"
  13 #include "ui/gfx/image/image_skia_source.h"
  14 #include "ui/gfx/size.h"
  15
  16 // Duplicated from base/threading/non_thread_safe.h so that we can be
  17 // good citizens there and undef the macro.
  18 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))
  19 #define ENABLE_NON_THREAD_SAFE 1
  20 #else
  21 #define ENABLE_NON_THREAD_SAFE 0
  22 #endif
  23
  24 namespace gfx {
  25
  26 namespace {
  27
  28 class FixedSource : public ImageSkiaSource {
  29  public:
  30   FixedSource(const ImageSkiaRep& image) : image_(image) {}
  31
  32   virtual ~FixedSource() {
  33   }
  34
  35   virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
  36     return image_;
  37   }
  38
  39  private:
  40   ImageSkiaRep image_;
  41
  42   DISALLOW_COPY_AND_ASSIGN(FixedSource);
  43 };
  44
  45 class DynamicSource : public ImageSkiaSource {
  46  public:
  47   DynamicSource(const gfx::Size& size) : size_(size) {}
  48
  49   virtual ~DynamicSource() {
  50   }
  51
  52   virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
  53     return gfx::ImageSkiaRep(size_, scale_factor);
  54   }
  55
  56  private:
  57   gfx::Size size_;
  58
  59   DISALLOW_COPY_AND_ASSIGN(DynamicSource);
  60 };
  61
  62 class NullSource: public ImageSkiaSource {
  63  public:
  64   NullSource() {
  65   }
  66
  67   virtual ~NullSource() {
  68   }
  69
  70   virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
  71     return gfx::ImageSkiaRep();
  72   }
  73
  74  private:
  75   DISALLOW_COPY_AND_ASSIGN(NullSource);
  76 };
  77
  78 }  // namespace
  79
  80 namespace test {
  81 class TestOnThread : public base::SimpleThread {
  82  public:
  83   explicit TestOnThread(ImageSkia* image_skia)
  84       : SimpleThread("image_skia_on_thread"),
  85         image_skia_(image_skia),
  86         can_read_(false),
  87         can_modify_(false) {
  88   }
  89
  90   virtual void Run() OVERRIDE {
  91     can_read_ = image_skia_->CanRead();
  92     can_modify_ = image_skia_->CanModify();
  93     if (can_read_)
  94       image_skia_->image_reps();
  95   }
  96
  97   void StartAndJoin() {
  98     Start();
  99     Join();
 100   }
 101
 102   bool can_read() const { return can_read_; }
 103
 104   bool can_modify() const { return can_modify_; }
 105
 106  private:
 107   ImageSkia* image_skia_;
 108
 109   bool can_read_;
 110   bool can_modify_;
 111
 112   DISALLOW_COPY_AND_ASSIGN(TestOnThread);
 113 };
 114
 115 }  // namespace test
 116
 117 TEST(ImageSkiaTest, FixedSource) {
 118   ImageSkiaRep image(Size(100, 200), ui::SCALE_FACTOR_100P);
 119   ImageSkia image_skia(new FixedSource(image), Size(100, 200));
 120   EXPECT_EQ(0U, image_skia.image_reps().size());
 121
 122   const ImageSkiaRep& result_100p =
 123       image_skia.GetRepresentation(ui::SCALE_FACTOR_100P);
 124   EXPECT_EQ(100, result_100p.GetWidth());
 125   EXPECT_EQ(200, result_100p.GetHeight());
 126   EXPECT_EQ(ui::SCALE_FACTOR_100P, result_100p.scale_factor());
 127   EXPECT_EQ(1U, image_skia.image_reps().size());
 128
 129   const ImageSkiaRep& result_200p =
 130       image_skia.GetRepresentation(ui::SCALE_FACTOR_200P);
 131
 132   EXPECT_EQ(100, result_200p.GetWidth());
 133   EXPECT_EQ(200, result_200p.GetHeight());
 134   EXPECT_EQ(100, result_200p.pixel_width());
 135   EXPECT_EQ(200, result_200p.pixel_height());
 136   EXPECT_EQ(ui::SCALE_FACTOR_100P, result_200p.scale_factor());
 137   EXPECT_EQ(1U, image_skia.image_reps().size());
 138
 139   // Get the representation again and make sure it doesn't
 140   // generate new image skia rep.
 141   image_skia.GetRepresentation(ui::SCALE_FACTOR_100P);
 142   image_skia.GetRepresentation(ui::SCALE_FACTOR_200P);
 143   EXPECT_EQ(1U, image_skia.image_reps().size());
 144 }
 145
 146 TEST(ImageSkiaTest, DynamicSource) {
 147   ImageSkia image_skia(new DynamicSource(Size(100, 200)), Size(100, 200));
 148   EXPECT_EQ(0U, image_skia.image_reps().size());
 149   const ImageSkiaRep& result_100p =
 150       image_skia.GetRepresentation(ui::SCALE_FACTOR_100P);
 151   EXPECT_EQ(100, result_100p.GetWidth());
 152   EXPECT_EQ(200, result_100p.GetHeight());
 153   EXPECT_EQ(ui::SCALE_FACTOR_100P, result_100p.scale_factor());
 154   EXPECT_EQ(1U, image_skia.image_reps().size());
 155
 156   const ImageSkiaRep& result_200p =
 157       image_skia.GetRepresentation(ui::SCALE_FACTOR_200P);
 158   EXPECT_EQ(100, result_200p.GetWidth());
 159   EXPECT_EQ(200, result_200p.GetHeight());
 160   EXPECT_EQ(200, result_200p.pixel_width());
 161   EXPECT_EQ(400, result_200p.pixel_height());
 162   EXPECT_EQ(ui::SCALE_FACTOR_200P, result_200p.scale_factor());
 163   EXPECT_EQ(2U, image_skia.image_reps().size());
 164
 165   // Get the representation again and make sure it doesn't
 166   // generate new image skia rep.
 167   image_skia.GetRepresentation(ui::SCALE_FACTOR_100P);
 168   EXPECT_EQ(2U, image_skia.image_reps().size());
 169   image_skia.GetRepresentation(ui::SCALE_FACTOR_200P);
 170   EXPECT_EQ(2U, image_skia.image_reps().size());
 171 }
 172
 173 // Tests that image_reps returns all of the representations in the
 174 // image when there are multiple representations for a scale factor.
 175 // This currently is the case with ImageLoader::LoadImages.
 176 TEST(ImageSkiaTest, ManyRepsPerScaleFactor) {
 177   const int kSmallIcon1x = 16;
 178   const int kSmallIcon2x = 32;
 179   const int kLargeIcon1x = 32;
 180
 181   ImageSkia image(new NullSource(), gfx::Size(kSmallIcon1x, kSmallIcon1x));
 182   // Simulate a source which loads images on a delay. Upon
 183   // GetImageForScaleFactor, it immediately returns null and starts loading
 184   // image reps slowly.
 185   image.GetRepresentation(ui::SCALE_FACTOR_100P);
 186   image.GetRepresentation(ui::SCALE_FACTOR_200P);
 187
 188   // After a lengthy amount of simulated time, finally loaded image reps.
 189   image.AddRepresentation(ImageSkiaRep(
 190       gfx::Size(kSmallIcon1x, kSmallIcon1x), ui::SCALE_FACTOR_100P));
 191   image.AddRepresentation(ImageSkiaRep(
 192       gfx::Size(kSmallIcon2x, kSmallIcon2x), ui::SCALE_FACTOR_200P));
 193   image.AddRepresentation(ImageSkiaRep(
 194       gfx::Size(kLargeIcon1x, kLargeIcon1x), ui::SCALE_FACTOR_100P));
 195
 196   std::vector<ImageSkiaRep> image_reps = image.image_reps();
 197   EXPECT_EQ(3u, image_reps.size());
 198
 199   int num_1x = 0;
 200   int num_2x = 0;
 201   for (size_t i = 0; i < image_reps.size(); ++i) {
 202     if (image_reps[i].scale_factor() == ui::SCALE_FACTOR_100P)
 203       num_1x++;
 204     else if (image_reps[i].scale_factor() == ui::SCALE_FACTOR_200P)
 205       num_2x++;
 206   }
 207   EXPECT_EQ(2, num_1x);
 208   EXPECT_EQ(1, num_2x);
 209 }
 210
 211 TEST(ImageSkiaTest, GetBitmap) {
 212   ImageSkia image_skia(new DynamicSource(Size(100, 200)), Size(100, 200));
 213   const SkBitmap* bitmap = image_skia.bitmap();
 214   EXPECT_NE(static_cast<SkBitmap*>(NULL), bitmap);
 215   EXPECT_FALSE(bitmap->isNull());
 216 }
 217
 218 TEST(ImageSkiaTest, GetBitmapFromEmpty) {
 219   // Create an image with 1 representation and remove it so the ImageSkiaStorage
 220   // is left with no representations.
 221   ImageSkia empty_image(ImageSkiaRep(Size(100, 200), ui::SCALE_FACTOR_100P));
 222   ImageSkia empty_image_copy(empty_image);
 223   empty_image.RemoveRepresentation(ui::SCALE_FACTOR_100P);
 224
 225   // Check that ImageSkia::bitmap() still returns a valid SkBitmap pointer for
 226   // the image and all its copies.
 227   const SkBitmap* bitmap = empty_image_copy.bitmap();
 228   ASSERT_NE(static_cast<SkBitmap*>(NULL), bitmap);
 229   EXPECT_TRUE(bitmap->isNull());
 230   EXPECT_TRUE(bitmap->empty());
 231 }
 232
 233 TEST(ImageSkiaTest, BackedBySameObjectAs) {
 234   // Null images should all be backed by the same object (NULL).
 235   ImageSkia image;
 236   ImageSkia unrelated;
 237   EXPECT_TRUE(image.BackedBySameObjectAs(unrelated));
 238
 239   image.AddRepresentation(gfx::ImageSkiaRep(gfx::Size(10, 10),
 240                                             ui::SCALE_FACTOR_100P));
 241   ImageSkia copy = image;
 242   copy.AddRepresentation(gfx::ImageSkiaRep(gfx::Size(10, 10),
 243                                            ui::SCALE_FACTOR_200P));
 244   unrelated.AddRepresentation(gfx::ImageSkiaRep(gfx::Size(10, 10),
 245                                                 ui::SCALE_FACTOR_100P));
 246   EXPECT_TRUE(image.BackedBySameObjectAs(copy));
 247   EXPECT_FALSE(image.BackedBySameObjectAs(unrelated));
 248   EXPECT_FALSE(copy.BackedBySameObjectAs(unrelated));
 249 }
 250
 251 #if ENABLE_NON_THREAD_SAFE
 252 TEST(ImageSkiaTest, EmptyOnThreadTest) {
 253   ImageSkia empty;
 254   test::TestOnThread empty_on_thread(&empty);
 255   empty_on_thread.Start();
 256   empty_on_thread.Join();
 257   EXPECT_TRUE(empty_on_thread.can_read());
 258   EXPECT_TRUE(empty_on_thread.can_modify());
 259 }
 260
 261 TEST(ImageSkiaTest, StaticOnThreadTest) {
 262   ImageSkia image(ImageSkiaRep(Size(100, 200), ui::SCALE_FACTOR_100P));
 263   EXPECT_FALSE(image.IsThreadSafe());
 264
 265   test::TestOnThread image_on_thread(&image);
 266   // an image that was never accessed on this thread can be
 267   // read by other thread.
 268   image_on_thread.StartAndJoin();
 269   EXPECT_TRUE(image_on_thread.can_read());
 270   EXPECT_TRUE(image_on_thread.can_modify());
 271   EXPECT_FALSE(image.CanRead());
 272   EXPECT_FALSE(image.CanModify());
 273
 274   image.DetachStorageFromThread();
 275   // An image is accessed by this thread,
 276   // so other thread cannot read/modify it.
 277   image.image_reps();
 278   test::TestOnThread image_on_thread2(&image);
 279   image_on_thread2.StartAndJoin();
 280   EXPECT_FALSE(image_on_thread2.can_read());
 281   EXPECT_FALSE(image_on_thread2.can_modify());
 282   EXPECT_TRUE(image.CanRead());
 283   EXPECT_TRUE(image.CanModify());
 284
 285   image.DetachStorageFromThread();
 286   scoped_ptr<ImageSkia> deep_copy(image.DeepCopy());
 287   EXPECT_FALSE(deep_copy->IsThreadSafe());
 288   test::TestOnThread deepcopy_on_thread(deep_copy.get());
 289   deepcopy_on_thread.StartAndJoin();
 290   EXPECT_TRUE(deepcopy_on_thread.can_read());
 291   EXPECT_TRUE(deepcopy_on_thread.can_modify());
 292   EXPECT_FALSE(deep_copy->CanRead());
 293   EXPECT_FALSE(deep_copy->CanModify());
 294
 295   scoped_ptr<ImageSkia> deep_copy2(image.DeepCopy());
 296   EXPECT_EQ(1U, deep_copy2->image_reps().size());
 297   // Access it from current thread so that it can't be
 298   // accessed from another thread.
 299   deep_copy2->image_reps();
 300   EXPECT_FALSE(deep_copy2->IsThreadSafe());
 301   test::TestOnThread deepcopy2_on_thread(deep_copy2.get());
 302   deepcopy2_on_thread.StartAndJoin();
 303   EXPECT_FALSE(deepcopy2_on_thread.can_read());
 304   EXPECT_FALSE(deepcopy2_on_thread.can_modify());
 305   EXPECT_TRUE(deep_copy2->CanRead());
 306   EXPECT_TRUE(deep_copy2->CanModify());
 307
 308   image.DetachStorageFromThread();
 309   image.SetReadOnly();
 310   // A read-only ImageSkia with no source is thread safe.
 311   EXPECT_TRUE(image.IsThreadSafe());
 312   test::TestOnThread readonly_on_thread(&image);
 313   readonly_on_thread.StartAndJoin();
 314   EXPECT_TRUE(readonly_on_thread.can_read());
 315   EXPECT_FALSE(readonly_on_thread.can_modify());
 316   EXPECT_TRUE(image.CanRead());
 317   EXPECT_FALSE(image.CanModify());
 318
 319   image.DetachStorageFromThread();
 320   image.MakeThreadSafe();
 321   EXPECT_TRUE(image.IsThreadSafe());
 322   test::TestOnThread threadsafe_on_thread(&image);
 323   threadsafe_on_thread.StartAndJoin();
 324   EXPECT_TRUE(threadsafe_on_thread.can_read());
 325   EXPECT_FALSE(threadsafe_on_thread.can_modify());
 326   EXPECT_TRUE(image.CanRead());
 327   EXPECT_FALSE(image.CanModify());
 328 }
 329
 330 TEST(ImageSkiaTest, SourceOnThreadTest) {
 331   ImageSkia image(new DynamicSource(Size(100, 200)), Size(100, 200));
 332   EXPECT_FALSE(image.IsThreadSafe());
 333
 334   test::TestOnThread image_on_thread(&image);
 335   image_on_thread.StartAndJoin();
 336   // an image that was never accessed on this thread can be
 337   // read by other thread.
 338   EXPECT_TRUE(image_on_thread.can_read());
 339   EXPECT_TRUE(image_on_thread.can_modify());
 340   EXPECT_FALSE(image.CanRead());
 341   EXPECT_FALSE(image.CanModify());
 342
 343   image.DetachStorageFromThread();
 344   // An image is accessed by this thread,
 345   // so other thread cannot read/modify it.
 346   image.image_reps();
 347   test::TestOnThread image_on_thread2(&image);
 348   image_on_thread2.StartAndJoin();
 349   EXPECT_FALSE(image_on_thread2.can_read());
 350   EXPECT_FALSE(image_on_thread2.can_modify());
 351   EXPECT_TRUE(image.CanRead());
 352   EXPECT_TRUE(image.CanModify());
 353
 354   image.DetachStorageFromThread();
 355   image.SetReadOnly();
 356   EXPECT_FALSE(image.IsThreadSafe());
 357   test::TestOnThread readonly_on_thread(&image);
 358   readonly_on_thread.StartAndJoin();
 359   EXPECT_TRUE(readonly_on_thread.can_read());
 360   EXPECT_FALSE(readonly_on_thread.can_modify());
 361   EXPECT_FALSE(image.CanRead());
 362   EXPECT_FALSE(image.CanModify());
 363
 364   image.DetachStorageFromThread();
 365   image.MakeThreadSafe();
 366   EXPECT_TRUE(image.IsThreadSafe());
 367   // Check if image reps are generated for supported scale factors.
 368   EXPECT_EQ(ui::GetSupportedScaleFactors().size(),
 369             image.image_reps().size());
 370   test::TestOnThread threadsafe_on_thread(&image);
 371   threadsafe_on_thread.StartAndJoin();
 372   EXPECT_TRUE(threadsafe_on_thread.can_read());
 373   EXPECT_FALSE(threadsafe_on_thread.can_modify());
 374   EXPECT_TRUE(image.CanRead());
 375   EXPECT_FALSE(image.CanModify());
 376 }
 377 #endif  // ENABLE_NON_THREAD_SAFE
 378
 379 // Just in case we ever get lumped together with other compilation units.
 380 #undef ENABLE_NON_THREAD_SAFE
 381
 382 }  // namespace gfx