Update mojo sdk to rev 3d23dae011859a2aae49f1d1adde705c8e85d819

third_party/mojo_services/src/view_manager/public/cpp/lib/view.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 "view_manager/public/cpp/view.h"
 
 #include <set>
 #include <string>
 
 #include "mojo/public/cpp/application/service_provider_impl.h"
@@ skipping 59 matching lines @@
     params_.new_parent = new_parent;
     NotifyViewTreeChange(params_, false);
   }
   ~ScopedTreeNotifier() {
     NotifyViewTreeChange(params_, true);
   }
 
  private:
   ViewObserver::TreeChangeParams params_;
 
-  DISALLOW_COPY_AND_ASSIGN(ScopedTreeNotifier);
+  MOJO_DISALLOW_COPY_AND_ASSIGN(ScopedTreeNotifier);
 };
 
 void RemoveChildImpl(View* child, View::Children* children) {
   View::Children::iterator it =
       std::find(children->begin(), children->end(), child);
   if (it != children->end()) {
     children->erase(it);
     ViewPrivate(child).ClearParent();
   }
 }
@@ skipping 14 matching lines @@
     FOR_EACH_OBSERVER(ViewObserver,
                       *ViewPrivate(view_).observers(),
                       OnViewReordered(view_, relative_view_, direction_));
   }
 
  private:
   View* view_;
   View* relative_view_;
   OrderDirection direction_;
 
-  DISALLOW_COPY_AND_ASSIGN(ScopedOrderChangedNotifier);
+  MOJO_DISALLOW_COPY_AND_ASSIGN(ScopedOrderChangedNotifier);
 };
 
 // Returns true if the order actually changed.
 bool ReorderImpl(View::Children* children,
                  View* view,
                  View* relative,
                  OrderDirection direction) {
   DCHECK(relative);
   DCHECK_NE(view, relative);
   DCHECK_EQ(view->parent(), relative->parent());
@@ skipping 35 matching lines @@
     FOR_EACH_OBSERVER(ViewObserver,
                       *ViewPrivate(view_).observers(),
                       OnViewBoundsChanged(view_, old_bounds_, new_bounds_));
   }
 
  private:
   View* view_;
   const Rect old_bounds_;
   const Rect new_bounds_;
 
-  DISALLOW_COPY_AND_ASSIGN(ScopedSetBoundsNotifier);
+  MOJO_DISALLOW_COPY_AND_ASSIGN(ScopedSetBoundsNotifier);
 };
 
 // Some operations are only permitted in the connection that created the view.
 bool OwnsView(ViewManager* manager, View* view) {
   return !manager ||
       static_cast<ViewManagerClientImpl*>(manager)->OwnsView(view->id());
 }
 
 }  // namespace
 
@@ skipping 31 matching lines @@
     static_cast<ViewManagerClientImpl*>(manager_)->SetBounds(id_, bounds);
   LocalSetBounds(bounds_, bounds);
 }
 
 void View::SetVisible(bool value) {
   if (visible_ == value)
     return;
 
   if (manager_)
     static_cast<ViewManagerClientImpl*>(manager_)->SetVisible(id_, value);
-  FOR_EACH_OBSERVER(ViewObserver, observers_, OnViewVisibilityChanging(this));
-  visible_ = value;
-  NotifyViewVisibilityChanged(this);
+  LocalSetVisible(value);
 }
 
 void View::SetSharedProperty(const std::string& name,
                              const std::vector<uint8_t>* value) {
   std::vector<uint8_t> old_value;
   std::vector<uint8_t>* old_value_ptr = nullptr;
   auto it = properties_.find(name);
   if (it != properties_.end()) {
     old_value = it->second;
     old_value_ptr = &old_value;
@@ skipping 288 matching lines @@
   // notification is the value of IsDrawn() is really changing.
   if (IsDrawn() == value) {
     drawn_ = value;
     return;
   }
   FOR_EACH_OBSERVER(ViewObserver, observers_, OnViewDrawnChanging(this));
   drawn_ = value;
   FOR_EACH_OBSERVER(ViewObserver, observers_, OnViewDrawnChanged(this));
 }
 
+void View::LocalSetVisible(bool visible) {
+  if (visible_ == visible)
+    return;
+
+  FOR_EACH_OBSERVER(ViewObserver, observers_, OnViewVisibilityChanging(this));
+  visible_ = visible;
+  NotifyViewVisibilityChanged(this);
+}
+
 void View::NotifyViewVisibilityChanged(View* target) {
   if (!NotifyViewVisibilityChangedDown(target)) {
     return; // |this| has been deleted.
   }
   NotifyViewVisibilityChangedUp(target);
 }
 
 bool View::NotifyViewVisibilityChangedAtReceiver(View* target) {
   // |this| may be deleted during a call to OnViewVisibilityChanged() on one
   // of the observers. We create an local observer for that. In that case we
@@ skipping 29 matching lines @@
 void View::NotifyViewVisibilityChangedUp(View* target) {
   // Start with the parent as we already notified |this|
   // in NotifyViewVisibilityChangedDown.
   for (View* view = parent(); view; view = view->parent()) {
     bool ret = view->NotifyViewVisibilityChangedAtReceiver(target);
     DCHECK(ret);
   }
 }
 
 }  // namespace mojo