Revert of Use template specialization to generate WindowProperty code

ui/aura/window_property.h

 // Copyright (c) 2012 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_AURA_WINDOW_PROPERTY_H_
 #define UI_AURA_WINDOW_PROPERTY_H_
 
 #include "base/basictypes.h"
 #include "ui/aura/aura_export.h"
 #include "ui/aura/window.h"
 
-// This header should be included by code that defines WindowProperties.
+// This header should be included by code that defines WindowProperties. It
+// should not be included by code that only gets and sets WindowProperties.
 //
 // To define a new WindowProperty:
 //
 //  #include "foo/foo_export.h"
 //  #include "ui/aura/window_property.h"
 //
 //  DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(FOO_EXPORT, MyType);
 //  namespace foo {
 //    // Use this to define an exported property that is premitive,
 //    // or a pointer you don't want automatically deleted.
@@ skipping 47 matching lines @@
 
 }  // namespace
 
 template<typename T>
 struct WindowProperty {
   T default_value;
   const char* name;
   Window::PropertyDeallocator deallocator;
 };
 
-namespace subtle {
+template<typename T>
+void Window::SetProperty(const WindowProperty<T>* property, T value) {
+  int64 old = SetPropertyInternal(
+      property,
+      property->name,
+      value == property->default_value ? NULL : 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);
+  }
+}
 
-class AURA_EXPORT PropertyHelper {
- public:
-  template<typename T>
-  static void Set(Window* window, const WindowProperty<T>* property, T value) {
-    int64 old = window->SetPropertyInternal(
-        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>
-  static T Get(const Window* window, const WindowProperty<T>* property) {
-    return WindowPropertyCaster<T>::FromInt64(window->GetPropertyInternal(
-        property, WindowPropertyCaster<T>::ToInt64(property->default_value)));
-  }
-  template<typename T>
-  static void Clear(Window* window, const WindowProperty<T>* property) {
-    window->SetProperty(property, property->default_value);       \
-  }
-};
+template<typename T>
+T Window::GetProperty(const WindowProperty<T>* property) const {
+  return WindowPropertyCaster<T>::FromInt64(GetPropertyInternal(
+      property, WindowPropertyCaster<T>::ToInt64(property->default_value)));
+}
 
-}  // namespace subtle
+template<typename T>
+void Window::ClearProperty(const WindowProperty<T>* property) {
+  SetProperty(property, property->default_value);
+}
 
 }  // namespace aura
 
 // Macros to instantiate the property getter/setter template functions.
 #define DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(EXPORT, T)  \
-    template<> EXPORT void aura::Window::SetProperty(         \
-        const aura::WindowProperty<T >* property, T value) {  \
-      subtle::PropertyHelper::Set<T>(this, property, value);  \
-    }                                                         \
-    template<> EXPORT T aura::Window::GetProperty(            \
-        const aura::WindowProperty<T >* property) const {     \
-      return subtle::PropertyHelper::Get<T>(this, property);  \
-    }                                                         \
-    template<> EXPORT void aura::Window::ClearProperty(       \
-        const aura::WindowProperty<T >* property) {           \
-      subtle::PropertyHelper::Clear<T>(this, property);       \
-    }
+    template EXPORT void aura::Window::SetProperty(         \
+        const aura::WindowProperty<T >*, T);                \
+    template EXPORT T aura::Window::GetProperty(            \
+        const aura::WindowProperty<T >*) const;             \
+    template EXPORT void aura::Window::ClearProperty(       \
+        const aura::WindowProperty<T >*);
 #define DECLARE_WINDOW_PROPERTY_TYPE(T)  \
     DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(, T)
 
 #define DEFINE_WINDOW_PROPERTY_KEY(TYPE, NAME, DEFAULT) \
-  COMPILE_ASSERT(sizeof(TYPE) <= sizeof(int64), property_type_too_large);  \
-  namespace {                                                              \
-    const aura::WindowProperty<TYPE> NAME ## _Value =                      \
-        {DEFAULT, #NAME, nullptr};                                         \
-  }                                                                        \
+  COMPILE_ASSERT(sizeof(TYPE) <= sizeof(int64), property_type_too_large);     \
+  namespace {                                                                 \
+    const aura::WindowProperty<TYPE> NAME ## _Value = {DEFAULT, #NAME, NULL}; \
+  }                                                                           \
   const aura::WindowProperty<TYPE>* const NAME = & NAME ## _Value;
 
 #define DEFINE_LOCAL_WINDOW_PROPERTY_KEY(TYPE, NAME, DEFAULT) \
-  COMPILE_ASSERT(sizeof(TYPE) <= sizeof(int64), property_type_too_large);  \
-  namespace {                                                              \
-    const aura::WindowProperty<TYPE> NAME ## _Value =                      \
-        {DEFAULT, #NAME, nullptr};                                         \
-    const aura::WindowProperty<TYPE>* const NAME = & NAME ## _Value;       \
+  COMPILE_ASSERT(sizeof(TYPE) <= sizeof(int64), property_type_too_large);     \
+  namespace {                                                                 \
+    const aura::WindowProperty<TYPE> NAME ## _Value = {DEFAULT, #NAME, NULL}; \
+    const aura::WindowProperty<TYPE>* const NAME = & NAME ## _Value;          \
   }
 
 #define DEFINE_OWNED_WINDOW_PROPERTY_KEY(TYPE, NAME, DEFAULT)   \
   namespace {                                                   \
     void Deallocator ## NAME (int64 p) {                        \
       enum { type_must_be_complete = sizeof(TYPE) };            \
       delete aura::WindowPropertyCaster<TYPE*>::FromInt64(p); \
     }                                                           \
     const aura::WindowProperty<TYPE*> NAME ## _Value =          \
         {DEFAULT,#NAME,&Deallocator ## NAME};                   \
   }                                                             \
   const aura::WindowProperty<TYPE*>* const NAME = & NAME ## _Value;
 
 #endif  // UI_AURA_WINDOW_PROPERTY_H_