Fix OnPropertyChanged calls and convert more properties in Label

Add enum for |full_text_| properties and convert ElideBehavior,
Shadows, and HorizontalAlignment.

Change-Id: I6d5263f380010906844b6a46c3003ece8126bfde
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1715727Reviewed-by: Allen Bauer <kylixrd@chromium.org>
Commit-Queue: Kristyn Hamasaki <khamasaki@google.com>
Cr-Commit-Position: refs/heads/master@{#682382}

ui/views/controls/label.cc

@@ -36,6 +36,17 @@
 
 namespace {
 
+// An enum giving different RenderText properties unique keys for the
+// OnPropertyChanged call.
+enum LabelPropertyKey {
+  kLabelText = 1,
+  kLabelShadows,
+  kLabelHorizontalAlignment,
+  kLabelLineHeight,
+  kLabelObscured,
+  kLabelAllowCharacterBreak,
+};
+
 bool IsOpaque(SkColor color) {
   return SkColorGetA(color) == SK_AlphaOPAQUE;
 }
@@ -88,7 +99,7 @@ void Label::SetText(const base::string16& new_text) {
   if (new_text == GetText())
     return;
   full_text_->SetText(new_text);
-  OnPropertyChanged(&new_text, kPropertyEffectsLayout);
+  OnPropertyChanged(&full_text_ + kLabelText, kPropertyEffectsLayout);
   stored_selection_range_ = gfx::Range::InvalidRange();
 }
 
@@ -156,7 +167,7 @@ void Label::SetSelectionBackgroundColor(SkColor color) {
   OnPropertyChanged(&selection_background_color_, kPropertyEffectsPaint);
 }
 
-const gfx::ShadowValues& Label::shadows() const {
+const gfx::ShadowValues& Label::GetShadows() const {
   return full_text_->shadows();
 }
 
@@ -164,7 +175,7 @@ void Label::SetShadows(const gfx::ShadowValues& shadows) {
   if (full_text_->shadows() == shadows)
     return;
   full_text_->set_shadows(shadows);
-  ResetLayout();
+  OnPropertyChanged(&full_text_ + kLabelShadows, kPropertyEffectsLayout);
 }
 
 bool Label::GetSubpixelRenderingEnabled() const {
@@ -187,7 +198,8 @@ void Label::SetHorizontalAlignment(gfx::HorizontalAlignment alignment) {
   if (GetHorizontalAlignment() == alignment)
     return;
   full_text_->SetHorizontalAlignment(alignment);
-  ResetLayout();
+  OnPropertyChanged(&full_text_ + kLabelHorizontalAlignment,
+                    kPropertyEffectsLayout);
 }
 
 int Label::GetLineHeight() const {
@@ -198,7 +210,7 @@ void Label::SetLineHeight(int height) {
   if (GetLineHeight() == height)
     return;
   full_text_->SetMinLineHeight(height);
-  OnPropertyChanged(&height, kPropertyEffectsLayout);
+  OnPropertyChanged(&full_text_ + kLabelLineHeight, kPropertyEffectsLayout);
 }
 
 bool Label::GetMultiLine() const {
@@ -237,7 +249,7 @@ void Label::SetObscured(bool obscured) {
   full_text_->SetObscured(obscured);
   if (obscured)
     SetSelectable(false);
-  OnPropertyChanged(&obscured, kPropertyEffectsLayout);
+  OnPropertyChanged(&full_text_ + kLabelObscured, kPropertyEffectsLayout);
 }
 
 bool Label::GetAllowCharacterBreak() const {
@@ -251,7 +263,8 @@ void Label::SetAllowCharacterBreak(bool allow_character_break) {
   if (full_text_->word_wrap_behavior() == behavior)
     return;
   full_text_->SetWordWrapBehavior(behavior);
-  OnPropertyChanged(&allow_character_break, kPropertyEffectsLayout);
+  OnPropertyChanged(&full_text_ + kLabelAllowCharacterBreak,
+                    kPropertyEffectsLayout);
 }
 
 gfx::ElideBehavior Label::GetElideBehavior() const {
@@ -264,7 +277,7 @@ void Label::SetElideBehavior(gfx::ElideBehavior elide_behavior) {
   if (elide_behavior_ == elide_behavior)
     return;
   elide_behavior_ = elide_behavior;
-  ResetLayout();
+  OnPropertyChanged(&elide_behavior_, kPropertyEffectsLayout);
 }
 
 base::string16 Label::GetTooltipText() const {
@@ -537,7 +550,7 @@ std::unique_ptr<gfx::RenderText> Label::CreateRenderText() const {
   render_text->SetObscured(GetObscured());
   render_text->SetMinLineHeight(GetLineHeight());
   render_text->SetFontList(font_list());
-  render_text->set_shadows(shadows());
+  render_text->set_shadows(GetShadows());
   render_text->SetCursorEnabled(false);
   render_text->SetText(GetText());
   render_text->SetMultiline(GetMultiLine());
@@ -951,7 +964,7 @@ void Label::MaybeBuildDisplayText() const {
   if (rect.IsEmpty())
     return;
 
-  rect.Inset(-gfx::ShadowValue::GetMargin(shadows()));
+  rect.Inset(-gfx::ShadowValue::GetMargin(GetShadows()));
   display_text_ = CreateRenderText();
   display_text_->SetDisplayRect(rect);
   stored_selection_range_ = gfx::Range::InvalidRange();
@@ -972,7 +985,7 @@ gfx::Size Label::GetTextSize() const {
     full_text_->SetDisplayRect(gfx::Rect(0, 0, width(), 0));
     size = full_text_->GetStringSize();
   }
-  const gfx::Insets shadow_margin = -gfx::ShadowValue::GetMargin(shadows());
+  const gfx::Insets shadow_margin = -gfx::ShadowValue::GetMargin(GetShadows());
   size.Enlarge(shadow_margin.width(), shadow_margin.height());
   return size;
 }
@@ -1079,10 +1092,13 @@ METADATA_PARENT_CLASS(View)
 ADD_PROPERTY_METADATA(Label, bool, AutoColorReadabilityEnabled)
 ADD_PROPERTY_METADATA(Label, base::string16, Text)
 ADD_PROPERTY_METADATA(Label, SkColor, EnabledColor)
+ADD_PROPERTY_METADATA(Label, gfx::ElideBehavior, ElideBehavior)
 ADD_PROPERTY_METADATA(Label, SkColor, BackgroundColor)
 ADD_PROPERTY_METADATA(Label, SkColor, SelectionTextColor)
 ADD_PROPERTY_METADATA(Label, SkColor, SelectionBackgroundColor)
 ADD_PROPERTY_METADATA(Label, bool, SubpixelRenderingEnabled)
+ADD_PROPERTY_METADATA(Label, gfx::ShadowValues, Shadows)
+ADD_PROPERTY_METADATA(Label, gfx::HorizontalAlignment, HorizontalAlignment)
 ADD_PROPERTY_METADATA(Label, int, LineHeight)
 ADD_PROPERTY_METADATA(Label, bool, MultiLine)
 ADD_PROPERTY_METADATA(Label, int, MaxLines)

ui/views/controls/label.h

@@ -114,7 +114,7 @@ class VIEWS_EXPORT Label : public View,
   void SetSelectionBackgroundColor(SkColor color);
 
   // Get/Set drop shadows underneath the text.
-  const gfx::ShadowValues& shadows() const;
+  const gfx::ShadowValues& GetShadows() const;
   void SetShadows(const gfx::ShadowValues& shadows);
 
   // Gets/Sets whether subpixel rendering is used; the default is true, but this

ui/views/metadata/type_conversion.cc

@@ -7,6 +7,7 @@
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ -59,6 +60,18 @@ base::string16 TypeConverter<const char*>::ToString(const char* source_value) {
   return base::UTF8ToUTF16(source_value);
 }
 
+base::string16 TypeConverter<gfx::ShadowValues>::ToString(
+    const gfx::ShadowValues& source_value) {
+  base::string16 ret = base::ASCIIToUTF16("[");
+  for (auto shadow_value : source_value) {
+    ret += base::ASCIIToUTF16(" " + shadow_value.ToString() + ";");
+  }
+
+  ret[ret.length() - 1] = ' ';
+  ret += base::ASCIIToUTF16("]");
+  return ret;
+}
+
 base::Optional<int8_t> TypeConverter<int8_t>::FromString(
     const base::string16& source_value) {
   int32_t ret = 0;
@@ -169,6 +182,34 @@ base::Optional<base::string16> TypeConverter<base::string16>::FromString(
   return source_value;
 }
 
+base::Optional<gfx::ShadowValues> TypeConverter<gfx::ShadowValues>::FromString(
+    const base::string16& source_value) {
+  gfx::ShadowValues ret;
+  const auto shadow_value_strings =
+      base::SplitStringPiece(source_value, base::ASCIIToUTF16("[;]"),
+                             base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+
+  for (auto v : shadow_value_strings) {
+    base::string16 member_string;
+    base::RemoveChars(v.as_string(), base::ASCIIToUTF16("()rgba"),
+                      &member_string);
+    const auto members = base::SplitStringPiece(
+        member_string, base::ASCIIToUTF16(","), base::TRIM_WHITESPACE,
+        base::SPLIT_WANT_NONEMPTY);
+    int x, y, r, g, b, a;
+    double blur;
+
+    if ((members.size() == 7) && base::StringToInt(members[0], &x) &&
+        base::StringToInt(members[1], &y) &&
+        base::StringToDouble(UTF16ToASCII(members[2]), &blur) &&
+        base::StringToInt(members[3], &r) &&
+        base::StringToInt(members[4], &g) &&
+        base::StringToInt(members[5], &b) && base::StringToInt(members[6], &a))
+      ret.emplace_back(gfx::Vector2d(x, y), blur, SkColorSetARGB(a, r, g, b));
+  }
+  return ret;
+}
+
 }  // namespace metadata
 }  // namespace views
 
@@ -182,6 +223,16 @@ DEFINE_ENUM_CONVERTERS(gfx::HorizontalAlignment,
                        {gfx::HorizontalAlignment::ALIGN_TO_HEAD,
                         base::ASCIIToUTF16("ALIGN_TO_HEAD")})
 
+DEFINE_ENUM_CONVERTERS(
+    gfx::ElideBehavior,
+    {gfx::ElideBehavior::NO_ELIDE, base::ASCIIToUTF16("NO_ELIDE")},
+    {gfx::ElideBehavior::TRUNCATE, base::ASCIIToUTF16("TRUNCATE")},
+    {gfx::ElideBehavior::ELIDE_HEAD, base::ASCIIToUTF16("ELIDE_HEAD")},
+    {gfx::ElideBehavior::ELIDE_MIDDLE, base::ASCIIToUTF16("ELIDE_MIDDLE")},
+    {gfx::ElideBehavior::ELIDE_TAIL, base::ASCIIToUTF16("ELIDE_TAIL")},
+    {gfx::ElideBehavior::ELIDE_EMAIL, base::ASCIIToUTF16("ELIDE_EMAIL")},
+    {gfx::ElideBehavior::FADE_TAIL, base::ASCIIToUTF16("FADE_TAIL")})
+
 DEFINE_ENUM_CONVERTERS(ui::TextInputType,
                        {ui::TextInputType::TEXT_INPUT_TYPE_NONE,
                         base::ASCIIToUTF16("TEXT_INPUT_TYPE_NONE")},

ui/views/metadata/type_conversion.h

@@ -16,6 +16,7 @@
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/gfx/geometry/size.h"
+#include "ui/gfx/shadow_value.h"
 #include "ui/gfx/text_constants.h"
 #include "ui/views/views_export.h"
 
@@ -114,6 +115,7 @@ DECLARE_CONVERSIONS(bool)
 DECLARE_CONVERSIONS(gfx::Size)
 DECLARE_CONVERSIONS(base::string16)
 DECLARE_CONVERSIONS(const char*)
+DECLARE_CONVERSIONS(gfx::ShadowValues)
 
 #undef DECLARE_CONVERSIONS
 

ui/views/metadata/type_conversion_unittest.cc

@@ -62,3 +62,42 @@ TEST_F(TypeConversionTest, TestConversion_StringToOptionalInt) {
                 base::ASCIIToUTF16("ab0")),
             base::nullopt);
 }
+
+TEST_F(TypeConversionTest, TestConversion_ShadowValuesToString) {
+  gfx::ShadowValues shadow_values;
+  shadow_values.emplace_back(gfx::Vector2d(1, 2), .3,
+                             SkColorSetARGB(128, 255, 0, 0));
+
+  EXPECT_EQ(MD::TypeConverter<gfx::ShadowValues>::ToString(shadow_values),
+            base::ASCIIToUTF16("[ (1,2),0.30,rgba(255,0,0,128) ]"));
+
+  shadow_values.emplace_back(gfx::Vector2d(9, 8), .76,
+                             SkColorSetARGB(20, 0, 64, 255));
+
+  EXPECT_EQ(
+      MD::TypeConverter<gfx::ShadowValues>::ToString(shadow_values),
+      base::ASCIIToUTF16(
+          "[ (1,2),0.30,rgba(255,0,0,128); (9,8),0.76,rgba(0,64,255,20) ]"));
+}
+
+TEST_F(TypeConversionTest, TestConversion_StringToShadowValues) {
+  base::Optional<gfx::ShadowValues> opt_result =
+      MD::TypeConverter<gfx::ShadowValues>::FromString(base::ASCIIToUTF16(
+          "[ (6,4),0.53,rgba(23,44,0,255); (93,83),4.33,rgba(10,20,0,15) ]"));
+
+  EXPECT_EQ(opt_result.has_value(), true);
+  gfx::ShadowValues result = opt_result.value();
+  EXPECT_EQ(result.size(), 2U);
+
+  EXPECT_EQ(result[0].color(), SkColorSetARGB(255, 23, 44, 0));
+  EXPECT_EQ(result[1].color(), SkColorSetARGB(15, 10, 20, 0));
+
+  EXPECT_EQ(result[0].x(), 6);
+  EXPECT_EQ(result[1].x(), 93);
+
+  EXPECT_EQ(result[0].y(), 4);
+  EXPECT_EQ(result[1].y(), 83);
+
+  EXPECT_EQ(result[0].blur(), 0.53);
+  EXPECT_EQ(result[1].blur(), 4.33);
+}