Views: Support enum type conversions and convert more properties

Add a semi-universal way to handle enum type conversions in MetaData.
In this CL, two enum properties from ImageViewBase were converted to
demo the usage.

BUG=938501,957272

Change-Id: I7e9df7fc7ec10bfff1303f1b0f537cab4d5068d4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1600858
Commit-Queue: Wei Li <weili@chromium.org>
Commit-Queue: Peter Kasting <pkasting@chromium.org>
Reviewed-by: Peter Kasting <pkasting@chromium.org>
Cr-Commit-Position: refs/heads/master@{#658780}

ui/views/controls/image_view_base.cc

@@ -9,6 +9,7 @@
 #include "base/logging.h"
 #include "ui/accessibility/ax_node_data.h"
 #include "ui/gfx/geometry/insets.h"
+#include "ui/views/metadata/metadata_impl_macros.h"
 
 namespace views {
 
@@ -39,7 +40,7 @@ void ImageViewBase::SetHorizontalAlignment(Alignment alignment) {
   if (alignment != horizontal_alignment_) {
     horizontal_alignment_ = alignment;
     UpdateImageOrigin();
-    SchedulePaint();
+    OnPropertyChanged(&horizontal_alignment_, kPropertyEffectsPaint);
   }
 }
 
@@ -51,7 +52,7 @@ void ImageViewBase::SetVerticalAlignment(Alignment alignment) {
   if (alignment != vertical_alignment_) {
     vertical_alignment_ = alignment;
     UpdateImageOrigin();
-    SchedulePaint();
+    OnPropertyChanged(&horizontal_alignment_, kPropertyEffectsPaint);
   }
 }
 
@@ -142,4 +143,16 @@ void ImageViewBase::PreferredSizeChanged() {
   UpdateImageOrigin();
 }
 
+DEFINE_ENUM_CONVERTERS(
+    ImageViewBase::Alignment,
+    {ImageViewBase::Alignment::kLeading, base::ASCIIToUTF16("kLeading")},
+    {ImageViewBase::Alignment::kCenter, base::ASCIIToUTF16("kCenter")},
+    {ImageViewBase::Alignment::kTrailing, base::ASCIIToUTF16("kTrailing")})
+
+BEGIN_METADATA(ImageViewBase)
+METADATA_PARENT_CLASS(View)
+ADD_PROPERTY_METADATA(ImageViewBase, Alignment, HorizontalAlignment)
+ADD_PROPERTY_METADATA(ImageViewBase, Alignment, VerticalAlignment)
+END_METADATA()
+
 }  // namespace views

ui/views/controls/image_view_base.h

@@ -17,6 +17,8 @@ namespace views {
 
 class VIEWS_EXPORT ImageViewBase : public View {
  public:
+  METADATA_HEADER(ImageViewBase);
+
   enum class Alignment { kLeading, kCenter, kTrailing };
 
   ImageViewBase();

ui/views/metadata/type_conversion.h

@@ -6,7 +6,9 @@
 #define UI_VIEWS_METADATA_TYPE_CONVERSION_H_
 
 #include <stdint.h>
+#include <vector>
 
+#include "base/no_destructor.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ -28,6 +30,55 @@ using ArgType = typename std::conditional<std::is_fundamental<T>::value ||
                                           T,
                                           const T&>::type;
 
+// Types and macros for generating enum converters ----------------------------
+template <typename T>
+struct EnumStrings {
+  struct EnumString {
+    T enum_value;
+    base::string16 str_value;
+  };
+
+  EnumStrings(std::vector<EnumString> init_val) : pairs(std::move(init_val)) {}
+
+  const std::vector<EnumString> pairs;
+};
+
+template <typename T>
+static const EnumStrings<T>& GetEnumStringsInstance();
+
+// Generate the code to define a enum type to and from base::string16
+// conversions. The first argument is the type T, and the rest of the argument
+// should have the enum value and string pairs defined in a format like
+// "{enum_value0, string16_value0}, {enum_value1, string16_value1} ...".
+#define DEFINE_ENUM_CONVERTERS(T, ...)                                        \
+  template <>                                                                 \
+  const views::metadata::EnumStrings<T>&                                      \
+  views::metadata::GetEnumStringsInstance<T>() {                              \
+    static const base::NoDestructor<EnumStrings<T>> instance(                 \
+        std::vector<views::metadata::EnumStrings<T>::EnumString>(             \
+            {__VA_ARGS__}));                                                  \
+    return *instance;                                                         \
+  }                                                                           \
+                                                                              \
+  template <>                                                                 \
+  base::string16 views::metadata::ConvertToString<T>(T source_value) {        \
+    for (const auto& pair : GetEnumStringsInstance<T>().pairs) {              \
+      if (source_value == pair.enum_value)                                    \
+        return pair.str_value;                                                \
+    }                                                                         \
+    return base::string16();                                                  \
+  }                                                                           \
+                                                                              \
+  template <>                                                                 \
+  T views::metadata::ConvertFromString<T>(const base::string16& source_value, \
+                                          T default_value) {                  \
+    for (const auto& pair : GetEnumStringsInstance<T>().pairs) {              \
+      if (source_value == pair.str_value)                                     \
+        return pair.enum_value;                                               \
+    }                                                                         \
+    return default_value;                                                     \
+  }
+
 // TypeConverter Class --------------------------------------------------------
 template <typename TSource, typename TTarget>
 class TypeConverter {