Revert 66784 - Converts usage of SetProp/GetProp to a map. Even after making ...

views/widget/widget_win.cc

 // Copyright (c) 2010 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 "views/widget/widget_win.h"
 
 #include "app/keyboard_code_conversion_win.h"
 #include "app/l10n_util_win.h"
 #include "app/system_monitor.h"
-#include "app/view_prop.h"
 #include "app/win_util.h"
+#include "app/win/scoped_prop.h"
 #include "base/string_util.h"
 #include "base/win_util.h"
 #include "gfx/canvas_skia.h"
 #include "gfx/native_theme_win.h"
 #include "gfx/path.h"
 #include "views/accessibility/view_accessibility.h"
 #include "views/controls/native_control_win.h"
 #include "views/focus/focus_util_win.h"
 #include "views/views_delegate.h"
 #include "views/widget/aero_tooltip_manager.h"
 #include "views/widget/child_window_message_processor.h"
 #include "views/widget/default_theme_provider.h"
 #include "views/widget/drop_target_win.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget_delegate.h"
 #include "views/window/window_win.h"
 
-using app::ViewProp;
-
 namespace views {
 
 // Property used to link the HWND to its RootView.
-static const char* const kRootViewWindowProperty = "__ROOT_VIEW__";
-
-// Links the HWND to it's Widget (as a Widget, not a WidgetWin).
-static const char* const kWidgetKey = "__VIEWS_WIDGET__";
+static const wchar_t* const kRootViewWindowProperty = L"__ROOT_VIEW__";
+static const wchar_t* kWidgetKey = L"__VIEWS_WIDGET__";
 
 bool WidgetWin::screen_reader_active_ = false;
 
 // A custom MSAA object id used to determine if a screen reader is actively
 // listening for MSAA events.
 #define OBJID_CUSTOM 1
 
 RootView* GetRootViewForHWND(HWND hwnd) {
-  return reinterpret_cast<RootView*>(
-      ViewProp::GetValue(hwnd, kRootViewWindowProperty));
+  return reinterpret_cast<RootView*>(::GetProp(hwnd, kRootViewWindowProperty));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WidgetWin, public
 
 WidgetWin::WidgetWin()
     : close_widget_factory_(this),
       active_mouse_tracking_flags_(0),
       has_capture_(false),
       use_layered_buffer_(true),
@@ skipping 354 matching lines @@
 }
 
 Window* WidgetWin::GetWindow() {
   return GetWindowImpl(hwnd());
 }
 
 const Window* WidgetWin::GetWindow() const {
   return GetWindowImpl(hwnd());
 }
 
-void WidgetWin::SetNativeWindowProperty(const char* name, void* value) {
+void WidgetWin::SetNativeWindowProperty(const std::wstring& name, void* value) {
   // Remove the existing property (if any).
-  for (ViewProps::iterator i = props_.begin(); i != props_.end(); ++i) {
-    if ((*i)->Key() == name) {
+  for (ScopedProps::iterator i = props_.begin(); i != props_.end(); ++i) {
+    if ((*i)->key() == name) {
       props_.erase(i);
       break;
     }
   }
 
   if (value)
-    props_.push_back(new ViewProp(hwnd(), name, value));
+    props_.push_back(new app::win::ScopedProp(hwnd(), name, value));
 }
 
-void* WidgetWin::GetNativeWindowProperty(const char* name) {
-  return ViewProp::GetValue(hwnd(), name);
+void* WidgetWin::GetNativeWindowProperty(const std::wstring& name) {
+  return GetProp(hwnd(), name.c_str());
 }
 
 ThemeProvider* WidgetWin::GetThemeProvider() const {
   Widget* widget = GetRootWidget();
   if (widget && widget != this) {
     // Attempt to get the theme provider, and fall back to the default theme
     // provider if not found.
     ThemeProvider* provider = widget->GetThemeProvider();
     if (provider)
       return provider;
@@ skipping 849 matching lines @@
     ex_style |= WS_EX_LAYERED;
   if (accept_events != AcceptEvents)
     ex_style |= WS_EX_TRANSPARENT;
   popup->set_window_style(WS_POPUP);
   popup->set_window_ex_style(ex_style);
   popup->set_delete_on_destroy(delete_on_destroy == DeleteOnDestroy);
   return popup;
 }
 
 static BOOL CALLBACK EnumChildProc(HWND hwnd, LPARAM l_param) {
-  RootView* root_view = GetRootViewForHWND(hwnd);
+  RootView* root_view =
+      reinterpret_cast<RootView*>(GetProp(hwnd, kRootViewWindowProperty));
   if (root_view) {
     *reinterpret_cast<RootView**>(l_param) = root_view;
     return FALSE;  // Stop enumerating.
   }
   return TRUE;  // Keep enumerating.
 }
 
 // static
 RootView* Widget::FindRootView(HWND hwnd) {
-  RootView* root_view = GetRootViewForHWND(hwnd);
+  RootView* root_view =
+      reinterpret_cast<RootView*>(GetProp(hwnd, kRootViewWindowProperty));
   if (root_view)
     return root_view;
 
   // Enumerate all children and check if they have a RootView.
   EnumChildWindows(hwnd, EnumChildProc, reinterpret_cast<LPARAM>(&root_view));
 
   return root_view;
 }
 
 // Enumerate child windows as they could have RootView distinct from
 // the HWND's root view.
 BOOL CALLBACK EnumAllRootViewsChildProc(HWND hwnd, LPARAM l_param) {
-  RootView* root_view = GetRootViewForHWND(hwnd);
+  RootView* root_view =
+      reinterpret_cast<RootView*>(GetProp(hwnd, kRootViewWindowProperty));
   if (root_view) {
     std::set<RootView*>* root_views_set =
         reinterpret_cast<std::set<RootView*>*>(l_param);
     root_views_set->insert(root_view);
   }
   return TRUE;  // Keep enumerating.
 }
 
 void Widget::FindAllRootViews(HWND window,
                               std::vector<RootView*>* root_views) {
-  RootView* root_view = GetRootViewForHWND(window);
+  RootView* root_view =
+      reinterpret_cast<RootView*>(GetProp(window, kRootViewWindowProperty));
   std::set<RootView*> root_views_set;
   if (root_view)
     root_views_set.insert(root_view);
   // Enumerate all children and check if they have a RootView.
   EnumChildWindows(window, EnumAllRootViewsChildProc,
       reinterpret_cast<LPARAM>(&root_views_set));
   root_views->clear();
   root_views->reserve(root_views_set.size());
   for (std::set<RootView*>::iterator it = root_views_set.begin();
       it != root_views_set.end();
       ++it)
     root_views->push_back(*it);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, public:
 
 // static
 Widget* Widget::GetWidgetFromNativeView(gfx::NativeView native_view) {
-  return IsWindow(native_view) ?
-      reinterpret_cast<Widget*>(ViewProp::GetValue(native_view, kWidgetKey)) :
-      NULL;
+  if (IsWindow(native_view)) {
+    HANDLE raw_widget = GetProp(native_view, kWidgetKey);
+    if (raw_widget)
+      return reinterpret_cast<Widget*>(raw_widget);
+  }
+  return NULL;
 }
 
 // static
 Widget* Widget::GetWidgetFromNativeWindow(gfx::NativeWindow native_window) {
   return Widget::GetWidgetFromNativeView(native_window);
 }
 
 // static
 void Widget::NotifyLocaleChanged() {
   NOTIMPLEMENTED();
 }
 
 }  // namespace views