| 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 "testing/gtest/include/gtest/gtest.h" | |
| 6 #include "third_party/skia/include/core/SkCanvas.h" | |
| 7 #include "third_party/skia/include/core/SkPaint.h" | |
| 8 #include "ui/gfx/image/image.h" | |
| 9 #include "ui/gfx/image/image_png_rep.h" | |
| 10 #include "ui/gfx/image/image_skia.h" | |
| 11 #include "ui/gfx/image/image_unittest_util.h" | |
| 12 | |
| 13 #if defined(OS_IOS) | |
| 14 #include "base/mac/foundation_util.h" | |
| 15 #include "skia/ext/skia_utils_ios.h" | |
| 16 #elif defined(OS_MACOSX) | |
| 17 #include "base/mac/mac_util.h" | |
| 18 #include "skia/ext/skia_utils_mac.h" | |
| 19 #endif | |
| 20 | |
| 21 namespace { | |
| 22 | |
| 23 #if defined(OS_IOS) || defined(OS_MACOSX) | |
| 24 const bool kUsesSkiaNatively = false; | |
| 25 #else | |
| 26 const bool kUsesSkiaNatively = true; | |
| 27 #endif | |
| 28 | |
| 29 class ImageTest : public testing::Test { | |
| 30 public: | |
| 31 ImageTest() { | |
| 32 std::vector<float> scales; | |
| 33 scales.push_back(1.0f); | |
| 34 #if !defined(OS_IOS) | |
| 35 scales.push_back(2.0f); | |
| 36 #endif | |
| 37 gfx::ImageSkia::SetSupportedScales(scales); | |
| 38 } | |
| 39 }; | |
| 40 | |
| 41 namespace gt = gfx::test; | |
| 42 | |
| 43 TEST_F(ImageTest, EmptyImage) { | |
| 44 // Test the default constructor. | |
| 45 gfx::Image image; | |
| 46 EXPECT_EQ(0U, image.RepresentationCount()); | |
| 47 EXPECT_TRUE(image.IsEmpty()); | |
| 48 EXPECT_EQ(0, image.Width()); | |
| 49 EXPECT_EQ(0, image.Height()); | |
| 50 | |
| 51 // Test the copy constructor. | |
| 52 gfx::Image imageCopy(image); | |
| 53 EXPECT_TRUE(imageCopy.IsEmpty()); | |
| 54 EXPECT_EQ(0, imageCopy.Width()); | |
| 55 EXPECT_EQ(0, imageCopy.Height()); | |
| 56 | |
| 57 // Test calling SwapRepresentations() with an empty image. | |
| 58 gfx::Image image2(gt::CreateImageSkia(25, 25)); | |
| 59 EXPECT_FALSE(image2.IsEmpty()); | |
| 60 EXPECT_EQ(25, image2.Width()); | |
| 61 EXPECT_EQ(25, image2.Height()); | |
| 62 | |
| 63 image.SwapRepresentations(&image2); | |
| 64 EXPECT_FALSE(image.IsEmpty()); | |
| 65 EXPECT_EQ(25, image.Width()); | |
| 66 EXPECT_EQ(25, image.Height()); | |
| 67 EXPECT_TRUE(image2.IsEmpty()); | |
| 68 EXPECT_EQ(0, image2.Width()); | |
| 69 EXPECT_EQ(0, image2.Height()); | |
| 70 } | |
| 71 | |
| 72 // Test constructing a gfx::Image from an empty PlatformImage. | |
| 73 TEST_F(ImageTest, EmptyImageFromEmptyPlatformImage) { | |
| 74 #if defined(OS_IOS) || defined(OS_MACOSX) | |
| 75 gfx::Image image1(NULL); | |
| 76 EXPECT_TRUE(image1.IsEmpty()); | |
| 77 EXPECT_EQ(0, image1.Width()); | |
| 78 EXPECT_EQ(0, image1.Height()); | |
| 79 EXPECT_EQ(0U, image1.RepresentationCount()); | |
| 80 #endif | |
| 81 | |
| 82 // gfx::ImageSkia and gfx::ImagePNGRep are available on all platforms. | |
| 83 gfx::ImageSkia image_skia; | |
| 84 EXPECT_TRUE(image_skia.isNull()); | |
| 85 gfx::Image image2(image_skia); | |
| 86 EXPECT_TRUE(image2.IsEmpty()); | |
| 87 EXPECT_EQ(0, image2.Width()); | |
| 88 EXPECT_EQ(0, image2.Height()); | |
| 89 EXPECT_EQ(0U, image2.RepresentationCount()); | |
| 90 | |
| 91 std::vector<gfx::ImagePNGRep> image_png_reps; | |
| 92 gfx::Image image3(image_png_reps); | |
| 93 EXPECT_TRUE(image3.IsEmpty()); | |
| 94 EXPECT_EQ(0, image3.Width()); | |
| 95 EXPECT_EQ(0, image3.Height()); | |
| 96 EXPECT_EQ(0U, image3.RepresentationCount()); | |
| 97 } | |
| 98 | |
| 99 // The resulting Image should be empty when it is created using obviously | |
| 100 // invalid data. | |
| 101 TEST_F(ImageTest, EmptyImageFromObviouslyInvalidPNGImage) { | |
| 102 std::vector<gfx::ImagePNGRep> image_png_reps1; | |
| 103 image_png_reps1.push_back(gfx::ImagePNGRep(NULL, 1.0f)); | |
| 104 gfx::Image image1(image_png_reps1); | |
| 105 EXPECT_TRUE(image1.IsEmpty()); | |
| 106 EXPECT_EQ(0U, image1.RepresentationCount()); | |
| 107 | |
| 108 std::vector<gfx::ImagePNGRep> image_png_reps2; | |
| 109 image_png_reps2.push_back(gfx::ImagePNGRep( | |
| 110 new base::RefCountedBytes(), 1.0f)); | |
| 111 gfx::Image image2(image_png_reps2); | |
| 112 EXPECT_TRUE(image2.IsEmpty()); | |
| 113 EXPECT_EQ(0U, image2.RepresentationCount()); | |
| 114 } | |
| 115 | |
| 116 // Test the Width, Height and Size of an empty and non-empty image. | |
| 117 TEST_F(ImageTest, ImageSize) { | |
| 118 gfx::Image image; | |
| 119 EXPECT_EQ(0, image.Width()); | |
| 120 EXPECT_EQ(0, image.Height()); | |
| 121 EXPECT_EQ(gfx::Size(0, 0), image.Size()); | |
| 122 | |
| 123 gfx::Image image2(gt::CreateImageSkia(10, 25)); | |
| 124 EXPECT_EQ(10, image2.Width()); | |
| 125 EXPECT_EQ(25, image2.Height()); | |
| 126 EXPECT_EQ(gfx::Size(10, 25), image2.Size()); | |
| 127 } | |
| 128 | |
| 129 TEST_F(ImageTest, SkiaToSkia) { | |
| 130 gfx::Image image(gt::CreateImageSkia(25, 25)); | |
| 131 EXPECT_EQ(25, image.Width()); | |
| 132 EXPECT_EQ(25, image.Height()); | |
| 133 | |
| 134 // Test ToImageSkia(). | |
| 135 const gfx::ImageSkia* image_skia1 = image.ToImageSkia(); | |
| 136 EXPECT_TRUE(image_skia1); | |
| 137 EXPECT_FALSE(image_skia1->isNull()); | |
| 138 EXPECT_EQ(1U, image.RepresentationCount()); | |
| 139 | |
| 140 // Make sure double conversion doesn't happen. | |
| 141 const gfx::ImageSkia* image_skia2 = image.ToImageSkia(); | |
| 142 EXPECT_EQ(1U, image.RepresentationCount()); | |
| 143 | |
| 144 // ToImageSkia() should always return the same gfx::ImageSkia. | |
| 145 EXPECT_EQ(image_skia1, image_skia2); | |
| 146 | |
| 147 // Test ToSkBitmap(). | |
| 148 const SkBitmap* bitmap1 = image.ToSkBitmap(); | |
| 149 const SkBitmap* bitmap2 = image.ToSkBitmap(); | |
| 150 EXPECT_TRUE(bitmap1); | |
| 151 EXPECT_FALSE(bitmap1->isNull()); | |
| 152 EXPECT_EQ(bitmap1, bitmap2); | |
| 153 | |
| 154 EXPECT_EQ(1U, image.RepresentationCount()); | |
| 155 EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepSkia)); | |
| 156 if (!kUsesSkiaNatively) | |
| 157 EXPECT_FALSE(image.HasRepresentation(gt::GetPlatformRepresentationType())); | |
| 158 } | |
| 159 | |
| 160 TEST_F(ImageTest, EmptyImageToPNG) { | |
| 161 gfx::Image image; | |
| 162 scoped_refptr<base::RefCountedMemory> png_bytes = image.As1xPNGBytes(); | |
| 163 EXPECT_TRUE(png_bytes.get()); | |
| 164 EXPECT_FALSE(png_bytes->size()); | |
| 165 } | |
| 166 | |
| 167 // Check that getting the 1x PNG bytes from images which do not have a 1x | |
| 168 // representation returns NULL. | |
| 169 TEST_F(ImageTest, ImageNo1xToPNG) { | |
| 170 // Image with 2x only. | |
| 171 const int kSize2x = 50; | |
| 172 gfx::ImageSkia image_skia; | |
| 173 image_skia.AddRepresentation(gfx::ImageSkiaRep(gt::CreateBitmap( | |
| 174 kSize2x, kSize2x), 2.0f)); | |
| 175 gfx::Image image1(image_skia); | |
| 176 scoped_refptr<base::RefCountedMemory> png_bytes1 = image1.As1xPNGBytes(); | |
| 177 EXPECT_TRUE(png_bytes1.get()); | |
| 178 EXPECT_FALSE(png_bytes1->size()); | |
| 179 | |
| 180 std::vector<gfx::ImagePNGRep> image_png_reps; | |
| 181 image_png_reps.push_back(gfx::ImagePNGRep( | |
| 182 gt::CreatePNGBytes(kSize2x), 2.0f)); | |
| 183 gfx::Image image2(image_png_reps); | |
| 184 EXPECT_FALSE(image2.IsEmpty()); | |
| 185 EXPECT_EQ(0, image2.Width()); | |
| 186 EXPECT_EQ(0, image2.Height()); | |
| 187 scoped_refptr<base::RefCountedMemory> png_bytes2 = image2.As1xPNGBytes(); | |
| 188 EXPECT_TRUE(png_bytes2.get()); | |
| 189 EXPECT_FALSE(png_bytes2->size()); | |
| 190 } | |
| 191 | |
| 192 // Check that for an image initialized with multi resolution PNG data, | |
| 193 // As1xPNGBytes() returns the 1x bytes. | |
| 194 TEST_F(ImageTest, CreateExtractPNGBytes) { | |
| 195 const int kSize1x = 25; | |
| 196 const int kSize2x = 50; | |
| 197 | |
| 198 scoped_refptr<base::RefCountedMemory> bytes1x = gt::CreatePNGBytes(kSize1x); | |
| 199 std::vector<gfx::ImagePNGRep> image_png_reps; | |
| 200 image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, 1.0f)); | |
| 201 image_png_reps.push_back(gfx::ImagePNGRep( | |
| 202 gt::CreatePNGBytes(kSize2x), 2.0f)); | |
| 203 | |
| 204 gfx::Image image(image_png_reps); | |
| 205 EXPECT_FALSE(image.IsEmpty()); | |
| 206 EXPECT_EQ(25, image.Width()); | |
| 207 EXPECT_EQ(25, image.Height()); | |
| 208 | |
| 209 EXPECT_TRUE(std::equal(bytes1x->front(), bytes1x->front() + bytes1x->size(), | |
| 210 image.As1xPNGBytes()->front())); | |
| 211 } | |
| 212 | |
| 213 TEST_F(ImageTest, MultiResolutionImageSkiaToPNG) { | |
| 214 const int kSize1x = 25; | |
| 215 const int kSize2x = 50; | |
| 216 | |
| 217 SkBitmap bitmap_1x = gt::CreateBitmap(kSize1x, kSize1x); | |
| 218 gfx::ImageSkia image_skia; | |
| 219 image_skia.AddRepresentation(gfx::ImageSkiaRep(bitmap_1x, | |
| 220 1.0f)); | |
| 221 image_skia.AddRepresentation(gfx::ImageSkiaRep(gt::CreateBitmap( | |
| 222 kSize2x, kSize2x), 2.0f)); | |
| 223 gfx::Image image(image_skia); | |
| 224 | |
| 225 EXPECT_TRUE(gt::IsEqual(image.As1xPNGBytes(), bitmap_1x)); | |
| 226 EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepPNG)); | |
| 227 } | |
| 228 | |
| 229 TEST_F(ImageTest, MultiResolutionPNGToImageSkia) { | |
| 230 const int kSize1x = 25; | |
| 231 const int kSize2x = 50; | |
| 232 | |
| 233 scoped_refptr<base::RefCountedMemory> bytes1x = gt::CreatePNGBytes(kSize1x); | |
| 234 scoped_refptr<base::RefCountedMemory> bytes2x = gt::CreatePNGBytes(kSize2x); | |
| 235 | |
| 236 std::vector<gfx::ImagePNGRep> image_png_reps; | |
| 237 image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, 1.0f)); | |
| 238 image_png_reps.push_back(gfx::ImagePNGRep(bytes2x, 2.0f)); | |
| 239 gfx::Image image(image_png_reps); | |
| 240 | |
| 241 std::vector<float> scales; | |
| 242 scales.push_back(1.0f); | |
| 243 scales.push_back(2.0f); | |
| 244 gfx::ImageSkia image_skia = image.AsImageSkia(); | |
| 245 EXPECT_TRUE(gt::IsEqual(bytes1x, | |
| 246 image_skia.GetRepresentation(1.0f).sk_bitmap())); | |
| 247 EXPECT_TRUE(gt::IsEqual(bytes2x, | |
| 248 image_skia.GetRepresentation(2.0f).sk_bitmap())); | |
| 249 EXPECT_TRUE(gt::ImageSkiaStructureMatches(image_skia, kSize1x, kSize1x, | |
| 250 scales)); | |
| 251 #if !defined(OS_IOS) | |
| 252 // IOS does not support arbitrary scale factors. | |
| 253 gfx::ImageSkiaRep rep_1_6x = image_skia.GetRepresentation(1.6f); | |
| 254 ASSERT_FALSE(rep_1_6x.is_null()); | |
| 255 ASSERT_EQ(1.6f, rep_1_6x.scale()); | |
| 256 EXPECT_EQ("40x40", rep_1_6x.pixel_size().ToString()); | |
| 257 | |
| 258 gfx::ImageSkiaRep rep_0_8x = image_skia.GetRepresentation(0.8f); | |
| 259 ASSERT_FALSE(rep_0_8x.is_null()); | |
| 260 ASSERT_EQ(0.8f, rep_0_8x.scale()); | |
| 261 EXPECT_EQ("20x20", rep_0_8x.pixel_size().ToString()); | |
| 262 #endif | |
| 263 } | |
| 264 | |
| 265 TEST_F(ImageTest, MultiResolutionPNGToPlatform) { | |
| 266 const int kSize1x = 25; | |
| 267 const int kSize2x = 50; | |
| 268 | |
| 269 scoped_refptr<base::RefCountedMemory> bytes1x = gt::CreatePNGBytes(kSize1x); | |
| 270 scoped_refptr<base::RefCountedMemory> bytes2x = gt::CreatePNGBytes(kSize2x); | |
| 271 std::vector<gfx::ImagePNGRep> image_png_reps; | |
| 272 image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, 1.0f)); | |
| 273 image_png_reps.push_back(gfx::ImagePNGRep(bytes2x, 2.0f)); | |
| 274 | |
| 275 gfx::Image from_png(image_png_reps); | |
| 276 gfx::Image from_platform(gt::CopyPlatformType(from_png)); | |
| 277 #if defined(OS_IOS) | |
| 278 // On iOS the platform type (UIImage) only supports one resolution. | |
| 279 std::vector<float> scales = gfx::ImageSkia::GetSupportedScales(); | |
| 280 EXPECT_EQ(scales.size(), 1U); | |
| 281 if (scales[0] == 1.0f) | |
| 282 EXPECT_TRUE(gt::IsEqual(bytes1x, from_platform.AsBitmap())); | |
| 283 else if (scales[0] == 2.0f) | |
| 284 EXPECT_TRUE(gt::IsEqual(bytes2x, from_platform.AsBitmap())); | |
| 285 else | |
| 286 ADD_FAILURE() << "Unexpected platform scale factor."; | |
| 287 #else | |
| 288 EXPECT_TRUE(gt::IsEqual(bytes1x, from_platform.AsBitmap())); | |
| 289 #endif // defined(OS_IOS) | |
| 290 } | |
| 291 | |
| 292 | |
| 293 TEST_F(ImageTest, PlatformToPNGEncodeAndDecode) { | |
| 294 gfx::Image image(gt::CreatePlatformImage()); | |
| 295 scoped_refptr<base::RefCountedMemory> png_data = image.As1xPNGBytes(); | |
| 296 EXPECT_TRUE(png_data.get()); | |
| 297 EXPECT_TRUE(png_data->size()); | |
| 298 EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepPNG)); | |
| 299 | |
| 300 std::vector<gfx::ImagePNGRep> image_png_reps; | |
| 301 image_png_reps.push_back(gfx::ImagePNGRep(png_data, 1.0f)); | |
| 302 gfx::Image from_png(image_png_reps); | |
| 303 | |
| 304 EXPECT_TRUE(from_png.HasRepresentation(gfx::Image::kImageRepPNG)); | |
| 305 EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(from_png))); | |
| 306 } | |
| 307 | |
| 308 // The platform types use the platform provided encoding/decoding of PNGs. Make | |
| 309 // sure these work with the Skia Encode/Decode. | |
| 310 TEST_F(ImageTest, PNGEncodeFromSkiaDecodeToPlatform) { | |
| 311 // Force the conversion sequence skia to png to platform_type. | |
| 312 gfx::Image from_bitmap = gfx::Image::CreateFrom1xBitmap( | |
| 313 gt::CreateBitmap(25, 25)); | |
| 314 scoped_refptr<base::RefCountedMemory> png_bytes = | |
| 315 from_bitmap.As1xPNGBytes(); | |
| 316 | |
| 317 std::vector<gfx::ImagePNGRep> image_png_reps; | |
| 318 image_png_reps.push_back(gfx::ImagePNGRep(png_bytes, 1.0f)); | |
| 319 gfx::Image from_png(image_png_reps); | |
| 320 | |
| 321 gfx::Image from_platform(gt::CopyPlatformType(from_png)); | |
| 322 | |
| 323 EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(from_platform))); | |
| 324 EXPECT_TRUE(gt::IsEqual(png_bytes, from_platform.AsBitmap())); | |
| 325 } | |
| 326 | |
| 327 TEST_F(ImageTest, PNGEncodeFromPlatformDecodeToSkia) { | |
| 328 // Force the conversion sequence platform_type to png to skia. | |
| 329 gfx::Image from_platform(gt::CreatePlatformImage()); | |
| 330 scoped_refptr<base::RefCountedMemory> png_bytes = | |
| 331 from_platform.As1xPNGBytes(); | |
| 332 std::vector<gfx::ImagePNGRep> image_png_reps; | |
| 333 image_png_reps.push_back(gfx::ImagePNGRep(png_bytes, 1.0f)); | |
| 334 gfx::Image from_png(image_png_reps); | |
| 335 | |
| 336 EXPECT_TRUE(gt::IsEqual(from_platform.AsBitmap(), from_png.AsBitmap())); | |
| 337 } | |
| 338 | |
| 339 TEST_F(ImageTest, PNGDecodeToSkiaFailure) { | |
| 340 scoped_refptr<base::RefCountedBytes> invalid_bytes( | |
| 341 new base::RefCountedBytes()); | |
| 342 invalid_bytes->data().push_back('0'); | |
| 343 std::vector<gfx::ImagePNGRep> image_png_reps; | |
| 344 image_png_reps.push_back(gfx::ImagePNGRep( | |
| 345 invalid_bytes, 1.0f)); | |
| 346 gfx::Image image(image_png_reps); | |
| 347 gt::CheckImageIndicatesPNGDecodeFailure(image); | |
| 348 } | |
| 349 | |
| 350 TEST_F(ImageTest, PNGDecodeToPlatformFailure) { | |
| 351 scoped_refptr<base::RefCountedBytes> invalid_bytes( | |
| 352 new base::RefCountedBytes()); | |
| 353 invalid_bytes->data().push_back('0'); | |
| 354 std::vector<gfx::ImagePNGRep> image_png_reps; | |
| 355 image_png_reps.push_back(gfx::ImagePNGRep( | |
| 356 invalid_bytes, 1.0f)); | |
| 357 gfx::Image from_png(image_png_reps); | |
| 358 gfx::Image from_platform(gt::CopyPlatformType(from_png)); | |
| 359 gt::CheckImageIndicatesPNGDecodeFailure(from_platform); | |
| 360 } | |
| 361 | |
| 362 TEST_F(ImageTest, SkiaToPlatform) { | |
| 363 gfx::Image image(gt::CreateImageSkia(25, 25)); | |
| 364 EXPECT_EQ(25, image.Width()); | |
| 365 EXPECT_EQ(25, image.Height()); | |
| 366 const size_t kRepCount = kUsesSkiaNatively ? 1U : 2U; | |
| 367 | |
| 368 EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepSkia)); | |
| 369 if (!kUsesSkiaNatively) | |
| 370 EXPECT_FALSE(image.HasRepresentation(gt::GetPlatformRepresentationType())); | |
| 371 | |
| 372 EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image))); | |
| 373 EXPECT_EQ(kRepCount, image.RepresentationCount()); | |
| 374 | |
| 375 const SkBitmap* bitmap = image.ToSkBitmap(); | |
| 376 EXPECT_FALSE(bitmap->isNull()); | |
| 377 EXPECT_EQ(kRepCount, image.RepresentationCount()); | |
| 378 | |
| 379 EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepSkia)); | |
| 380 EXPECT_TRUE(image.HasRepresentation(gt::GetPlatformRepresentationType())); | |
| 381 EXPECT_EQ(25, image.Width()); | |
| 382 EXPECT_EQ(25, image.Height()); | |
| 383 } | |
| 384 | |
| 385 TEST_F(ImageTest, PlatformToSkia) { | |
| 386 gfx::Image image(gt::CreatePlatformImage()); | |
| 387 EXPECT_EQ(25, image.Width()); | |
| 388 EXPECT_EQ(25, image.Height()); | |
| 389 const size_t kRepCount = kUsesSkiaNatively ? 1U : 2U; | |
| 390 | |
| 391 EXPECT_TRUE(image.HasRepresentation(gt::GetPlatformRepresentationType())); | |
| 392 if (!kUsesSkiaNatively) | |
| 393 EXPECT_FALSE(image.HasRepresentation(gfx::Image::kImageRepSkia)); | |
| 394 | |
| 395 const SkBitmap* bitmap = image.ToSkBitmap(); | |
| 396 EXPECT_TRUE(bitmap); | |
| 397 EXPECT_FALSE(bitmap->isNull()); | |
| 398 EXPECT_EQ(kRepCount, image.RepresentationCount()); | |
| 399 | |
| 400 EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image))); | |
| 401 EXPECT_EQ(kRepCount, image.RepresentationCount()); | |
| 402 | |
| 403 EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepSkia)); | |
| 404 EXPECT_EQ(25, image.Width()); | |
| 405 EXPECT_EQ(25, image.Height()); | |
| 406 } | |
| 407 | |
| 408 TEST_F(ImageTest, PlatformToPlatform) { | |
| 409 gfx::Image image(gt::CreatePlatformImage()); | |
| 410 EXPECT_EQ(25, image.Width()); | |
| 411 EXPECT_EQ(25, image.Height()); | |
| 412 EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image))); | |
| 413 EXPECT_EQ(1U, image.RepresentationCount()); | |
| 414 | |
| 415 // Make sure double conversion doesn't happen. | |
| 416 EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image))); | |
| 417 EXPECT_EQ(1U, image.RepresentationCount()); | |
| 418 | |
| 419 EXPECT_TRUE(image.HasRepresentation(gt::GetPlatformRepresentationType())); | |
| 420 if (!kUsesSkiaNatively) | |
| 421 EXPECT_FALSE(image.HasRepresentation(gfx::Image::kImageRepSkia)); | |
| 422 EXPECT_EQ(25, image.Width()); | |
| 423 EXPECT_EQ(25, image.Height()); | |
| 424 } | |
| 425 | |
| 426 TEST_F(ImageTest, PlatformToSkiaToCopy) { | |
| 427 const gfx::ImageSkia* image_skia = NULL; | |
| 428 { | |
| 429 gfx::Image image(gt::CreatePlatformImage()); | |
| 430 image_skia = image.CopyImageSkia(); | |
| 431 } | |
| 432 EXPECT_TRUE(image_skia); | |
| 433 EXPECT_FALSE(image_skia->isNull()); | |
| 434 delete image_skia; | |
| 435 | |
| 436 const SkBitmap* bitmap = NULL; | |
| 437 { | |
| 438 gfx::Image image(gt::CreatePlatformImage()); | |
| 439 bitmap = image.CopySkBitmap(); | |
| 440 } | |
| 441 | |
| 442 EXPECT_TRUE(bitmap); | |
| 443 EXPECT_FALSE(bitmap->isNull()); | |
| 444 delete bitmap; | |
| 445 } | |
| 446 | |
| 447 #if defined(OS_IOS) | |
| 448 TEST_F(ImageTest, SkiaToCocoaTouchCopy) { | |
| 449 UIImage* ui_image; | |
| 450 | |
| 451 { | |
| 452 gfx::Image image(gt::CreateImageSkia(25, 25)); | |
| 453 ui_image = image.CopyUIImage(); | |
| 454 } | |
| 455 | |
| 456 EXPECT_TRUE(ui_image); | |
| 457 base::mac::NSObjectRelease(ui_image); | |
| 458 } | |
| 459 #elif defined(OS_MACOSX) | |
| 460 TEST_F(ImageTest, SkiaToCocoaCopy) { | |
| 461 NSImage* ns_image; | |
| 462 | |
| 463 { | |
| 464 gfx::Image image(gt::CreateImageSkia(25, 25)); | |
| 465 ns_image = image.CopyNSImage(); | |
| 466 } | |
| 467 | |
| 468 EXPECT_TRUE(ns_image); | |
| 469 base::mac::NSObjectRelease(ns_image); | |
| 470 } | |
| 471 #endif | |
| 472 | |
| 473 TEST_F(ImageTest, CheckSkiaColor) { | |
| 474 gfx::Image image(gt::CreatePlatformImage()); | |
| 475 | |
| 476 const SkBitmap* bitmap = image.ToSkBitmap(); | |
| 477 SkAutoLockPixels auto_lock(*bitmap); | |
| 478 gt::CheckColors(bitmap->getColor(10, 10), SK_ColorGREEN); | |
| 479 } | |
| 480 | |
| 481 TEST_F(ImageTest, SkBitmapConversionPreservesOrientation) { | |
| 482 const int width = 50; | |
| 483 const int height = 50; | |
| 484 SkBitmap bitmap; | |
| 485 bitmap.allocN32Pixels(width, height); | |
| 486 bitmap.eraseARGB(255, 0, 255, 0); | |
| 487 | |
| 488 // Paint the upper half of the image in red (lower half is in green). | |
| 489 SkCanvas canvas(bitmap); | |
| 490 SkPaint red; | |
| 491 red.setColor(SK_ColorRED); | |
| 492 canvas.drawRect(SkRect::MakeWH(width, height / 2), red); | |
| 493 { | |
| 494 SCOPED_TRACE("Checking color of the initial SkBitmap"); | |
| 495 gt::CheckColors(bitmap.getColor(10, 10), SK_ColorRED); | |
| 496 gt::CheckColors(bitmap.getColor(10, 40), SK_ColorGREEN); | |
| 497 } | |
| 498 | |
| 499 // Convert from SkBitmap to a platform representation, then check the upper | |
| 500 // half of the platform image to make sure it is red, not green. | |
| 501 gfx::Image from_skbitmap = gfx::Image::CreateFrom1xBitmap(bitmap); | |
| 502 { | |
| 503 SCOPED_TRACE("Checking color of the platform image"); | |
| 504 gt::CheckColors( | |
| 505 gt::GetPlatformImageColor(gt::ToPlatformType(from_skbitmap), 10, 10), | |
| 506 SK_ColorRED); | |
| 507 gt::CheckColors( | |
| 508 gt::GetPlatformImageColor(gt::ToPlatformType(from_skbitmap), 10, 40), | |
| 509 SK_ColorGREEN); | |
| 510 } | |
| 511 | |
| 512 // Force a conversion back to SkBitmap and check that the upper half is red. | |
| 513 gfx::Image from_platform(gt::CopyPlatformType(from_skbitmap)); | |
| 514 const SkBitmap* bitmap2 = from_platform.ToSkBitmap(); | |
| 515 SkAutoLockPixels auto_lock(*bitmap2); | |
| 516 { | |
| 517 SCOPED_TRACE("Checking color after conversion back to SkBitmap"); | |
| 518 gt::CheckColors(bitmap2->getColor(10, 10), SK_ColorRED); | |
| 519 gt::CheckColors(bitmap2->getColor(10, 40), SK_ColorGREEN); | |
| 520 } | |
| 521 } | |
| 522 | |
| 523 TEST_F(ImageTest, SkBitmapConversionPreservesTransparency) { | |
| 524 const int width = 50; | |
| 525 const int height = 50; | |
| 526 SkBitmap bitmap; | |
| 527 bitmap.allocN32Pixels(width, height); | |
| 528 bitmap.eraseARGB(0, 0, 255, 0); | |
| 529 | |
| 530 // Paint the upper half of the image in red (lower half is transparent). | |
| 531 SkCanvas canvas(bitmap); | |
| 532 SkPaint red; | |
| 533 red.setColor(SK_ColorRED); | |
| 534 canvas.drawRect(SkRect::MakeWH(width, height / 2), red); | |
| 535 { | |
| 536 SCOPED_TRACE("Checking color of the initial SkBitmap"); | |
| 537 gt::CheckColors(bitmap.getColor(10, 10), SK_ColorRED); | |
| 538 gt::CheckIsTransparent(bitmap.getColor(10, 40)); | |
| 539 } | |
| 540 | |
| 541 // Convert from SkBitmap to a platform representation, then check the upper | |
| 542 // half of the platform image to make sure it is red, not green. | |
| 543 gfx::Image from_skbitmap = gfx::Image::CreateFrom1xBitmap(bitmap); | |
| 544 { | |
| 545 SCOPED_TRACE("Checking color of the platform image"); | |
| 546 gt::CheckColors( | |
| 547 gt::GetPlatformImageColor(gt::ToPlatformType(from_skbitmap), 10, 10), | |
| 548 SK_ColorRED); | |
| 549 gt::CheckIsTransparent( | |
| 550 gt::GetPlatformImageColor(gt::ToPlatformType(from_skbitmap), 10, 40)); | |
| 551 } | |
| 552 | |
| 553 // Force a conversion back to SkBitmap and check that the upper half is red. | |
| 554 gfx::Image from_platform(gt::CopyPlatformType(from_skbitmap)); | |
| 555 const SkBitmap* bitmap2 = from_platform.ToSkBitmap(); | |
| 556 SkAutoLockPixels auto_lock(*bitmap2); | |
| 557 { | |
| 558 SCOPED_TRACE("Checking color after conversion back to SkBitmap"); | |
| 559 gt::CheckColors(bitmap2->getColor(10, 10), SK_ColorRED); | |
| 560 gt::CheckIsTransparent(bitmap.getColor(10, 40)); | |
| 561 } | |
| 562 } | |
| 563 | |
| 564 TEST_F(ImageTest, SwapRepresentations) { | |
| 565 const size_t kRepCount = kUsesSkiaNatively ? 1U : 2U; | |
| 566 | |
| 567 gfx::Image image1(gt::CreateImageSkia(25, 25)); | |
| 568 const gfx::ImageSkia* image_skia1 = image1.ToImageSkia(); | |
| 569 EXPECT_EQ(1U, image1.RepresentationCount()); | |
| 570 | |
| 571 gfx::Image image2(gt::CreatePlatformImage()); | |
| 572 const gfx::ImageSkia* image_skia2 = image2.ToImageSkia(); | |
| 573 gt::PlatformImage platform_image = gt::ToPlatformType(image2); | |
| 574 EXPECT_EQ(kRepCount, image2.RepresentationCount()); | |
| 575 | |
| 576 image1.SwapRepresentations(&image2); | |
| 577 | |
| 578 EXPECT_EQ(image_skia2, image1.ToImageSkia()); | |
| 579 EXPECT_TRUE(gt::PlatformImagesEqual(platform_image, | |
| 580 gt::ToPlatformType(image1))); | |
| 581 EXPECT_EQ(image_skia1, image2.ToImageSkia()); | |
| 582 EXPECT_EQ(kRepCount, image1.RepresentationCount()); | |
| 583 EXPECT_EQ(1U, image2.RepresentationCount()); | |
| 584 } | |
| 585 | |
| 586 TEST_F(ImageTest, Copy) { | |
| 587 const size_t kRepCount = kUsesSkiaNatively ? 1U : 2U; | |
| 588 | |
| 589 gfx::Image image1(gt::CreateImageSkia(25, 25)); | |
| 590 EXPECT_EQ(25, image1.Width()); | |
| 591 EXPECT_EQ(25, image1.Height()); | |
| 592 gfx::Image image2(image1); | |
| 593 EXPECT_EQ(25, image2.Width()); | |
| 594 EXPECT_EQ(25, image2.Height()); | |
| 595 | |
| 596 EXPECT_EQ(1U, image1.RepresentationCount()); | |
| 597 EXPECT_EQ(1U, image2.RepresentationCount()); | |
| 598 EXPECT_EQ(image1.ToImageSkia(), image2.ToImageSkia()); | |
| 599 | |
| 600 EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image2))); | |
| 601 EXPECT_EQ(kRepCount, image2.RepresentationCount()); | |
| 602 EXPECT_EQ(kRepCount, image1.RepresentationCount()); | |
| 603 } | |
| 604 | |
| 605 TEST_F(ImageTest, Assign) { | |
| 606 gfx::Image image1(gt::CreatePlatformImage()); | |
| 607 EXPECT_EQ(25, image1.Width()); | |
| 608 EXPECT_EQ(25, image1.Height()); | |
| 609 // Assignment must be on a separate line to the declaration in order to test | |
| 610 // assignment operator (instead of copy constructor). | |
| 611 gfx::Image image2; | |
| 612 image2 = image1; | |
| 613 EXPECT_EQ(25, image2.Width()); | |
| 614 EXPECT_EQ(25, image2.Height()); | |
| 615 | |
| 616 EXPECT_EQ(1U, image1.RepresentationCount()); | |
| 617 EXPECT_EQ(1U, image2.RepresentationCount()); | |
| 618 EXPECT_EQ(image1.ToSkBitmap(), image2.ToSkBitmap()); | |
| 619 } | |
| 620 | |
| 621 TEST_F(ImageTest, MultiResolutionImageSkia) { | |
| 622 const int kWidth1x = 10; | |
| 623 const int kHeight1x = 12; | |
| 624 const int kWidth2x = 20; | |
| 625 const int kHeight2x = 24; | |
| 626 | |
| 627 gfx::ImageSkia image_skia; | |
| 628 image_skia.AddRepresentation(gfx::ImageSkiaRep( | |
| 629 gt::CreateBitmap(kWidth1x, kHeight1x), | |
| 630 1.0f)); | |
| 631 image_skia.AddRepresentation(gfx::ImageSkiaRep( | |
| 632 gt::CreateBitmap(kWidth2x, kHeight2x), | |
| 633 2.0f)); | |
| 634 | |
| 635 std::vector<float> scales; | |
| 636 scales.push_back(1.0f); | |
| 637 scales.push_back(2.0f); | |
| 638 EXPECT_TRUE(gt::ImageSkiaStructureMatches(image_skia, kWidth1x, kHeight1x, | |
| 639 scales)); | |
| 640 | |
| 641 // Check that the image has a single representation. | |
| 642 gfx::Image image(image_skia); | |
| 643 EXPECT_EQ(1u, image.RepresentationCount()); | |
| 644 EXPECT_EQ(kWidth1x, image.Width()); | |
| 645 EXPECT_EQ(kHeight1x, image.Height()); | |
| 646 } | |
| 647 | |
| 648 TEST_F(ImageTest, RemoveFromMultiResolutionImageSkia) { | |
| 649 const int kWidth2x = 20; | |
| 650 const int kHeight2x = 24; | |
| 651 | |
| 652 gfx::ImageSkia image_skia; | |
| 653 | |
| 654 image_skia.AddRepresentation(gfx::ImageSkiaRep( | |
| 655 gt::CreateBitmap(kWidth2x, kHeight2x), 2.0f)); | |
| 656 EXPECT_EQ(1u, image_skia.image_reps().size()); | |
| 657 | |
| 658 image_skia.RemoveRepresentation(1.0f); | |
| 659 EXPECT_EQ(1u, image_skia.image_reps().size()); | |
| 660 | |
| 661 image_skia.RemoveRepresentation(2.0f); | |
| 662 EXPECT_EQ(0u, image_skia.image_reps().size()); | |
| 663 } | |
| 664 | |
| 665 // Tests that gfx::Image does indeed take ownership of the SkBitmap it is | |
| 666 // passed. | |
| 667 TEST_F(ImageTest, OwnershipTest) { | |
| 668 gfx::Image image; | |
| 669 { | |
| 670 SkBitmap bitmap(gt::CreateBitmap(10, 10)); | |
| 671 EXPECT_TRUE(!bitmap.isNull()); | |
| 672 image = gfx::Image(gfx::ImageSkia( | |
| 673 gfx::ImageSkiaRep(bitmap, 1.0f))); | |
| 674 } | |
| 675 EXPECT_TRUE(!image.ToSkBitmap()->isNull()); | |
| 676 } | |
| 677 | |
| 678 // Integration tests with UI toolkit frameworks require linking against the | |
| 679 // Views library and cannot be here (ui_unittests doesn't include it). They | |
| 680 // instead live in /chrome/browser/ui/tests/ui_gfx_image_unittest.cc. | |
| 681 | |
| 682 } // namespace | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 854713003:
More old files deletion. (Closed)
Base URL: https://github.com/domokit/mojo.git@master