Moves transient window observer methods out of WindowObserver

ui/views/corewm/transient_window_manager.cc

 // Copyright 2014 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 "ui/views/corewm/transient_window_manager.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/auto_reset.h"
 #include "base/stl_util.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
+#include "ui/views/corewm/transient_window_observer.h"
 #include "ui/views/corewm/transient_window_stacking_client.h"
 #include "ui/views/corewm/window_util.h"
 
 using aura::Window;
 
 namespace views {
 namespace corewm {
 
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(TransientWindowManager, kPropertyKey, NULL);
 
 TransientWindowManager::~TransientWindowManager() {
 }
 
 // static
 TransientWindowManager* TransientWindowManager::Get(Window* window) {
   TransientWindowManager* manager = window->GetProperty(kPropertyKey);
   if (!manager) {
     manager = new TransientWindowManager(window);
     window->SetProperty(kPropertyKey, manager);
   }
   return manager;
 }
 
 // static
 const TransientWindowManager* TransientWindowManager::Get(
     const Window* window) {
   return window->GetProperty(kPropertyKey);
 }
 
+void TransientWindowManager::AddObserver(TransientWindowObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void TransientWindowManager::RemoveObserver(TransientWindowObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 void TransientWindowManager::AddTransientChild(Window* child) {
   // TransientWindowStackingClient does the stacking of transient windows. If it
   // isn't installed stacking is going to be wrong.
   DCHECK(TransientWindowStackingClient::instance_);
 
   TransientWindowManager* child_manager = Get(child);
   if (child_manager->transient_parent_)
     Get(child_manager->transient_parent_)->RemoveTransientChild(child);
   DCHECK(std::find(transient_children_.begin(), transient_children_.end(),
                    child) == transient_children_.end());
   transient_children_.push_back(child);
   child_manager->transient_parent_ = window_;
-  FOR_EACH_OBSERVER(WindowObserver, window_->observers_,
-                    OnAddTransientChild(window_, child));
+  FOR_EACH_OBSERVER(TransientWindowObserver, observers_,
+                    OnTransientChildAdded(window_, child));
 }
 
 void TransientWindowManager::RemoveTransientChild(Window* child) {
   Windows::iterator i =
       std::find(transient_children_.begin(), transient_children_.end(), child);
   DCHECK(i != transient_children_.end());
   transient_children_.erase(i);
   TransientWindowManager* child_manager = Get(child);
   DCHECK_EQ(window_, child_manager->transient_parent_);
   child_manager->transient_parent_ = NULL;
-  FOR_EACH_OBSERVER(WindowObserver, window_->observers_,
-                    OnRemoveTransientChild(window_, child));
+  FOR_EACH_OBSERVER(TransientWindowObserver, observers_,
+                    OnTransientChildRemoved(window_, child));
 }
 
 bool TransientWindowManager::IsStackingTransient(
     const aura::Window* child,
     const aura::Window* target) const {
   return stacking_pair_ && stacking_pair_->child == child &&
       stacking_pair_->target == target;
 }
 
 TransientWindowManager::TransientWindowManager(Window* window)
@@ skipping 59 matching lines @@
   // parent, as destroying an active transient child may otherwise attempt to
   // refocus us.
   // NOTE: this use to be after removed from parent, now its before.
   Windows transient_children(transient_children_);
   STLDeleteElements(&transient_children);
   DCHECK(transient_children_.empty());
 }
 
 }  // namespace corewm
 }  // namespace views