Add View::AddedToWidget and RemovedFromWidget.

ui/views/view.cc

 // Copyright (c) 2012 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.
 
 #define _USE_MATH_DEFINES // For VC++ to get M_PI. This has to be first.
 
 #include "ui/views/view.h"
 
 #include <algorithm>
 #include <cmath>
@@ skipping 178 matching lines @@
 }
 
 void View::AddChildViewAt(View* view, int index) {
   CHECK_NE(view, this) << "You cannot add a view as its own child";
   DCHECK_GE(index, 0);
   DCHECK_LE(index, child_count());
 
   // If |view| has a parent, remove it from its parent.
   View* parent = view->parent_;
   ui::NativeTheme* old_theme = NULL;
+  Widget* old_widget = NULL;
   if (parent) {
     old_theme = view->GetNativeTheme();
+    old_widget = view->GetWidget();
     if (parent == this) {
       ReorderChildView(view, index);
       return;
     }
     parent->DoRemoveChildView(view, true, true, false, this);
   }
 
   // Sets the prev/next focus views.
   InitFocusSiblings(view, index);
 
@@ skipping 30 matching lines @@
   for (View* v = this; v; v = v->parent_)
     v->ViewHierarchyChangedImpl(false, details);
 
   view->PropagateAddNotifications(details);
 
   UpdateTooltip();
 
   if (widget) {
     RegisterChildrenForVisibleBoundsNotification(view);
 
+    if (widget != old_widget)
+      view->PropagateAddedToWidget();

[sky, 2017/02/27 16:46:54]

I would like to avoid more tree walking. Can't you incorporate the additional
notification in ViewHierarchyChangedImpl?

[msimonides, 2017/02/28 10:07:27]

Ok.
I will merge PropagateAddedToWidget into PropagateAddNotifications and
PropagateRemovedFromWidget into PropagateRemoveNotifications.
Calling the notifications from ViewHierarchyChangedImpl would require more
complex argument passing (widget added, widget removed, widget not changed).

Alternatively, ViewHierarchyChangedDetails could be extended with the
information about widget change. I think this would be overly complex but I can
do this if you wish.

[sky, 2017/02/28 17:35:33]

That's fine. These are implementation details of Views.
I agree. I prefer separate functions for subclasses.

[msimonides, 2017/03/01 10:31:52]

Done.

+
     if (view->visible())
       view->SchedulePaint();
   }
 
   if (layout_manager_.get())
     layout_manager_->ViewAdded(this, view);
 
   for (ViewObserver& observer : observers_)
     observer.OnChildViewAdded(view);
 }
@@ skipping 1248 matching lines @@
 void View::NativeViewHierarchyChanged() {
   FocusManager* focus_manager = GetFocusManager();
   if (accelerator_focus_manager_ != focus_manager) {
     UnregisterAccelerators(true);
 
     if (focus_manager)
       RegisterPendingAccelerators();
   }
 }
 
+void View::AddedToWidget() {}
+
+void View::RemovedFromWidget() {}
+
 // Painting --------------------------------------------------------------------
 
 void View::PaintChildren(const ui::PaintContext& context) {
   TRACE_EVENT1("views", "View::PaintChildren", "class", GetClassName());
   View::Views children = GetChildrenInZOrder();
   DCHECK_EQ(child_count(), static_cast<int>(children.size()));
   for (auto* child : children) {
     if (!child->layer())
       child->Paint(context);
   }
@@ skipping 398 matching lines @@
     if (next_focusable)
       next_focusable->previous_focusable_view_ = prev_focusable;
   }
 
   Widget* widget = GetWidget();
   if (widget) {
     UnregisterChildrenForVisibleBoundsNotification(view);
     if (view->visible())
       view->SchedulePaint();
 
-    if (!new_parent || new_parent->GetWidget() != widget)
+    if (!new_parent || new_parent->GetWidget() != widget) {
       widget->NotifyWillRemoveView(view);
+      view->PropagateRemovedFromWidget();
+    }
   }
 
   // Make sure the layers belonging to the subtree rooted at |view| get
   // removed.
   view->OrphanLayers();
   if (widget)
     widget->LayerTreeChanged();
 
   view->PropagateRemoveNotifications(this, new_parent);
   view->parent_ = nullptr;
@@ skipping 71 matching lines @@
     return;
 
   {
     internal::ScopedChildrenLock lock(this);
     for (auto* child : children_)
       child->PropagateNativeThemeChanged(theme);
   }
   OnNativeThemeChanged(theme);
 }
 
+void View::PropagateAddedToWidget() {
+  {
+    internal::ScopedChildrenLock lock(this);
+    for (auto* child : children_)
+      child->PropagateAddedToWidget();
+  }
+  AddedToWidget();
+}
+
+void View::PropagateRemovedFromWidget() {
+  {
+    internal::ScopedChildrenLock lock(this);
+    for (auto* child : children_)
+      child->PropagateRemovedFromWidget();
+  }
+  RemovedFromWidget();
+}
+
 // Size and disposition --------------------------------------------------------
 
 void View::PropagateVisibilityNotifications(View* start, bool is_visible) {
   {
     internal::ScopedChildrenLock lock(this);
     for (auto* child : children_)
       child->PropagateVisibilityNotifications(start, is_visible);
   }
   VisibilityChangedImpl(start, is_visible);
 }
@@ skipping 511 matching lines @@
   // Message the RootView to do the drag and drop. That way if we're removed
   // the RootView can detect it and avoid calling us back.
   gfx::Point widget_location(event.location());
   ConvertPointToWidget(this, &widget_location);
   widget->RunShellDrag(this, data, widget_location, drag_operations, source);
   // WARNING: we may have been deleted.
   return true;
 }
 
 }  // namespace views