Refactor and push window properties up to class properties.

ui/aura/window.cc

 // 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.
 
 #include "ui/aura/window.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 106 matching lines @@
   for (WindowObserver& observer : observers_) {
     RemoveObserver(&observer);
     observer.OnWindowDestroyed(this);
   }
 
   // Delete the LayoutManager before properties. This way if the LayoutManager
   // depends upon properties existing the properties are still valid.
   layout_manager_.reset();
 
   // Clear properties.
-  for (std::map<const void*, Value>::const_iterator iter = prop_map_.begin();
-       iter != prop_map_.end();
-       ++iter) {
-    if (iter->second.deallocator)
-      (*iter->second.deallocator)(iter->second.value);
-  }
-  prop_map_.clear();
+  ClearProperties();
 
   // The layer will either be destroyed by |layer_owner_|'s dtor, or by whoever
   // acquired it.
   layer()->set_delegate(NULL);
   DestroyLayer();
 }
 
 void Window::Init(ui::LayerType layer_type) {
   if (!port_owner_) {
     port_owner_ = Env::GetInstance()->CreateWindowPort(this);
@@ skipping 448 matching lines @@
   if (!root_window)
     return false;
   client::CaptureClient* capture_client = client::GetCaptureClient(root_window);
   return capture_client && capture_client->GetCaptureWindow() == this;
 }
 
 void Window::SuppressPaint() {
   layer()->SuppressPaint();
 }
 
+/*
 std::set<const void*> Window::GetAllPropertKeys() const {
   std::set<const void*> keys;
   for (auto& pair : prop_map_)
     keys.insert(pair.first);
   return keys;
-}
+}*/
 
 // {Set,Get,Clear}Property are implemented in window_property.h.
 
 void Window::SetNativeWindowProperty(const char* key, void* value) {
   SetPropertyInternal(key, key, NULL, reinterpret_cast<int64_t>(value), 0);
 }
 
 void* Window::GetNativeWindowProperty(const char* key) const {
   return reinterpret_cast<void*>(GetPropertyInternal(key, 0));
 }
@@ skipping 36 matching lines @@
              children_.end());
     } else {
       // Even if we can't delete the child, we still need to remove it from the
       // parent so that relevant bookkeeping (parent_ back-pointers etc) are
       // updated.
       RemoveChild(child);
     }
   }
 }
 
+std::unique_ptr<ui::PropertyData> Window::BeforePropertyChange(
+    const void* key) {
+  return port_ ? port_->OnWillChangeProperty(key) : nullptr;
+}
+
+void Window::AfterPropertyChange(const void* key,
+                                 int64_t old_value,
+                                 std::unique_ptr<ui::PropertyData> data) {
+  if (port_)
+    port_->OnPropertyChanged(key, std::move(data));
+  for (WindowObserver& observer : observers_)
+    observer.OnWindowPropertyChanged(this, key, old_value);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Window, private:
 
 int64_t Window::SetPropertyInternal(const void* key,
                                     const char* name,
-                                    PropertyDeallocator deallocator,
+                                    ui::PropertyDeallocator deallocator,
                                     int64_t value,
                                     int64_t default_value) {
-  // This code may be called before |port_| has been created.
-  std::unique_ptr<WindowPortPropertyData> data =
-      port_ ? port_->OnWillChangeProperty(key) : nullptr;
-  int64_t old = GetPropertyInternal(key, default_value);
-  if (value == default_value) {
-    prop_map_.erase(key);
-  } else {
-    Value prop_value;
-    prop_value.name = name;
-    prop_value.value = value;
-    prop_value.deallocator = deallocator;
-    prop_map_[key] = prop_value;
-  }
-  if (port_)
-    port_->OnPropertyChanged(key, std::move(data));
-  for (WindowObserver& observer : observers_)
-    observer.OnWindowPropertyChanged(this, key, old);
-  return old;
+  return PropertyHandler::SetPropertyInternal(key, name, deallocator, value,
+      default_value);
 }
 
 int64_t Window::GetPropertyInternal(const void* key,
                                     int64_t default_value) const {
-  std::map<const void*, Value>::const_iterator iter = prop_map_.find(key);
-  if (iter == prop_map_.end())
-    return default_value;
-  return iter->second.value;
+  return PropertyHandler::GetPropertyInternal(key, default_value);
 }
 
 bool Window::HitTest(const gfx::Point& local_point) {
   gfx::Rect local_bounds(bounds().size());
   if (!delegate_ || !delegate_->HasHitTestMask())
     return local_bounds.Contains(local_point);
 
   gfx::Path mask;
   delegate_->GetHitTestMask(&mask);
 
@@ skipping 410 matching lines @@
     layer_name = "Unnamed Window";
 
   if (id_ != -1)
     layer_name += " " + base::IntToString(id_);
 
   layer()->set_name(layer_name);
 #endif
 }
 
 }  // namespace aura