Moves transient window observer methods out of WindowObserver

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

 // 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.
 
 #ifndef CHROME_BROWSER_UI_ASH_MULTI_USER_MULTI_USER_WINDOW_MANAGER_CHROMEOS_H_
 #define CHROME_BROWSER_UI_ASH_MULTI_USER_MULTI_USER_WINDOW_MANAGER_CHROMEOS_H_
 
 #include <map>
 #include <string>
 
 #include "ash/session_state_observer.h"
 #include "ash/wm/window_state_observer.h"
 #include "base/compiler_specific.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "ui/aura/window_observer.h"
+#include "ui/views/corewm/transient_window_observer.h"
 
 class Browser;
 class Profile;
 
 namespace aura {
 class Window;
 class WindowObserver;
 }
 
 namespace chrome {
 
 class AppObserver;
 
 // This ChromeOS implementation of the MultiUserWindowManager interface is
 // detecting app and browser creations, tagging their windows automatically and
 // using (currently) show and hide to make the owned windows visible - or not.
 // If it becomes necessary, the function |SetWindowVisibility| can be
 // overwritten to match new ways of doing this.
 // Note:
 // - aura::Window::Hide() is currently hiding the window and all owned transient
 //   children. However aura::Window::Show() is only showing the window itself.
 //   To address that, all transient children (and their children) are remembered
 //   in |transient_window_to_visibility_| and monitored to keep track of the
 //   visibility changes from the owning user. This way the visibility can be
 //   changed back to its requested state upon showing by us - or when the window
 //   gets detached from its current owning parent.
-class MultiUserWindowManagerChromeOS : public MultiUserWindowManager,
-                                       public ash::SessionStateObserver,
-                                       public aura::WindowObserver,
-                                       public content::NotificationObserver,
-                                       public ash::wm::WindowStateObserver {
+class MultiUserWindowManagerChromeOS
+    : public MultiUserWindowManager,
+      public ash::SessionStateObserver,
+      public ash::wm::WindowStateObserver,
+      public aura::WindowObserver,
+      public content::NotificationObserver,
+      public views::corewm::TransientWindowObserver {
  public:
   // Create the manager and use |active_user_id| as the active user.
   explicit MultiUserWindowManagerChromeOS(const std::string& active_user_id);
   virtual ~MultiUserWindowManagerChromeOS();
 
   // MultiUserWindowManager overrides:
   virtual void SetWindowOwner(
       aura::Window* window, const std::string& user_id) OVERRIDE;
   virtual const std::string& GetWindowOwner(aura::Window* window) OVERRIDE;
   virtual void ShowWindowForUser(
       aura::Window* window, const std::string& user_id) OVERRIDE;
   virtual bool AreWindowsSharedAmongUsers() OVERRIDE;
   virtual bool IsWindowOnDesktopOfUser(aura::Window* window,
                                        const std::string& user_id) OVERRIDE;
   virtual const std::string& GetUserPresentingWindow(
       aura::Window* window) OVERRIDE;
   virtual void AddUser(Profile* profile) OVERRIDE;
 
   // SessionStateObserver overrides:
   virtual void ActiveUserChanged(const std::string& user_id) OVERRIDE;
 
   // WindowObserver overrides:
   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
   virtual void OnWindowVisibilityChanging(aura::Window* window,
                                           bool visible) OVERRIDE;
   virtual void OnWindowVisibilityChanged(aura::Window* window,
                                          bool visible) OVERRIDE;
-  virtual void OnAddTransientChild(aura::Window* window,
-                                   aura::Window* transient) OVERRIDE;
-  virtual void OnRemoveTransientChild(aura::Window* window,
-                                      aura::Window* transient) OVERRIDE;
+
+  // TransientWindowObserver overrides:
+  virtual void OnTransientChildAdded(aura::Window* window,
+                                     aura::Window* transient) OVERRIDE;
+  virtual void OnTransientChildRemoved(aura::Window* window,
+                                       aura::Window* transient) OVERRIDE;
 
   // Window .. overrides:
   virtual void OnWindowShowTypeChanged(
       ash::wm::WindowState* state,
       ash::wm::WindowShowType old_type) OVERRIDE;
 
   // content::NotificationObserver overrides:
   virtual void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) OVERRIDE;
@@ skipping 94 matching lines @@
   // Caching the current multi profile mode since the detection which mode is
   // used is quite expensive.
   static MultiProfileMode multi_user_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(MultiUserWindowManagerChromeOS);
 };
 
 }  // namespace chrome
 
 #endif  // CHROME_BROWSER_UI_ASH_MULTI_USER_MULTI_USER_WINDOW_MANAGER_CHROMEOS_H_