| // Copyright 2014 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 SERVICES_UI_PUBLIC_CPP_WINDOW_PROPERTY_H_ |
| #define SERVICES_UI_PUBLIC_CPP_WINDOW_PROPERTY_H_ |
| |
| #include <stdint.h> |
| |
| // To define a new WindowProperty: |
| // |
| // #include "services/ui/public/cpp/window_property.h" |
| // |
| // MUS_DECLARE_EXPORTED_WINDOW_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. |
| // MUS_DEFINE_WINDOW_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 window. |
| // MUS_DEFINE_OWNED_WINDOW_PROPERTY_KEY(gfx::Rect, kRestoreBoundsKey, |
| // nullptr); |
| // |
| // // 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. |
| // MUS_DEFINE_LOCAL_WINDOW_PROPERTY_KEY(MyType, kMyKey, MyDefault); |
| // |
| // } // foo namespace |
| // |
| // To define a new type used for WindowProperty. |
| // |
| // // outside all namespaces: |
| // MUS_DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(FOO_EXPORT, MyType) |
| // |
| // If a property type is not exported, use |
| // MUS_DECLARE_WINDOW_PROPERTY_TYPE(MyType) which is a shorthand for |
| // MUS_DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(, MyType). |
| |
| namespace ui { |
| |
| template <typename T> |
| void Window::SetSharedProperty(const std::string& name, const T& data) { |
| const std::vector<uint8_t> bytes = |
| mojo::TypeConverter<std::vector<uint8_t>, T>::Convert(data); |
| SetSharedPropertyInternal(name, &bytes); |
| } |
| |
| template <typename T> |
| T Window::GetSharedProperty(const std::string& name) const { |
| DCHECK(HasSharedProperty(name)); |
| auto it = properties_.find(name); |
| return mojo::TypeConverter<T, std::vector<uint8_t>>::Convert(it->second); |
| } |
| |
| 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 WindowPropertyCaster { |
| 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 WindowPropertyCaster<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 WindowPropertyCaster<bool> { |
| public: |
| static int64_t ToInt64(bool x) { return static_cast<int64_t>(x); } |
| static bool FromInt64(int64_t x) { return x != 0; } |
| }; |
| |
| } // namespace |
| |
| template <typename T> |
| struct WindowProperty { |
| T default_value; |
| const char* name; |
| Window::PropertyDeallocator deallocator; |
| }; |
| |
| template <typename T> |
| void Window::SetLocalProperty(const WindowProperty<T>* property, T value) { |
| int64_t old = SetLocalPropertyInternal( |
| property, property->name, |
| value == property->default_value ? nullptr : property->deallocator, |
| WindowPropertyCaster<T>::ToInt64(value), |
| WindowPropertyCaster<T>::ToInt64(property->default_value)); |
| if (property->deallocator && |
| old != WindowPropertyCaster<T>::ToInt64(property->default_value)) { |
| (*property->deallocator)(old); |
| } |
| } |
| |
| template <typename T> |
| T Window::GetLocalProperty(const WindowProperty<T>* property) const { |
| return WindowPropertyCaster<T>::FromInt64(GetLocalPropertyInternal( |
| property, WindowPropertyCaster<T>::ToInt64(property->default_value))); |
| } |
| |
| template <typename T> |
| void Window::ClearLocalProperty(const WindowProperty<T>* property) { |
| SetLocalProperty(property, property->default_value); |
| } |
| |
| } // namespace ui |
| |
| // Macros to instantiate the property getter/setter template functions. |
| #define MUS_DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(EXPORT, T) \ |
| template EXPORT void ui::Window::SetLocalProperty( \ |
| const ui::WindowProperty<T>*, T); \ |
| template EXPORT T ui::Window::GetLocalProperty(const ui::WindowProperty<T>*) \ |
| const; \ |
| template EXPORT void ui::Window::ClearLocalProperty( \ |
| const ui::WindowProperty<T>*); |
| #define MUS_DECLARE_WINDOW_PROPERTY_TYPE(T) \ |
| MUS_DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(, T) |
| |
| #define MUS_DEFINE_WINDOW_PROPERTY_KEY(TYPE, NAME, DEFAULT) \ |
| static_assert(sizeof(TYPE) <= sizeof(int64_t), \ |
| "Property type must fit in 64 bits"); \ |
| namespace { \ |
| const ui::WindowProperty<TYPE> NAME##_Value = {DEFAULT, #NAME, nullptr}; \ |
| } \ |
| const ui::WindowProperty<TYPE>* const NAME = &NAME##_Value; |
| |
| #define MUS_DEFINE_LOCAL_WINDOW_PROPERTY_KEY(TYPE, NAME, DEFAULT) \ |
| static_assert(sizeof(TYPE) <= sizeof(int64_t), \ |
| "Property type must fit in 64 bits"); \ |
| namespace { \ |
| const ui::WindowProperty<TYPE> NAME##_Value = {DEFAULT, #NAME, nullptr}; \ |
| const ui::WindowProperty<TYPE>* const NAME = &NAME##_Value; \ |
| } |
| |
| #define MUS_DEFINE_OWNED_WINDOW_PROPERTY_KEY(TYPE, NAME, DEFAULT) \ |
| namespace { \ |
| void Deallocator##NAME(int64_t p) { \ |
| enum { type_must_be_complete = sizeof(TYPE) }; \ |
| delete ui::WindowPropertyCaster<TYPE*>::FromInt64(p); \ |
| } \ |
| const ui::WindowProperty<TYPE*> NAME##_Value = {DEFAULT, #NAME, \ |
| &Deallocator##NAME}; \ |
| } \ |
| const ui::WindowProperty<TYPE*>* const NAME = &NAME##_Value; |
| |
| #endif // SERVICES_UI_PUBLIC_CPP_WINDOW_PROPERTY_H_ |