Remove DispositionChangePhase.

mojo/services/public/cpp/view_manager/lib/node.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/node.h"
 
 #include "mojo/services/public/cpp/view_manager/lib/node_private.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_manager_client_impl.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_private.h"
 #include "mojo/services/public/cpp/view_manager/node_observer.h"
 #include "mojo/services/public/cpp/view_manager/view.h"
 
 namespace mojo {
 namespace view_manager {
 
 namespace {
 
 void NotifyViewTreeChangeAtReceiver(
     Node* receiver,
-    const NodeObserver::TreeChangeParams& params) {
+    const NodeObserver::TreeChangeParams& params,
+    bool change_applied) {
   NodeObserver::TreeChangeParams local_params = params;
   local_params.receiver = receiver;
-  FOR_EACH_OBSERVER(NodeObserver,
-                    *NodePrivate(receiver).observers(),
-                    OnTreeChange(local_params));
+  if (change_applied) {
+    FOR_EACH_OBSERVER(NodeObserver,
+                      *NodePrivate(receiver).observers(),
+                      OnTreeChanged(local_params));
+  } else {
+    FOR_EACH_OBSERVER(NodeObserver,
+                      *NodePrivate(receiver).observers(),
+                      OnTreeChanging(local_params));
+  }
 }
 
 void NotifyViewTreeChangeUp(
     Node* start_at,
-    const NodeObserver::TreeChangeParams& params) {
+    const NodeObserver::TreeChangeParams& params,
+    bool change_applied) {
   for (Node* current = start_at; current; current = current->parent())
-    NotifyViewTreeChangeAtReceiver(current, params);
+    NotifyViewTreeChangeAtReceiver(current, params, change_applied);
 }
 
 void NotifyViewTreeChangeDown(
     Node* start_at,
-    const NodeObserver::TreeChangeParams& params) {
-  NotifyViewTreeChangeAtReceiver(start_at, params);
+    const NodeObserver::TreeChangeParams& params,
+    bool change_applied) {
+  NotifyViewTreeChangeAtReceiver(start_at, params, change_applied);
   Node::Children::const_iterator it = start_at->children().begin();
   for (; it != start_at->children().end(); ++it)
-    NotifyViewTreeChangeDown(*it, params);
+    NotifyViewTreeChangeDown(*it, params, change_applied);
 }
 
 void NotifyViewTreeChange(
-    const NodeObserver::TreeChangeParams& params) {
-  NotifyViewTreeChangeDown(params.target, params);
+    const NodeObserver::TreeChangeParams& params,
+    bool change_applied) {
+  NotifyViewTreeChangeDown(params.target, params, change_applied);
   if (params.old_parent)
-    NotifyViewTreeChangeUp(params.old_parent, params);
+    NotifyViewTreeChangeUp(params.old_parent, params, change_applied);
   if (params.new_parent)
-    NotifyViewTreeChangeUp(params.new_parent, params);
+    NotifyViewTreeChangeUp(params.new_parent, params, change_applied);
 }
 
 class ScopedTreeNotifier {
  public:
   ScopedTreeNotifier(Node* target, Node* old_parent, Node* new_parent) {
     params_.target = target;
     params_.old_parent = old_parent;
     params_.new_parent = new_parent;
-    NotifyViewTreeChange(params_);
+    NotifyViewTreeChange(params_, false);
   }
   ~ScopedTreeNotifier() {
-    params_.phase = NodeObserver::DISPOSITION_CHANGED;
-    NotifyViewTreeChange(params_);
+    NotifyViewTreeChange(params_, true);
   }
 
  private:
   NodeObserver::TreeChangeParams params_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedTreeNotifier);
 };
 
 void RemoveChildImpl(Node* child, Node::Children* children) {
   Node::Children::iterator it =
       std::find(children->begin(), children->end(), child);
   if (it != children->end()) {
     children->erase(it);
     NodePrivate(child).ClearParent();
   }
 }
 
 class ScopedOrderChangedNotifier {
  public:
   ScopedOrderChangedNotifier(Node* node,
                              Node* relative_node,
                              OrderDirection direction)
       : node_(node),
         relative_node_(relative_node),
         direction_(direction) {
-    FOR_EACH_OBSERVER(
-        NodeObserver,
-        *NodePrivate(node_).observers(),
-        OnNodeReordered(node_,
-                        relative_node_,
-                        direction_,
-                        NodeObserver::DISPOSITION_CHANGING));
-
+    FOR_EACH_OBSERVER(NodeObserver,
+                      *NodePrivate(node_).observers(),
+                      OnNodeReordering(node_, relative_node_, direction_));
   }
   ~ScopedOrderChangedNotifier() {
-    FOR_EACH_OBSERVER(
-        NodeObserver,
-        *NodePrivate(node_).observers(),
-        OnNodeReordered(node_,
-                        relative_node_,
-                        direction_,
-                        NodeObserver::DISPOSITION_CHANGED));
+    FOR_EACH_OBSERVER(NodeObserver,
+                      *NodePrivate(node_).observers(),
+                      OnNodeReordered(node_, relative_node_, direction_));
   }
 
  private:
   Node* node_;
   Node* relative_node_;
   OrderDirection direction_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedOrderChangedNotifier);
 };
 
@@ skipping 27 matching lines @@
 
   return true;
 }
 
 class ScopedSetActiveViewNotifier {
  public:
   ScopedSetActiveViewNotifier(Node* node, View* old_view, View* new_view)
       : node_(node),
         old_view_(old_view),
         new_view_(new_view) {
-    FOR_EACH_OBSERVER(
-        NodeObserver,
-        *NodePrivate(node).observers(),
-        OnNodeActiveViewChange(node_,
-                               old_view_,
-                               new_view_,
-                               NodeObserver::DISPOSITION_CHANGING));
+    FOR_EACH_OBSERVER(NodeObserver,
+                      *NodePrivate(node).observers(),
+                      OnNodeActiveViewChanging(node_, old_view_, new_view_));
   }
   ~ScopedSetActiveViewNotifier() {
-    FOR_EACH_OBSERVER(
-        NodeObserver,
-        *NodePrivate(node_).observers(),
-        OnNodeActiveViewChange(node_,
-                               old_view_,
-                               new_view_,
-                               NodeObserver::DISPOSITION_CHANGED));
+    FOR_EACH_OBSERVER(NodeObserver,
+                      *NodePrivate(node_).observers(),
+                      OnNodeActiveViewChanged(node_, old_view_, new_view_));
   }
 
  private:
   Node* node_;
   View* old_view_;
   View* new_view_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedSetActiveViewNotifier);
 };
 
 class ScopedSetBoundsNotifier {
  public:
   ScopedSetBoundsNotifier(Node* node,
                           const gfx::Rect& old_bounds,
                           const gfx::Rect& new_bounds)
       : node_(node),
         old_bounds_(old_bounds),
         new_bounds_(new_bounds) {
-    FOR_EACH_OBSERVER(
-        NodeObserver,
-        *NodePrivate(node_).observers(),
-        OnNodeBoundsChange(node_,
-                           old_bounds_,
-                           new_bounds_,
-                           NodeObserver::DISPOSITION_CHANGING));
+    FOR_EACH_OBSERVER(NodeObserver,
+                      *NodePrivate(node_).observers(),
+                      OnNodeBoundsChanging(node_, old_bounds_, new_bounds_));
   }
   ~ScopedSetBoundsNotifier() {
-    FOR_EACH_OBSERVER(
-        NodeObserver,
-        *NodePrivate(node_).observers(),
-        OnNodeBoundsChange(node_,
-                           old_bounds_,
-                           new_bounds_,
-                           NodeObserver::DISPOSITION_CHANGED));
+    FOR_EACH_OBSERVER(NodeObserver,
+                      *NodePrivate(node_).observers(),
+                      OnNodeBoundsChanged(node_, old_bounds_, new_bounds_));
   }
 
  private:
   Node* node_;
   const gfx::Rect old_bounds_;
   const gfx::Rect new_bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedSetBoundsNotifier);
 };
 
 class ScopedDestructionNotifier {
  public:
   explicit ScopedDestructionNotifier(Node* node)
       : node_(node) {
-    FOR_EACH_OBSERVER(
-        NodeObserver,
-        *NodePrivate(node_).observers(),
-        OnNodeDestroy(node_, NodeObserver::DISPOSITION_CHANGING));
+    FOR_EACH_OBSERVER(NodeObserver,
+                      *NodePrivate(node_).observers(),
+                      OnNodeDestroying(node_));
   }
   ~ScopedDestructionNotifier() {
-    FOR_EACH_OBSERVER(
-        NodeObserver,
-        *NodePrivate(node_).observers(),
-        OnNodeDestroy(node_, NodeObserver::DISPOSITION_CHANGED));
+    FOR_EACH_OBSERVER(NodeObserver,
+                      *NodePrivate(node_).observers(),
+                      OnNodeDestroyed(node_));
   }
 
  private:
   Node* node_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedDestructionNotifier);
 };
 
 // Some operations are only permitted in the connection that created the node.
 bool OwnsNode(ViewManager* manager, Node* node) {
@@ skipping 191 matching lines @@
 
 void Node::LocalSetBounds(const gfx::Rect& old_bounds,
                           const gfx::Rect& new_bounds) {
   DCHECK(old_bounds == bounds_);
   ScopedSetBoundsNotifier notifier(this, old_bounds, new_bounds);
   bounds_ = new_bounds;
 }
 
 }  // namespace view_manager
 }  // namespace mojo