Implement ui::ImageModel::operator==/!=

This helps clients to decide when to rasterize ui::ImageModel.
For instance, if a new ImageModel is same with the old one,
they can skip rasterization.

Bug: 1048901
Change-Id: I72ba2bdc71d9cde576f99fe5cbf3db994a8b6837
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2303747Reviewed-by: Scott Violet <sky@chromium.org>
Commit-Queue: Sang Woo Ko <sangwoo108@chromium.org>
Cr-Commit-Position: refs/heads/master@{#790642}

ui/base/models/image_model.cc

@@ -28,6 +28,15 @@ VectorIconModel::VectorIconModel(VectorIconModel&&) = default;
 
 VectorIconModel& VectorIconModel::operator=(VectorIconModel&&) = default;
 
+bool VectorIconModel::operator==(const VectorIconModel& other) const {
+  return vector_icon_ == other.vector_icon_ && icon_size_ == other.icon_size_ &&
+         color_ == other.color_ && color_id_ == other.color_id_;
+}
+
+bool VectorIconModel::operator!=(const VectorIconModel& other) const {
+  return !(*this == other);
+}
+
 ImageModel::ImageModel() = default;
 
 ImageModel::ImageModel(const VectorIconModel& vector_icon_model)
@@ -102,4 +111,27 @@ const gfx::Image ImageModel::GetImage() const {
   return image_.value();
 }
 
-}  // namespace ui
+bool ImageModel::operator==(const ImageModel& other) const {
\ No newline at end of file
+  if (IsEmpty() != other.IsEmpty())
+    return false;
+
+  if (IsEmpty())
+    return true;
+
+  if (IsVectorIcon() != other.IsVectorIcon())
+    return false;
+
+  if (IsImage()) {
+    return GetImage().AsImageSkia().BackedBySameObjectAs(
+        other.GetImage().AsImageSkia());
+  }
+
+  DCHECK(IsVectorIcon());
+  return GetVectorIcon() == other.GetVectorIcon();
+}
+
+bool ImageModel::operator!=(const ImageModel& other) const {
+  return !(*this == other);
+}
+
+}  // namespace ui

ui/base/models/image_model.h

