ash: HiDPI user avatar for SessionController

ui/gfx/image/mojo/image_traits_unittest.cc

+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <vector>
+
+#include "base/macros.h"
+#include "base/message_loop/message_loop.h"
+#include "mojo/public/cpp/bindings/binding_set.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/image/image_skia_operations.h"
+#include "ui/gfx/image/image_skia_source.h"
+#include "ui/gfx/image/mojo/image_traits_test_service.mojom.h"
+#include "ui/gfx/skia_util.h"
+
+namespace gfx {
+
+namespace {
+
+// Returns true if |reps| matches the representations in |image| except for
+// the null/empty ones.
+bool ContainsSameRepresentation(const std::vector<ImageSkiaRep>& reps,
+                                const ImageSkia& image) {
+  std::vector<ImageSkiaRep> check_reps = image.image_reps();
+
+  // Strip null/empty representations.
+  auto check_it = check_reps.begin();
+  while (check_it != check_reps.end()) {
+    if (check_it->sk_bitmap().drawsNothing())
+      check_it = check_reps.erase(check_it);
+    else
+      ++check_it;
+  }
+
+  if (reps.size() != check_reps.size())
+    return false;
+
+  auto it = reps.begin();
+  check_it = check_reps.begin();
+  while (it != reps.end() && check_it != check_reps.end()) {
+    if (!gfx::BitmapsAreEqual(it->sk_bitmap(), check_it->sk_bitmap()))
+      return false;
+
+    ++it;
+    ++check_it;
+  }
+
+  return it == reps.end() && check_it == check_reps.end();
+}
+
+// A test ImageSkiaSource that creates an ImageSkiaRep for any scale.
+class TestImageSkiaSource : public ImageSkiaSource {
+ public:
+  explicit TestImageSkiaSource(const gfx::Size& dip_size)
+      : dip_size_(dip_size) {}
+  ~TestImageSkiaSource() override = default;
+
+  // ImageSkiaSource:
+  ImageSkiaRep GetImageForScale(float scale) override {
+    return ImageSkiaRep(ScaleToCeiledSize(dip_size_, scale), scale);
+  }
+
+ private:
+  const gfx::Size dip_size_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestImageSkiaSource);
+};
+
+class ImageTraitsTest : public testing::Test,
+                        public mojom::ImageTraitsTestService {
+ public:
+  ImageTraitsTest() = default;
+
+  // testing::Test:
+  void SetUp() override {
+    service_ = bindings_.CreateInterfacePtrAndBind(this);
+  }
+
+  mojom::ImageTraitsTestServicePtr& service() { return service_; }
+
+ private:
+  // mojom::ImageTraitsTestService:
+  void EchoImageSkiaRep(const ImageSkiaRep& in,
+                        const EchoImageSkiaRepCallback& callback) override {
+    callback.Run(in);
+  }
+  void EchoImageSkia(const ImageSkia& in,
+                     const EchoImageSkiaCallback& callback) override {
+    callback.Run(in);
+  }
+
+  base::MessageLoop loop_;
+  mojo::BindingSet<ImageTraitsTestService> bindings_;
+  mojom::ImageTraitsTestServicePtr service_;
+
+  DISALLOW_COPY_AND_ASSIGN(ImageTraitsTest);
+};
+
+}  // namespace
+
+TEST_F(ImageTraitsTest, NullImageSkiaRep) {
+  ImageSkiaRep null_rep;
+  ASSERT_TRUE(null_rep.is_null());
+
+  ImageSkiaRep output(gfx::Size(1, 1), 1.0f);
+  ASSERT_FALSE(output.is_null());
+  service()->EchoImageSkiaRep(null_rep, &output);
+  EXPECT_TRUE(output.is_null());
+}
+
+TEST_F(ImageTraitsTest, EmptyImageSkiaRepIsNull) {
+  SkBitmap empty_bitmap;
+  empty_bitmap.allocN32Pixels(0, 0);
+  // Empty SkBitmap is not null.
+  EXPECT_FALSE(empty_bitmap.isNull());
+
+  ImageSkiaRep empty_rep(empty_bitmap, 1.0f);
+  // ImageSkiaRep with empty bitmap is not null.
+  ASSERT_FALSE(empty_rep.is_null());
+
+  ImageSkiaRep output(gfx::Size(1, 1), 1.0f);
+  ASSERT_FALSE(output.is_null());
+  service()->EchoImageSkiaRep(empty_rep, &output);
+  EXPECT_TRUE(output.is_null());
+}
+
+TEST_F(ImageTraitsTest, ImageSkiaRep) {
+  ImageSkiaRep image_rep(gfx::Size(2, 4), 2.0f);
+
+  ImageSkiaRep output;
+  service()->EchoImageSkiaRep(image_rep, &output);
+
+  EXPECT_FALSE(output.is_null());
+  EXPECT_EQ(image_rep.scale(), output.scale());
+  EXPECT_EQ(image_rep.pixel_size(), output.pixel_size());
+  EXPECT_EQ(image_rep.GetWidth(), output.GetWidth());
+  EXPECT_EQ(image_rep.GetHeight(), output.GetHeight());
+  EXPECT_TRUE(gfx::BitmapsAreEqual(image_rep.sk_bitmap(), output.sk_bitmap()));
+}
+
+TEST_F(ImageTraitsTest, UnscaledImageSkiaRep) {
+  ImageSkiaRep image_rep(gfx::Size(2, 4), 0.0f);
+  ASSERT_TRUE(image_rep.unscaled());
+
+  ImageSkiaRep output(gfx::Size(1, 1), 1.0f);
+  EXPECT_FALSE(output.unscaled());
+  service()->EchoImageSkiaRep(image_rep, &output);
+  EXPECT_TRUE(output.unscaled());
+  EXPECT_EQ(image_rep.pixel_size(), output.pixel_size());
+  EXPECT_TRUE(gfx::BitmapsAreEqual(image_rep.sk_bitmap(), output.sk_bitmap()));
+}
+
+TEST_F(ImageTraitsTest, NullImageSkia) {
+  ImageSkia null_image;
+  ASSERT_TRUE(null_image.isNull());
+
+  ImageSkia output(ImageSkiaRep(gfx::Size(1, 1), 1.0f));
+  ASSERT_FALSE(output.isNull());
+  service()->EchoImageSkia(null_image, &output);
+  EXPECT_TRUE(output.isNull());
+}
+
+TEST_F(ImageTraitsTest, ImageSkiaWithNoRepsTreatedAsNull) {
+  const gfx::Size kSize(1, 2);
+  ImageSkia image(new TestImageSkiaSource(kSize), kSize);
+  ASSERT_FALSE(image.isNull());
+
+  ImageSkia output(ImageSkiaRep(gfx::Size(1, 1), 1.0f));
+  ASSERT_FALSE(output.isNull());
+  service()->EchoImageSkia(image, &output);
+  EXPECT_TRUE(output.isNull());
+}
+
+TEST_F(ImageTraitsTest, ImageSkia) {
+  const gfx::Size kSize(1, 2);
+  ImageSkia image(new TestImageSkiaSource(kSize), kSize);
+  image.GetRepresentation(1.0f);
+  image.GetRepresentation(2.0f);
+
+  ImageSkia output;
+  service()->EchoImageSkia(image, &output);
+
+  EXPECT_FALSE(output.isNull());
+  const std::vector<ImageSkiaRep> output_reps = output.image_reps();
+  EXPECT_EQ(2u, output_reps.size());
+  EXPECT_TRUE(ContainsSameRepresentation(output_reps, image));
+}
+
+TEST_F(ImageTraitsTest, EmptyRepStripped) {
+  const gfx::Size kSize(1, 2);
+  ImageSkia image(new TestImageSkiaSource(kSize), kSize);
+  image.GetRepresentation(1.0f);
+
+  SkBitmap empty_bitmap;
+  empty_bitmap.allocN32Pixels(0, 0);
+  image.AddRepresentation(ImageSkiaRep(empty_bitmap, 2.0f));
+
+  ImageSkia output;
+  service()->EchoImageSkia(image, &output);
+
+  EXPECT_FALSE(output.isNull());
+  const std::vector<ImageSkiaRep> output_reps = output.image_reps();
+  EXPECT_EQ(1u, output_reps.size());
+  EXPECT_TRUE(ContainsSameRepresentation(output_reps, image));
+}
+
+TEST_F(ImageTraitsTest, ImageSkiaWithOperations) {
+  const gfx::Size kSize(32, 32);
+  ImageSkia image(new TestImageSkiaSource(kSize), kSize);
+
+  const gfx::Size kNewSize(16, 16);
+  ImageSkia resized = ImageSkiaOperations::CreateResizedImage(
+      image, skia::ImageOperations::RESIZE_BEST, kNewSize);
+  resized.GetRepresentation(1.0f);
+  resized.GetRepresentation(2.0f);
+
+  ImageSkia output;
+  service()->EchoImageSkia(resized, &output);
+
+  EXPECT_FALSE(output.isNull());
+  EXPECT_EQ(kNewSize, output.size());
+  const std::vector<ImageSkiaRep> output_reps = output.image_reps();
+  EXPECT_EQ(2u, output_reps.size());
+  EXPECT_TRUE(ContainsSameRepresentation(output_reps, resized));
+}
+
+}  // namespace gfx