Introduce RootWindowProperty for RootWindow's properties

ash/display/display_controller.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 "ash/display/display_controller.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/mirror_window_controller.h"
 #include "ash/display/root_window_transformers.h"
 #include "ash/host/root_window_host_factory.h"
 #include "ash/root_window_controller.h"
+#include "ash/root_window_property.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/property_util.h"
-#include "ash/wm/window_properties.h"
-#include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "third_party/skia/include/utils/SkMatrix44.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/root_window_transformer.h"
@@ skipping 13 matching lines @@
 #include "chromeos/display/output_configurator.h"
 #include "ui/base/x/x11_util.h"
 
 // Including this at the bottom to avoid other
 // potential conflict with chrome headers.
 #include <X11/extensions/Xrandr.h>
 #undef RootWindow
 #endif  // defined(USE_X11)
 #endif  // defined(OS_CHROMEOS)
 
-DECLARE_WINDOW_PROPERTY_TYPE(int64);
-
 namespace ash {
 namespace {
 
 // Primary display stored in global object as it can be
 // accessed after Shell is deleted. A separate display instance is created
 // during the shutdown instead of always keeping two display instances
 // (one here and another one in display_manager) in sync, which is error prone.
 int64 primary_display_id = gfx::Display::kInvalidDisplayID;
 gfx::Display* primary_display_for_shutdown = NULL;
 // Keeps the number of displays during the shutdown after
@@ skipping 57 matching lines @@
 #endif
   scoped_ptr<aura::RootWindowTransformer> transformer(
       internal::CreateRootWindowTransformerForDisplay(root, display));
   root->SetRootWindowTransformer(transformer.Pass());
 }
 
 }  // namespace
 
 namespace internal {
 
-DEFINE_WINDOW_PROPERTY_KEY(int64, kDisplayIdKey,
-                           gfx::Display::kInvalidDisplayID);
-
 // A utility class to store/restore focused/active window
 // when the display configuration has changed.
 class FocusActivationStore {
  public:
   FocusActivationStore()
       : activation_client_(NULL),
         capture_client_(NULL),
         focus_client_(NULL),
         focused_(NULL),
         active_(NULL) {
@@ skipping 336 matching lines @@
     return;
 
   gfx::Display old_primary_display = GetPrimaryDisplay();
 
   // Swap root windows between current and new primary display.
   aura::RootWindow* primary_root = root_windows_[primary_display_id];
   DCHECK(primary_root);
   DCHECK_NE(primary_root, non_primary_root);
 
   root_windows_[new_primary_display.id()] = primary_root;
-  primary_root->SetProperty(internal::kDisplayIdKey, new_primary_display.id());
+  internal::GetRootWindowProperty(primary_root)->display_id =
+      new_primary_display.id();
 
   root_windows_[old_primary_display.id()] = non_primary_root;
-  non_primary_root->SetProperty(internal::kDisplayIdKey,
-                                old_primary_display.id());
+  internal::GetRootWindowProperty(non_primary_root)->display_id =
+      old_primary_display.id();
 
   primary_display_id = new_primary_display.id();
   GetDisplayManager()->layout_store()->UpdatePrimaryDisplayId(
       display_manager->GetCurrentDisplayIdPair(), primary_display_id);
 
   UpdateWorkAreaOfDisplayNearestWindow(
       primary_root, old_primary_display.GetWorkAreaInsets());
   UpdateWorkAreaOfDisplayNearestWindow(
       non_primary_root, new_primary_display.GetWorkAreaInsets());
 
@@ skipping 51 matching lines @@
     }
   }
   dst_root_window->ConvertPointFromNativeScreen(&target_location_in_native);
   dst_root_window->MoveCursorTo(target_location_in_native);
 }
 
 bool DisplayController::UpdateWorkAreaOfDisplayNearestWindow(
     const aura::Window* window,
     const gfx::Insets& insets) {
   const aura::RootWindow* root_window = window->GetRootWindow();
-  int64 id = root_window->GetProperty(internal::kDisplayIdKey);
+  int64 id = internal::GetRootWindowProperty(root_window)->display_id;
   // if id is |kInvaildDisplayID|, it's being deleted.
   DCHECK(id != gfx::Display::kInvalidDisplayID);
   return GetDisplayManager()->UpdateWorkAreaOfDisplay(id, insets);
 }
 
 const gfx::Display& DisplayController::GetDisplayNearestWindow(
     const aura::Window* window) const {
   if (!window)
     return GetPrimaryDisplay();
   const aura::RootWindow* root_window = window->GetRootWindow();
   if (!root_window)
     return GetPrimaryDisplay();
-  int64 id = root_window->GetProperty(internal::kDisplayIdKey);
+  int64 id = internal::GetRootWindowProperty(root_window)->display_id;
   // if id is |kInvaildDisplayID|, it's being deleted.
   DCHECK(id != gfx::Display::kInvalidDisplayID);
 
   internal::DisplayManager* display_manager = GetDisplayManager();
   // RootWindow needs Display to determine its device scale factor.
   // TODO(oshima): We don't need full display info for mirror
   // window. Refactor so that RootWindow doesn't use it.
   if (display_manager->mirrored_display().id() == id)
     return display_manager->mirrored_display();
 
@@ skipping 36 matching lines @@
   aura::RootWindow* root = root_windows_[display.id()];
   root->SetHostBounds(display_info.bounds_in_pixel());
   SetDisplayPropertiesOnHostWindow(root, display);
 }
 
 void DisplayController::OnDisplayAdded(const gfx::Display& display) {
   if (primary_root_window_for_replace_) {
     DCHECK(root_windows_.empty());
     primary_display_id = display.id();
     root_windows_[display.id()] = primary_root_window_for_replace_;
-    primary_root_window_for_replace_->SetProperty(
-        internal::kDisplayIdKey, display.id());
+    internal::GetRootWindowProperty(primary_root_window_for_replace_)->
+        display_id = display.id();
     primary_root_window_for_replace_ = NULL;
     const internal::DisplayInfo& display_info =
         GetDisplayManager()->GetDisplayInfo(display.id());
     root_windows_[display.id()]->SetHostBounds(
         display_info.bounds_in_pixel());
   } else {
     if (primary_display_id == gfx::Display::kInvalidDisplayID)
       primary_display_id = display.id();
     DCHECK(!root_windows_.empty());
     aura::RootWindow* root = AddRootWindowForDisplay(display);
@@ skipping 18 matching lines @@
       primary_display_id = gfx::Display::kInvalidDisplayID;
       primary_root_window_for_replace_ = root_to_delete;
       return;
     }
     DCHECK_EQ(1U, root_windows_.size());
     primary_display_id = ScreenAsh::GetSecondaryDisplay().id();
     aura::RootWindow* primary_root = root_to_delete;
 
     // Delete the other root instead.
     root_to_delete = root_windows_[primary_display_id];
-    root_to_delete->SetProperty(internal::kDisplayIdKey, display.id());
+    internal::GetRootWindowProperty(root_to_delete)->display_id = display.id();
 
     // Setup primary root.
     root_windows_[primary_display_id] = primary_root;
-    primary_root->SetProperty(internal::kDisplayIdKey, primary_display_id);
+    internal::GetRootWindowProperty(primary_root)->display_id =
+        primary_display_id;
 
     OnDisplayBoundsChanged(
         GetDisplayManager()->GetDisplayForId(primary_display_id));
   }
   internal::RootWindowController* controller =
       GetRootWindowController(root_to_delete);
   DCHECK(controller);
   controller->MoveWindowsTo(GetPrimaryRootWindow());
   // Delete most of root window related objects, but don't delete
   // root window itself yet because the stack may be using it.
