Refactor and push window properties up to class properties.

ui/base/class_property.h

+// 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.
+
+#ifndef UI_BASE_CLASS_PROPERTY_H_
+#define UI_BASE_CLASS_PROPERTY_H_
+
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <set>
+
+#include "ui/base/property_data.h"
+#include "ui/base/ui_base_export.h"
+#include "ui/base/ui_base_types.h"
+
+// This header should be included by code that defines ClassProperties.
+//
+// To define a new ClassProperty:
+//
+//  #include "foo/foo_export.h"
+//  #include "ui/base/class_property.h"
+//
+//  DECLARE_EXPORTED_UI_CLASS_PROPERTY_TYPE(FOO_EXPORT, MyType);
+//  namespace foo {
+//    // Use this to define an exported property that is primitive,
+//    // or a pointer you don't want automatically deleted.
+//    DEFINE_UI_CLASS_PROPERTY_KEY(MyType, kMyKey, MyDefault);
+//
+//    // Use this to define an exported property whose value is a heap
+//    // allocated object, and has to be owned and freed by the class.
+//    DEFINE_OWNED_UI_CLASS_PROPERTY_KEY(gfx::Rect, kRestoreBoundsKey, NULL);
+//
+//    // Use this to define a non exported property that is primitive,
+//    // or a pointer you don't want to automatically deleted, and is used
+//    // only in a specific file. This will define the property in an unnamed
+//    // namespace which cannot be accessed from another file.
+//    DEFINE_LOCAL_UI_CLASS_PROPERTY_KEY(MyType, kMyKey, MyDefault);
+//
+//  }  // foo namespace
+//
+// To define a new type used for ClassProperty.
+//
+//  // outside all namespaces:
+//  DECLARE_EXPORTED_UI_CLASS_PROPERTY_TYPE(FOO_EXPORT, MyType)
+//
+// If a property type is not exported, use DECLARE_CLASS_PROPERTY_TYPE(MyType)
+// which is a shorthand for DECLARE_EXPORTED_CLASS_PROPERTY_TYPE(, MyType).
+
+namespace ui {
+
+// Type of a function to delete a property that this window owns.
+using PropertyDeallocator = void(*)(int64_t value);
+
+template<typename T>
+struct ClassProperty {
+  T default_value;
+  const char* name;
+  PropertyDeallocator deallocator;
+};
+
+namespace subtle {
+
+class PropertyHelper;
+
+}
+
+class UI_BASE_EXPORT PropertyHandler {
+ public:
+  PropertyHandler();
+  ~PropertyHandler();
+
+  // Sets the |value| of the given class |property|. Setting to the default
+  // value (e.g., NULL) removes the property. The caller is responsible for the
+  // lifetime of any object set as a property on the class.
+  template<typename T>
+  void SetProperty(const ClassProperty<T>* property, T value);
+
+  // Returns the value of the given class |property|.  Returns the
+  // property-specific default value if the property was not previously set.
+  template<typename T>
+  T GetProperty(const ClassProperty<T>* property) const;
+
+  // Sets the |property| to its default value. Useful for avoiding a cast when
+  // setting to NULL.
+  template<typename T>
+  void ClearProperty(const ClassProperty<T>* property);
+
+  // Returns the value of all properties with a non-default value.
+  std::set<const void*> GetAllPropertyKeys() const;

[sky, 2017/02/01 00:54:02]

Thanks for fixing the spelling here!

[kylix_rd, 2017/02/01 18:43:14]

Not a problem. It happens.

+
+ protected:
+  friend class subtle::PropertyHelper;
+
+  virtual void AfterPropertyChange(const void* key,
+                                   int64_t old_value,
+                                   std::unique_ptr<PropertyData> data) {}
+  virtual std::unique_ptr<PropertyData> BeforePropertyChange(const void* key);
+  void ClearProperties();
+
+  // Called by the public {Set,Get,Clear}Property functions.
+  int64_t SetPropertyInternal(const void* key,
+                              const char* name,
+                              PropertyDeallocator deallocator,
+                              int64_t value,
+                              int64_t default_value);
+  int64_t GetPropertyInternal(const void* key, int64_t default_value) const;
+
+ private:
+  // Value struct to keep the name and deallocator for this property.
+  // Key cannot be used for this purpose because it can be char* or
+  // ClassProperty<>.
+  struct Value {
+    const char* name;
+    int64_t value;
+    PropertyDeallocator deallocator;
+  };
+
+  std::map<const void*, Value> prop_map_;
+};
+
+namespace {
+
+// No single new-style cast works for every conversion to/from int64_t, so we
+// need this helper class. A third specialization is needed for bool because
+// MSVC warning C4800 (forcing value to bool) is not suppressed by an explicit
+// cast (!).
+template<typename T>
+class ClassPropertyCaster {
+ public:
+  static int64_t ToInt64(T x) { return static_cast<int64_t>(x); }
+  static T FromInt64(int64_t x) { return static_cast<T>(x); }
+};
+template<typename T>
+class ClassPropertyCaster<T*> {
+ public:
+  static int64_t ToInt64(T* x) { return reinterpret_cast<int64_t>(x); }
+  static T* FromInt64(int64_t x) { return reinterpret_cast<T*>(x); }
+};
+template<>
+class ClassPropertyCaster<bool> {
+ public:
+  static int64_t ToInt64(bool x) { return static_cast<int64_t>(x); }
+  static bool FromInt64(int64_t x) { return x != 0; }
+};
+
+}  // namespace
+
+namespace subtle {
+
+class UI_BASE_EXPORT PropertyHelper {
+ public:
+  template<typename T>
+  static void Set(::ui::PropertyHandler* handler,
+                  const ::ui::ClassProperty<T>* property, T value) {
+    int64_t old = handler->SetPropertyInternal(
+        property, property->name,
+        value == property->default_value ? nullptr : property->deallocator,
+        ClassPropertyCaster<T>::ToInt64(value),
+        ClassPropertyCaster<T>::ToInt64(property->default_value));
+    if (property->deallocator &&
+        old != ClassPropertyCaster<T>::ToInt64(property->default_value)) {
+      (*property->deallocator)(old);
+    }
+  }
+  template<typename T>
+  static T Get(const ::ui::PropertyHandler* handler,
+               const ::ui::ClassProperty<T>* property) {
+    return ClassPropertyCaster<T>::FromInt64(handler->GetPropertyInternal(
+        property, ClassPropertyCaster<T>::ToInt64(property->default_value)));
+  }
+  template<typename T>
+  static void Clear(::ui::PropertyHandler* handler,
+                    const ::ui::ClassProperty<T>* property) {
+    handler->SetProperty(property, property->default_value);
+  }
+};
+
+}  // namespace subtle
+
+}  // namespace ui
+
+// Macros to instantiate the property getter/setter template functions.
+#define DECLARE_EXPORTED_UI_CLASS_PROPERTY_TYPE(EXPORT, T)                   \
+  namespace ui {                                                             \
+  template <>                                                                \
+  EXPORT void PropertyHandler::SetProperty(                                  \
+      const ClassProperty<T>* property, T value) {                           \
+    subtle::PropertyHelper::Set<T>(this, property, value);                   \
+  }                                                                          \
+  template <>                                                                \
+  EXPORT T PropertyHandler::GetProperty(                                     \
+      const ClassProperty<T>* property) const {                              \
+    return subtle::PropertyHelper::Get<T>(this, property);                   \
+  }                                                                          \
+  template <>                                                                \
+  EXPORT void PropertyHandler::ClearProperty(                                \
+      const ClassProperty<T>* property) {                                    \
+    subtle::PropertyHelper::Clear<T>(this, property);                        \
+  }                                                                          \
+  }
+
+#define DECLARE_UI_CLASS_PROPERTY_TYPE(T)  \
+    DECLARE_EXPORTED_UI_CLASS_PROPERTY_TYPE(, T)
+
+#define DEFINE_UI_CLASS_PROPERTY_KEY(TYPE, NAME, DEFAULT)                    \
+  static_assert(sizeof(TYPE) <= sizeof(int64_t), "property type too large"); \
+  namespace {                                                                \
+  const ::ui::ClassProperty<TYPE> NAME##_Value = {DEFAULT, #NAME, nullptr};  \
+  }                                                                          \
+  const ::ui::ClassProperty<TYPE>* const NAME = &NAME##_Value;
+
+#define DEFINE_LOCAL_UI_CLASS_PROPERTY_KEY(TYPE, NAME, DEFAULT)              \
+  static_assert(sizeof(TYPE) <= sizeof(int64_t), "property type too large"); \
+  namespace {                                                                \
+  const ::ui::ClassProperty<TYPE> NAME##_Value = {DEFAULT, #NAME, nullptr};  \
+  const ::ui::ClassProperty<TYPE>* const NAME = &NAME##_Value;               \
+  }
+
+#define DEFINE_OWNED_UI_CLASS_PROPERTY_KEY(TYPE, NAME, DEFAULT)          \
+  namespace {                                                            \
+  void Deallocator##NAME(int64_t p) {                                    \
+    enum { type_must_be_complete = sizeof(TYPE) };                       \
+    delete ::ui::ClassPropertyCaster<TYPE*>::FromInt64(p);               \
+  }                                                                      \
+  const ::ui::ClassProperty<TYPE*> NAME##_Value = {DEFAULT, #NAME,       \
+                                                 &Deallocator##NAME};    \
+  }                                                                      \
+  const ::ui::ClassProperty<TYPE*>* const NAME = &NAME##_Value;
+
+#endif  // UI_BASE_CLASS_PROPERTY_H_