@@ -39,6 +39,9 @@ class COMPONENT_EXPORT(UI_BASE) VectorIconModel {
 
   bool is_empty() const { return !vector_icon_; }
 
+  bool operator==(const VectorIconModel& other) const;
+  bool operator!=(const VectorIconModel& other) const;
+
  private:
   friend class ThemedVectorIcon;
   friend class ImageModel;
@@ -97,6 +100,10 @@ class COMPONENT_EXPORT(UI_BASE) ImageModel {
   const VectorIconModel GetVectorIcon() const;
   const gfx::Image GetImage() const;
 
+  // Checks if both model yield equal images.
+  bool operator==(const ImageModel& other) const;
+  bool operator!=(const ImageModel& other) const;
+
  private:
   ImageModel(const gfx::Image& image);
   ImageModel(const gfx::ImageSkia& image_skia);

ui/base/models/image_model_unittest.cc

@@ -16,7 +16,7 @@ namespace ui {
 
 namespace {
 
-const gfx::VectorIcon& GetVectorIcon() {
+const gfx::VectorIcon& GetCircleVectorIcon() {
   static constexpr gfx::PathElement path[] = {gfx::CommandType::CIRCLE, 24, 18,
                                               5};
   static const gfx::VectorIconRep rep[] = {{path, 4}};
@@ -25,6 +25,16 @@ const gfx::VectorIcon& GetVectorIcon() {
   return circle_icon;
 }
 
+const gfx::VectorIcon& GetRectVectorIcon() {
+  static constexpr gfx::PathElement path[] = {
+      gfx::CommandType::LINE_TO, 0,  10, gfx::CommandType::LINE_TO, 10, 10,
+      gfx::CommandType::LINE_TO, 10, 0,  gfx::CommandType::CLOSE};
+  static const gfx::VectorIconRep rep[] = {{path, 10}};
+  static constexpr gfx::VectorIcon rect_icon = {rep, 1, "rect"};
+
+  return rect_icon;
+}
+
 }  // namespace
 
 TEST(ImageModelTest, DefaultEmpty) {
@@ -40,7 +50,7 @@ TEST(ImageModelTest, DefaultVectorIconEmpty) {
 }
 
 TEST(ImageModelTest, CheckForVectorIcon) {
-  ImageModel image_model = ImageModel::FromVectorIcon(GetVectorIcon());
+  ImageModel image_model = ImageModel::FromVectorIcon(GetCircleVectorIcon());
 
   EXPECT_FALSE(image_model.IsEmpty());
   EXPECT_TRUE(image_model.IsVectorIcon());
@@ -57,7 +67,7 @@ TEST(ImageModelTest, CheckForImage) {
 TEST(ImageModelTest, Size) {
   EXPECT_EQ(gfx::Size(), ImageModel().Size());
   EXPECT_EQ(gfx::Size(16, 16),
-            ImageModel::FromVectorIcon(GetVectorIcon(), -1, 16).Size());
+            ImageModel::FromVectorIcon(GetCircleVectorIcon(), -1, 16).Size());
   EXPECT_EQ(gfx::Size(16, 16),
             ImageModel::FromImage(gfx::test::CreateImage(16, 16)).Size());
 }
@@ -65,7 +75,7 @@ TEST(ImageModelTest, Size) {
 TEST(ImageModelTest, CheckAssignVectorIcon) {
   VectorIconModel vector_icon_model_dest;
   VectorIconModel vector_icon_model_src =
-      ImageModel::FromVectorIcon(GetVectorIcon()).GetVectorIcon();
+      ImageModel::FromVectorIcon(GetCircleVectorIcon()).GetVectorIcon();
 
   EXPECT_TRUE(vector_icon_model_dest.is_empty());
   EXPECT_FALSE(vector_icon_model_src.is_empty());
@@ -90,7 +100,7 @@ TEST(ImageModelTest, CheckAssignImage) {
   EXPECT_TRUE(image_model_dest.IsImage());
   EXPECT_FALSE(image_model_dest.IsVectorIcon());
 
-  image_model_src = ImageModel::FromVectorIcon(GetVectorIcon());
+  image_model_src = ImageModel::FromVectorIcon(GetCircleVectorIcon());
 
   EXPECT_TRUE(image_model_src.IsVectorIcon());
 
@@ -100,4 +110,50 @@ TEST(ImageModelTest, CheckAssignImage) {
   EXPECT_FALSE(image_model_dest.IsImage());
 }
 
+TEST(ImageModelTest, CheckEqual) {
+  ImageModel image_model_src;
+  ImageModel image_model_dest;
+  EXPECT_EQ(image_model_src, image_model_dest);
+
+  auto first_image = gfx::test::CreateImage(16, 16);
+  image_model_src = ImageModel::FromImage(first_image);
+  EXPECT_NE(image_model_src, image_model_dest);
+  image_model_dest = ImageModel::FromImage(first_image);
+  EXPECT_EQ(image_model_src, image_model_dest);
+  image_model_dest = ImageModel::FromImage(gfx::test::CreateImage(16, 16));
+  EXPECT_NE(image_model_src, image_model_dest);
+  image_model_src = image_model_dest;
+  EXPECT_EQ(image_model_src, image_model_dest);
+
+  image_model_dest = ImageModel::FromVectorIcon(GetRectVectorIcon());
+  EXPECT_NE(image_model_src, image_model_dest);
+  image_model_src = ImageModel::FromVectorIcon(GetRectVectorIcon());
+  EXPECT_EQ(image_model_src, image_model_dest);
+  image_model_dest = ImageModel::FromVectorIcon(GetCircleVectorIcon());
+  EXPECT_NE(image_model_src, image_model_dest);
+  image_model_src = image_model_dest;
+  EXPECT_EQ(image_model_src, image_model_dest);
+
+  image_model_src = ImageModel::FromVectorIcon(GetCircleVectorIcon(), 1);
+  image_model_dest =
+      ImageModel::FromVectorIcon(GetCircleVectorIcon(), SK_ColorMAGENTA);
+  EXPECT_NE(image_model_src, image_model_dest);
+
+  image_model_src = ImageModel::FromVectorIcon(GetCircleVectorIcon(), 1);
+  image_model_dest = ImageModel::FromVectorIcon(GetCircleVectorIcon(), 2);
+  EXPECT_NE(image_model_src, image_model_dest);
+
+  image_model_src =
+      ImageModel::FromVectorIcon(GetCircleVectorIcon(), SK_ColorCYAN);
+  image_model_dest =
+      ImageModel::FromVectorIcon(GetCircleVectorIcon(), SK_ColorMAGENTA);
+  EXPECT_NE(image_model_src, image_model_dest);
+
+  image_model_src =
+      ImageModel::FromVectorIcon(GetCircleVectorIcon(), SK_ColorMAGENTA, 1);
+  image_model_dest =
+      ImageModel::FromVectorIcon(GetCircleVectorIcon(), SK_ColorMAGENTA, 2);
+  EXPECT_NE(image_model_src, image_model_dest);
+}
+
 }  // namespace ui