Add ViewObserver to View for view updates

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 33 matching lines @@
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/accessibility/native_view_accessibility.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/context_menu_controller.h"
 #include "ui/views/drag_controller.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/layout/layout_manager.h"
+#include "ui/views/view_observer.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/native_widget_private.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/tooltip_manager.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_gdi_object.h"
 #include "ui/native_theme/native_theme_win.h"
 #endif
@@ skipping 149 matching lines @@
 
   if (widget) {
     RegisterChildrenForVisibleBoundsNotification(view);
 
     if (view->visible())
       view->SchedulePaint();
   }
 
   if (layout_manager_.get())
     layout_manager_->ViewAdded(this, view);
+
+  NotifyViewParentChanged(view, nullptr, this);
 }
 
 void View::ReorderChildView(View* view, int index) {
   DCHECK_EQ(view->parent_, this);
   if (index < 0)
     index = child_count() - 1;
   else if (index >= child_count())
     return;
   if (children_[index] == view)
     return;
 
   const Views::iterator i(std::find(children_.begin(), children_.end(), view));
   DCHECK(i != children_.end());
   children_.erase(i);
 
   // Unlink the view first
   View* next_focusable = view->next_focusable_view_;
   View* prev_focusable = view->previous_focusable_view_;
   if (prev_focusable)
     prev_focusable->next_focusable_view_ = next_focusable;
   if (next_focusable)
     next_focusable->previous_focusable_view_ = prev_focusable;
 
   // Add it in the specified index now.
   InitFocusSiblings(view, index);
   children_.insert(children_.begin() + index, view);
 
+  for (ViewObserver& observer : observers_)
+    observer.OnChildViewReordered(view, index);

[sky, 2016/11/21 16:33:37]

Is index really useful for this notification?

[Sarmad Hashmi, 2016/11/21 17:09:53]

Avoids looking up where the view was placed after being reordered. Removed for
now.

+
   ReorderLayers();
 }
 
 void View::RemoveChildView(View* view) {
   DoRemoveChildView(view, true, true, false, NULL);
 }
 
 void View::RemoveAllChildViews(bool delete_children) {
   while (!children_.empty())
     DoRemoveChildView(children_.front(), false, false, delete_children, NULL);
@@ skipping 31 matching lines @@
   if (visible_) {
     // Paint where the view is currently.
     SchedulePaintBoundsChanged(
         bounds_.size() == bounds.size() ? SCHEDULE_PAINT_SIZE_SAME :
         SCHEDULE_PAINT_SIZE_CHANGED);
   }
 
   gfx::Rect prev = bounds_;
   bounds_ = bounds;
   BoundsChanged(prev);
+
+  for (ViewObserver& observer : observers_)
+    observer.OnViewBoundsChanged(this);
 }
 
 void View::SetSize(const gfx::Size& size) {
   SetBounds(x(), y(), size.width(), size.height());
 }
 
 void View::SetPosition(const gfx::Point& position) {
   SetBounds(position.x(), position.y(), width(), height());
 }
 
@@ skipping 100 matching lines @@
 
     visible_ = visible;
     AdvanceFocusIfNecessary();
 
     // Notify the parent.
     if (parent_) {
       parent_->ChildVisibilityChanged(this);
       parent_->NotifyAccessibilityEvent(ui::AX_EVENT_CHILDREN_CHANGED, false);
     }
 
+    for (ViewObserver& observer : observers_)
+      observer.OnViewVisibilityChanged(this);
+
     // This notifies all sub-views recursively.
     PropagateVisibilityNotifications(this, visible_);
     UpdateLayerVisibility();
 
     // If we are newly visible, schedule paint.
     if (visible_)
       SchedulePaint();
   }
 }
 
 bool View::IsDrawn() const {
   return visible_ && parent_ ? parent_->IsDrawn() : false;
 }
 
 void View::SetEnabled(bool enabled) {
   if (enabled != enabled_) {
     enabled_ = enabled;
     AdvanceFocusIfNecessary();
+
+    for (ViewObserver& observer : observers_)
+      observer.OnViewEnabledChanged(this);

[sky, 2016/11/21 16:33:37]

I mildly favor calling this after OnEnabledChanged. That better matches other
places you're notifying observers.

[Sarmad Hashmi, 2016/11/21 17:09:53]

Done.

+
     OnEnabledChanged();
   }
 }
 
 void View::OnEnabledChanged() {
   SchedulePaint();
 }
 
 // Transformations -------------------------------------------------------------
 
@@ skipping 908 matching lines @@
 int View::GetPageScrollIncrement(ScrollView* scroll_view,
                                  bool is_horizontal, bool is_positive) {
   return 0;
 }
 
 int View::GetLineScrollIncrement(ScrollView* scroll_view,
                                  bool is_horizontal, bool is_positive) {
   return 0;
 }
 
+// Observers -------------------------------------------------------------------

[sky, 2016/11/21 16:33:37]

No need for this comment, please remove.

[Sarmad Hashmi, 2016/11/21 17:09:53]

Done.

+void View::AddObserver(ViewObserver* observer) {
+  CHECK(observer);
+  observers_.AddObserver(observer);
+}
+
+void View::RemoveObserver(ViewObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+bool View::HasObserver(const ViewObserver* observer) const {
+  return observers_.HasObserver(observer);
+}
+
+void View::NotifyViewParentChanged(View* view,
+                                   View* old_parent,
+                                   View* new_parent) {
+  for (ViewObserver& observer : observers_)
+    observer.OnViewParentChanged(view, old_parent, new_parent);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // View, protected:
 
 // Size and disposition --------------------------------------------------------
 
 void View::OnBoundsChanged(const gfx::Rect& previous_bounds) {
 }
 
 void View::PreferredSizeChanged() {
   InvalidateLayout();
@@ skipping 455 matching lines @@
   if (delete_removed_view && !view->owned_by_client_)
     view_to_be_deleted.reset(view);
 
   children_.erase(i);
 
   if (update_tool_tip)
     UpdateTooltip();
 
   if (layout_manager_)
     layout_manager_->ViewRemoved(this, view);
+
+  NotifyViewParentChanged(view, this, nullptr);

[sky, 2016/11/21 16:33:37]

DoRemoveChildView is called from AddChildView. So, notifying here is wrong in
some cases. Please add test coverage of this case, e.g. adding when a view
already has a parent.

[Sarmad Hashmi, 2016/11/21 17:09:53]

Already have this under the ViewParentChanged test.

[sky, 2016/11/21 18:32:12]

Sure, but your test is verifying the observer is called with a null parent, then
a new parent. It should ensure only one change is observed with the new parent.

 }
 
 void View::PropagateRemoveNotifications(View* old_parent, View* new_parent) {
   for (int i = 0, count = child_count(); i < count; ++i)
     child_at(i)->PropagateRemoveNotifications(old_parent, new_parent);
 
   ViewHierarchyChangedDetails details(false, old_parent, this, new_parent);
   for (View* v = this; v; v = v->parent_)
     v->ViewHierarchyChangedImpl(true, details);
 }
@@ skipping 563 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