@@ skipping 75 matching lines @@
   aura::RootWindow::CreateParams params(bounds_in_pixel);
   params.host = Shell::GetInstance()->root_window_host_factory()->
       CreateRootWindowHost(bounds_in_pixel);
   aura::RootWindow* root_window = new aura::RootWindow(params);
   root_window->SetName(
       base::StringPrintf("RootWindow-%d", root_window_count++));
   root_window->compositor()->SetBackgroundColor(SK_ColorBLACK);
   // No need to remove RootWindowObserver because
   // the DisplayController object outlives RootWindow objects.
   root_window->AddRootWindowObserver(this);
-  root_window->SetProperty(internal::kDisplayIdKey, display.id());
+  internal::GetRootWindowProperty(root_window)->display_id = display.id();
   root_window->Init();
 
   root_windows_[display.id()] = root_window;
   SetDisplayPropertiesOnHostWindow(root_window, display);
 
 #if defined(OS_CHROMEOS)
   static bool force_constrain_pointer_to_root =
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshConstrainPointerToRoot);
   if (base::chromeos::IsRunningOnChromeOS() || force_constrain_pointer_to_root)
@@ skipping 33 matching lines @@
   for (size_t i = 0; i < root_windows.size(); ++i) {
     std::string name =
         root_windows[i] == primary ? "aura_root_0" : "aura_root_x";
     gfx::AcceleratedWidget xwindow = root_windows[i]->GetAcceleratedWidget();
     XStoreName(ui::GetXDisplay(), xwindow, name.c_str());
   }
 #endif
 }
 
 }  // namespace ash