Moves transient window observer methods out of WindowObserver

chrome/browser/ui/ash/multi_user/multi_user_window_manager_chromeos.cc

 // Copyright 2013 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 "chrome/browser/ui/ash/multi_user/multi_user_window_manager_chromeos.h"
 
 #include "apps/shell_window.h"
 #include "apps/shell_window_registry.h"
 #include "ash/ash_switches.h"
 #include "ash/multi_profile_uma.h"
@@ skipping 18 matching lines @@
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "content/public/browser/notification_service.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/events/event.h"
+#include "ui/views/corewm/transient_window_manager.h"
 #include "ui/views/corewm/window_util.h"
 
 namespace {
 
 // Checks if a given event is a user event.
 bool IsUserEvent(ui::Event* e) {
   if (e) {
     ui::EventType type = e->type();
     if (type != ui::ET_CANCEL_MODE &&
         type != ui::ET_UMA_DATA &&
@@ skipping 179 matching lines @@
   DCHECK(window);
   DCHECK(!user_id.empty());
   if (GetWindowOwner(window) == user_id)
     return;
   DCHECK(GetWindowOwner(window).empty());
   window_to_entry_[window] = new WindowEntry(user_id);
 
   // Remember the initial visibility of the window.
   window_to_entry_[window]->set_show(window->IsVisible());
 
-  // Set the window and the state observer.
+  // Add observers to track state changes.
   window->AddObserver(this);
   ash::wm::GetWindowState(window)->AddObserver(this);
+  views::corewm::TransientWindowManager::Get(window)->AddObserver(this);
 
   // Check if this window was created due to a user interaction. If it was,
   // transfer it to the current user.
   if (IsProcessingUserEvent())
     window_to_entry_[window]->set_show_for_user(current_user_id_);
 
   // Add all transient children to our set of windows. Note that the function
   // will add the children but not the owner to the transient children map.
   AddTransientOwnerRecursive(window, window);
 
@@ skipping 157 matching lines @@
   }
 }
 
 void MultiUserWindowManagerChromeOS::OnWindowDestroyed(aura::Window* window) {
   if (GetWindowOwner(window).empty()) {
     // This must be a window in the transient chain - remove it and its
     // children from the owner.
     RemoveTransientOwnerRecursive(window);
     return;
   }
-  // Remove the state and the window observer.
   ash::wm::GetWindowState(window)->RemoveObserver(this);
+  views::corewm::TransientWindowManager::Get(window)->RemoveObserver(this);
   // Remove the window from the owners list.
   delete window_to_entry_[window];
   window_to_entry_.erase(window);
 }
 
 void MultiUserWindowManagerChromeOS::OnWindowVisibilityChanging(
     aura::Window* window, bool visible) {
   // This command gets called first and immediately when show or hide gets
   // called. We remember here the desired state for restoration IF we were
   // not ourselves issuing the call.
@@ skipping 25 matching lines @@
   if (visible && !IsWindowOnDesktopOfUser(window, current_user_id_)) {
     SetWindowVisibility(window, false);
     return;
   }
   aura::Window* owned_parent = GetOwningWindowInTransientChain(window);
   if (owned_parent && owned_parent != window && visible &&
       !IsWindowOnDesktopOfUser(owned_parent, current_user_id_))
     SetWindowVisibility(window, false);
 }
 
-void MultiUserWindowManagerChromeOS::OnAddTransientChild(
+void MultiUserWindowManagerChromeOS::OnTransientChildAdded(
     aura::Window* window,
     aura::Window* transient_window) {
   if (!GetWindowOwner(window).empty()) {
     AddTransientOwnerRecursive(transient_window, window);
     return;
   }
   aura::Window* owned_parent =
       GetOwningWindowInTransientChain(transient_window);
   if (!owned_parent)
     return;
 
   AddTransientOwnerRecursive(transient_window, owned_parent);
 }
 
-void MultiUserWindowManagerChromeOS::OnRemoveTransientChild(
+void MultiUserWindowManagerChromeOS::OnTransientChildRemoved(
     aura::Window* window,
     aura::Window* transient_window) {
   // Remove the transient child if the window itself is owned, or one of the
   // windows in its transient parents chain.
   if (!GetWindowOwner(window).empty() ||
       GetOwningWindowInTransientChain(window))
     RemoveTransientOwnerRecursive(transient_window);
 }
 
 void MultiUserWindowManagerChromeOS::OnWindowShowTypeChanged(
@@ skipping 107 matching lines @@
 
   // If this window is the owned window, we do not have to handle it again.
   if (window == owned_parent)
     return;
 
   // Remember the current visibility.
   DCHECK(transient_window_to_visibility_.find(window) ==
              transient_window_to_visibility_.end());
   transient_window_to_visibility_[window] = window->IsVisible();
 
-  // Add a window observer to make sure that we catch status changes.
+  // Add observers to track state changes.
   window->AddObserver(this);
+  views::corewm::TransientWindowManager::Get(window)->AddObserver(this);
 
   // Hide the window if it should not be shown. Note that this hide operation
   // will hide recursively this and all children - but we have already collected
   // their initial view state.
   if (!IsWindowOnDesktopOfUser(owned_parent, current_user_id_))
     SetWindowVisibility(window, false);
 }
 
 void MultiUserWindowManagerChromeOS::RemoveTransientOwnerRecursive(
     aura::Window* window) {
   // First remove all child windows.
   aura::Window::Windows::const_iterator it =
       views::corewm::GetTransientChildren(window).begin();
   for (; it != views::corewm::GetTransientChildren(window).end(); ++it)
     RemoveTransientOwnerRecursive(*it);
 
   // Find from transient window storage the visibility for the given window,
   // set the visibility accordingly and delete the window from the map.
   TransientWindowToVisibility::iterator visibility_item =
       transient_window_to_visibility_.find(window);
   DCHECK(visibility_item != transient_window_to_visibility_.end());
 
-  // Remove the window observer.
   window->RemoveObserver(this);
+  views::corewm::TransientWindowManager::Get(window)->RemoveObserver(this);
 
   bool unowned_view_state = visibility_item->second;
   transient_window_to_visibility_.erase(visibility_item);
   if (unowned_view_state && !window->IsVisible()) {
     // To prevent these commands from being recorded as any other commands, we
     // are suppressing any window entry changes while this is going on.
     // Instead of calling SetWindowVisible, only show gets called here since all
     // dependents have been shown previously already.
     base::AutoReset<bool> suppressor(&suppress_visibility_changes_, true);
     window->Show();
   }
 }
 
 }  // namespace chrome