Changes view manager to report visibility and drawn state

mojo/services/view_manager/view_manager_service_impl.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/view_manager/view_manager_service_impl.h"
 
 #include "base/bind.h"
 #include "mojo/services/public/cpp/geometry/geometry_type_converters.h"
 #include "mojo/services/public/cpp/input_events/input_events_type_converters.h"
 #include "mojo/services/view_manager/connection_manager.h"
@@ skipping 63 matching lines @@
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds,
     bool originated_change) {
   if (originated_change || !IsViewKnown(view))
     return;
   client()->OnViewBoundsChanged(ViewIdToTransportId(view->id()),
                                 Rect::From(old_bounds),
                                 Rect::From(new_bounds));
 }
 
+void ViewManagerServiceImpl::ProcessWillChangeViewHierarchy(
+    const ServerView* view,
+    const ServerView* new_parent,
+    const ServerView* old_parent,
+    bool originated_change) {
+  if (originated_change)
+    return;
+
+  const bool old_drawn = view->IsDrawn(connection_manager_->root());
+  const bool new_drawn = view->visible() && new_parent &&
+      new_parent->IsDrawn(connection_manager_->root());
+  if (old_drawn == new_drawn)
+    return;
+
+  NotifyDrawnStateChanged(view, new_drawn);
+}
+
 void ViewManagerServiceImpl::ProcessViewHierarchyChanged(
     const ServerView* view,
     const ServerView* new_parent,
     const ServerView* old_parent,
     bool originated_change) {
   if (originated_change && !IsViewKnown(view) && new_parent &&
       IsViewKnown(new_parent)) {
     std::vector<const ServerView*> unused;
     GetUnknownViewsFrom(view, &unused);
   }
@@ skipping 41 matching lines @@
 
   if (originated_change)
     return;
 
   if (in_known) {
     client()->OnViewDeleted(ViewIdToTransportId(view));
     connection_manager_->OnConnectionMessagedClient(id_);
   }
 }
 
+void ViewManagerServiceImpl::ProcessWillChangeViewVisibility(
+    const ServerView* view,
+    bool originated_change) {
+  if (originated_change)
+    return;
+
+  if (IsViewKnown(view)) {
+    client()->OnViewVisibilityChanged(ViewIdToTransportId(view->id()),
+                                      !view->visible());
+    return;
+  }
+
+  bool view_target_drawn_state;
+  if (view->visible()) {
+    // View is being hidden, won't be drawn.
+    view_target_drawn_state = false;
+  } else {
+    // View is being shown. View will be drawn if its parent is drawn.
+    view_target_drawn_state =
+        view->parent() && view->parent()->IsDrawn(connection_manager_->root());
+  }
+
+  NotifyDrawnStateChanged(view, view_target_drawn_state);
+}
+
 void ViewManagerServiceImpl::OnConnectionError() {
   if (delete_on_connection_error_)
     delete this;
 }
 
 bool ViewManagerServiceImpl::IsViewKnown(const ServerView* view) const {
   return known_views_.count(ViewIdToTransportId(view->id())) > 0;
 }
 
 bool ViewManagerServiceImpl::CanReorderView(const ServerView* view,
@@ skipping 102 matching lines @@
   DCHECK(IsViewKnown(view));
   const ServerView* parent = view->parent();
   // If the parent isn't known, it means the parent is not visible to us (not
   // in roots), and should not be sent over.
   if (parent && !IsViewKnown(parent))
     parent = NULL;
   ViewDataPtr view_data(ViewData::New());
   view_data->parent_id = ViewIdToTransportId(parent ? parent->id() : ViewId());
   view_data->view_id = ViewIdToTransportId(view->id());
   view_data->bounds = Rect::From(view->bounds());
+  view_data->visible = view->visible();
+  view_data->drawn = view->IsDrawn(connection_manager_->root());
   return view_data.Pass();
 }
 
 void ViewManagerServiceImpl::GetViewTreeImpl(
     const ServerView* view,
     std::vector<const ServerView*>* views) const {
   DCHECK(view);
 
   if (!access_policy_->CanGetViewTree(view))
     return;
 
   views->push_back(view);
 
   if (!access_policy_->CanDescendIntoViewForViewTree(view))
     return;
 
   std::vector<const ServerView*> children(view->GetChildren());
   for (size_t i = 0 ; i < children.size(); ++i)
     GetViewTreeImpl(children[i], views);
 }
 
+void ViewManagerServiceImpl::NotifyDrawnStateChanged(const ServerView* view,
+                                                     bool new_drawn_value) {
+  // Even though we don't know about view, it may be an ancestor of one of our
+  // roots, in which case the change may effect our roots drawn state.
+  for (ViewIdSet::iterator i = roots_.begin(); i != roots_.end(); ++i) {
+    const ServerView* root = GetView(ViewIdFromTransportId(*i));
+    DCHECK(root);
+    if (view->Contains(root) &&
+        (new_drawn_value != root->IsDrawn(connection_manager_->root()))) {
+      client()->OnViewDrawnStateChanged(ViewIdToTransportId(root->id()),
+                                        new_drawn_value);
+    }
+  }
+}
+
 void ViewManagerServiceImpl::CreateView(
     Id transport_view_id,
     const Callback<void(ErrorCode)>& callback) {
   const ViewId view_id(ViewIdFromTransportId(transport_view_id));
   ErrorCode error_code = ERROR_CODE_NONE;
   if (view_id.connection_id != id_) {
     error_code = ERROR_CODE_ILLEGAL_ARGUMENT;
   } else if (view_map_.find(view_id.view_id) != view_map_.end()) {
     error_code = ERROR_CODE_VALUE_IN_USE;
   } else {
@@ skipping 109 matching lines @@
     view->SetBounds(bounds.To<gfx::Rect>());
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::SetViewVisibility(
     Id transport_view_id,
     bool visible,
     const Callback<void(bool)>& callback) {
   ServerView* view = GetView(ViewIdFromTransportId(transport_view_id));
-  const bool success = view && view->visible() != visible &&
-                       access_policy_->CanChangeViewVisibility(view);
-  if (success) {
-    DCHECK(view);
+  if (!view || view->visible() == visible ||
+      !access_policy_->CanChangeViewVisibility(view)) {
+    callback.Run(false);
+    return;
+  }
+  {
+    ConnectionManager::ScopedChange change(this, connection_manager_, false);
     view->SetVisible(visible);
   }
-  // TODO(sky): need to notify of visibility changes.
-  callback.Run(success);
+  callback.Run(true);
 }
 
 void ViewManagerServiceImpl::Embed(
     const String& url,
     Id transport_view_id,
     ServiceProviderPtr service_provider,
     const Callback<void(bool)>& callback) {
   InterfaceRequest<ServiceProvider> spir;
   spir.Bind(service_provider.PassMessagePipe());
 
@@ skipping 72 matching lines @@
 
 bool ViewManagerServiceImpl::IsViewRootOfAnotherConnectionForAccessPolicy(
     const ServerView* view) const {
   ViewManagerServiceImpl* connection =
       connection_manager_->GetConnectionWithRoot(view->id());
   return connection && connection != this;
 }
 
 }  // namespace service
 }  // namespace mojo