Remove DispositionChangePhase.

mojo/services/public/cpp/view_manager/tests/view_manager_unittest.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 "mojo/services/public/cpp/view_manager/view_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "mojo/public/cpp/application/application_connection.h"
@@ skipping 80 matching lines @@
 };
 
 class ActiveViewChangedObserver : public NodeObserver {
  public:
   explicit ActiveViewChangedObserver(Node* node)
       : node_(node) {}
   virtual ~ActiveViewChangedObserver() {}
 
  private:
   // Overridden from NodeObserver:
-  virtual void OnNodeActiveViewChange(Node* node,
-                                      View* old_view,
-                                      View* new_view,
-                                      DispositionChangePhase phase) OVERRIDE {
+  virtual void OnNodeActiveViewChanged(Node* node,
+                                       View* old_view,
+                                       View* new_view) OVERRIDE {
     DCHECK_EQ(node, node_);
     QuitRunLoop();
   }
 
   Node* node_;
 
   DISALLOW_COPY_AND_ASSIGN(ActiveViewChangedObserver);
 };
 
 // Waits until the active view id of the supplied node changes.
 void WaitForActiveViewToChange(Node* node) {
   ActiveViewChangedObserver observer(node);
   node->AddObserver(&observer);
   DoRunLoop();
   node->RemoveObserver(&observer);
 }
 
 class BoundsChangeObserver : public NodeObserver {
  public:
   explicit BoundsChangeObserver(Node* node) : node_(node) {}
   virtual ~BoundsChangeObserver() {}
 
  private:
   // Overridden from NodeObserver:
-  virtual void OnNodeBoundsChange(Node* node,
-                                  const gfx::Rect& old_bounds,
-                                  const gfx::Rect& new_bounds,
-                                  DispositionChangePhase phase) OVERRIDE {
+  virtual void OnNodeBoundsChanged(Node* node,
+                                   const gfx::Rect& old_bounds,
+                                   const gfx::Rect& new_bounds) OVERRIDE {
     DCHECK_EQ(node, node_);
-    if (phase != NodeObserver::DISPOSITION_CHANGED)
-      return;
     QuitRunLoop();
   }
 
   Node* node_;
 
   DISALLOW_COPY_AND_ASSIGN(BoundsChangeObserver);
 };
 
 // Wait until the bounds of the supplied node change.
 void WaitForBoundsToChange(Node* node) {
@@ skipping 11 matching lines @@
       : tree_(tree),
         tree_size_(tree_size) {}
   virtual ~TreeSizeMatchesObserver() {}
 
   bool IsTreeCorrectSize() {
     return CountNodes(tree_) == tree_size_;
   }
 
  private:
   // Overridden from NodeObserver:
-  virtual void OnTreeChange(const TreeChangeParams& params) OVERRIDE {
+  virtual void OnTreeChanged(const TreeChangeParams& params) OVERRIDE {
     if (IsTreeCorrectSize())
       QuitRunLoop();
   }
 
   size_t CountNodes(const Node* node) const {
     size_t count = 1;
     Node::Children::const_iterator it = node->children().begin();
     for (; it != node->children().end(); ++it)
       count += CountNodes(*it);
     return count;
@@ skipping 19 matching lines @@
 // views.
 class DestructionObserver : public NodeObserver, public ViewObserver {
  public:
   // |nodes| or |views| can be NULL.
   DestructionObserver(std::set<Id>* nodes, std::set<Id>* views)
       : nodes_(nodes),
         views_(views) {}
 
  private:
   // Overridden from NodeObserver:
-  virtual void OnNodeDestroy(
-      Node* node,
-      NodeObserver::DispositionChangePhase phase) OVERRIDE {
-    if (phase != NodeObserver::DISPOSITION_CHANGED)
-      return;
+  virtual void OnNodeDestroyed(Node* node) OVERRIDE {
     std::set<Id>::iterator it = nodes_->find(node->id());
     if (it != nodes_->end())
       nodes_->erase(it);
     if (CanQuit())
       QuitRunLoop();
   }
 
   // Overridden from ViewObserver:
-  virtual void OnViewDestroy(
-      View* view,
-      ViewObserver::DispositionChangePhase phase) OVERRIDE {
-    if (phase != ViewObserver::DISPOSITION_CHANGED)
-      return;
+  virtual void OnViewDestroyed(View* view) OVERRIDE {
     std::set<Id>::iterator it = views_->find(view->id());
     if (it != views_->end())
       views_->erase(it);
     if (CanQuit())
       QuitRunLoop();
   }
 
   bool CanQuit() {
     return (!nodes_ || nodes_->empty()) && (!views_ || views_->empty());
   }
@@ skipping 30 matching lines @@
     node_->AddObserver(this);
   }
   virtual ~OrderChangeObserver() {
     node_->RemoveObserver(this);
   }
 
  private:
   // Overridden from NodeObserver:
   virtual void OnNodeReordered(Node* node,
                                Node* relative_node,
-                               OrderDirection direction,
-                               DispositionChangePhase phase) OVERRIDE {
-    if (phase != NodeObserver::DISPOSITION_CHANGED)
-      return;
-
+                               OrderDirection direction) OVERRIDE {
     DCHECK_EQ(node, node_);
     QuitRunLoop();
   }
 
   Node* node_;
 
   DISALLOW_COPY_AND_ASSIGN(OrderChangeObserver);
 };
 
 void WaitForOrderChange(ViewManager* view_manager, Node* node) {
   OrderChangeObserver observer(node);
   DoRunLoop();
 }
 
 // Tracks a node's destruction. Query is_valid() for current state.
 class NodeTracker : public NodeObserver {
  public:
   explicit NodeTracker(Node* node) : node_(node) {
     node_->AddObserver(this);
   }
   virtual ~NodeTracker() {
     if (node_)
       node_->RemoveObserver(this);
   }
 
   bool is_valid() const { return !!node_; }
 
  private:
   // Overridden from NodeObserver:
-  virtual void OnNodeDestroy(
-      Node* node,
-      NodeObserver::DispositionChangePhase phase) OVERRIDE {
-    if (phase != NodeObserver::DISPOSITION_CHANGED)
-      return;
+  virtual void OnNodeDestroyed(Node* node) OVERRIDE {
     DCHECK_EQ(node, node_);
     node_ = NULL;
   }
 
   int id_;
   Node* node_;
 
   DISALLOW_COPY_AND_ASSIGN(NodeTracker);
 };
 
@@ skipping 463 matching lines @@
 // TODO(beng): tests for view event dispatcher.
 // - verify that we see events for all views.
 
 // TODO(beng): tests for focus:
 // - focus between two nodes known to a connection
 // - focus between nodes unknown to one of the connections.
 // - focus between nodes unknown to either connection.
 
 }  // namespace view_manager
 }  // namespace mojo