Rename GetRootWindow() -> GetPrimaryRootWindow()

ash/wm/activation_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/wm/activation_controller.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_modality_controller.h"
 #include "ash/wm/window_util.h"
@@ skipping 100 matching lines @@
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // ActivationController, public:
 
 ActivationController::ActivationController()
     : updating_activation_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(observer_manager_(this)) {
-  aura::client::SetActivationClient(Shell::GetRootWindow(), this);
+  aura::client::SetActivationClient(Shell::GetPrimaryRootWindow(), this);
   aura::Env::GetInstance()->AddObserver(this);
-  Shell::GetRootWindow()->AddRootWindowObserver(this);
+  Shell::GetPrimaryRootWindow()->AddRootWindowObserver(this);
 }
 
 ActivationController::~ActivationController() {
-  Shell::GetRootWindow()->RemoveRootWindowObserver(this);
+  Shell::GetPrimaryRootWindow()->RemoveRootWindowObserver(this);
   aura::Env::GetInstance()->RemoveObserver(this);
 }
 
 // static
 aura::Window* ActivationController::GetActivatableWindow(
     aura::Window* window,
     const aura::Event* event) {
   aura::Window* parent = window->parent();
   aura::Window* child = window;
   while (parent) {
@@ skipping 20 matching lines @@
 void ActivationController::ActivateWindow(aura::Window* window) {
   ActivateWindowWithEvent(window, NULL);
 }
 
 void ActivationController::DeactivateWindow(aura::Window* window) {
   if (window)
     ActivateNextWindow(window);
 }
 
 aura::Window* ActivationController::GetActiveWindow() {
-  return Shell::GetRootWindow()->GetProperty(
+  return Shell::GetPrimaryRootWindow()->GetProperty(
       aura::client::kRootWindowActiveWindowKey);
 }
 
 bool ActivationController::OnWillFocusWindow(aura::Window* window,
                                              const aura::Event* event) {
   return CanActivateWindowWithEvent(
       GetActivatableWindow(window, event), event, CURRENT_VISIBILITY);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 10 matching lines @@
                                             next_window->layer());
     }
   }
 }
 
 void ActivationController::OnWindowDestroying(aura::Window* window) {
   if (wm::IsActiveWindow(window)) {
     // Clear the property before activating something else, since
     // ActivateWindow() will attempt to notify the window stored in this value
     // otherwise.
-    Shell::GetRootWindow()->ClearProperty(
+    Shell::GetPrimaryRootWindow()->ClearProperty(
         aura::client::kRootWindowActiveWindowKey);
     ActivateWindow(GetTopmostWindowToActivate(window));
   }
   observer_manager_.Remove(window);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ActivationController, aura::EnvObserver implementation:
 
 void ActivationController::OnWindowInitialized(aura::Window* window) {
@@ skipping 41 matching lines @@
   // it will be activated when the lock window is destroyed.
   if (window && !window->CanReceiveEvents()) {
     StackTransientParentsBelowModalWindow(window);
     window->parent()->StackChildAtTop(window);
     return;
   }
   if (window &&
       !window->Contains(window->GetFocusManager()->GetFocusedWindow())) {
     window->GetFocusManager()->SetFocusedWindow(window, event);
   }
-  Shell::GetRootWindow()->SetProperty(aura::client::kRootWindowActiveWindowKey,
-                                      window);
+  Shell::GetPrimaryRootWindow()->SetProperty(
+      aura::client::kRootWindowActiveWindowKey, window);
   // Invoke OnLostActive after we've changed the active window. That way if the
   // delegate queries for active state it doesn't think the window is still
   // active.
   if (old_active && aura::client::GetActivationDelegate(old_active))
     aura::client::GetActivationDelegate(old_active)->OnLostActive();
 
   if (window) {
     StackTransientParentsBelowModalWindow(window);
     window->parent()->StackChildAtTop(window);
     if (aura::client::GetActivationDelegate(window))
@@ skipping 45 matching lines @@
     if (*i != ignore &&
         CanActivateWindowWithEvent(*i, NULL, CURRENT_VISIBILITY) &&
         !wm::IsWindowMinimized(*i))
       return *i;
   }
   return NULL;
 }
 
 }  // namespace internal
 }  // namespace ash