Adds View::visible() and IsDrawn

mojo/services/public/cpp/view_manager/lib/view_manager_client_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/public/cpp/view_manager/lib/view_manager_client_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 13 matching lines @@
 namespace mojo {
 
 Id MakeTransportId(ConnectionSpecificId connection_id,
                    ConnectionSpecificId local_id) {
   return (connection_id << 16) | local_id;
 }
 
 // Helper called to construct a local view object from transport data.
 View* AddViewToViewManager(ViewManagerClientImpl* client,
                            View* parent,
-                           Id view_id,
-                           const gfx::Rect& bounds) {
+                           const ViewDataPtr& view_data) {
   // We don't use the ctor that takes a ViewManager here, since it will call
   // back to the service and attempt to create a new view.
   View* view = ViewPrivate::LocalCreate();
   ViewPrivate private_view(view);
   private_view.set_view_manager(client);
-  private_view.set_id(view_id);
+  private_view.set_id(view_data->view_id);
+  private_view.set_visible(view_data->visible);
+  private_view.set_drawn(view_data->drawn);
   client->AddView(view);
-  private_view.LocalSetBounds(gfx::Rect(), bounds);
+  private_view.LocalSetBounds(gfx::Rect(), view_data->bounds.To<gfx::Rect>());
   if (parent)
     ViewPrivate(parent).LocalAddChild(view);
   return view;
 }
 
 View* BuildViewTree(ViewManagerClientImpl* client,
                     const Array<ViewDataPtr>& views,
                     View* initial_parent) {
   std::vector<View*> parents;
   View* root = NULL;
   View* last_view = NULL;
   if (initial_parent)
     parents.push_back(initial_parent);
   for (size_t i = 0; i < views.size(); ++i) {
     if (last_view && views[i]->parent_id == last_view->id()) {
       parents.push_back(last_view);
     } else if (!parents.empty()) {
       while (parents.back()->id() != views[i]->parent_id)
         parents.pop_back();
     }
     View* view = AddViewToViewManager(
-        client,
-        !parents.empty() ? parents.back() : NULL,
-        views[i]->view_id,
-        views[i]->bounds.To<gfx::Rect>());
+        client, !parents.empty() ? parents.back() : NULL, views[i]);
     if (!last_view)
       root = view;
     last_view = view;
   }
   return root;
 }
 
 // Responsible for removing a root from the ViewManager when that view is
 // destroyed.
 class RootObserver : public ViewObserver {
@@ skipping 190 matching lines @@
     connected_ = true;
     connection_id_ = connection_id;
     creator_url_ = String::From(creator_url);
   } else {
     DCHECK_EQ(connection_id_, connection_id);
     DCHECK_EQ(creator_url_, creator_url);
   }
 
   // A new root must not already exist as a root or be contained by an existing
   // hierarchy visible to this view manager.
-  View* root = AddViewToViewManager(this, NULL, root_data->view_id,
-                                    root_data->bounds.To<gfx::Rect>());
+  View* root = AddViewToViewManager(this, NULL, root_data);
   roots_.push_back(root);
   root->AddObserver(new RootObserver(root));
 
   // BindToRequest() binds the lifetime of |exported_services| to the pipe.
   ServiceProviderImpl* exported_services = new ServiceProviderImpl;
   BindToRequest(exported_services, &service_provider);
   scoped_ptr<ServiceProvider> remote(
       exported_services->CreateRemoteServiceProvider());
   delegate_->OnEmbed(this, root, exported_services, remote.Pass());
 }
@@ skipping 34 matching lines @@
     ViewPrivate(view).LocalReorder(relative_view, direction);
 }
 
 void ViewManagerClientImpl::OnViewDeleted(Id view_id) {
   View* view = GetViewById(view_id);
   if (view)
     ViewPrivate(view).LocalDestroy();
 }
 
 void ViewManagerClientImpl::OnViewVisibilityChanged(Id view_id, bool visible) {
-  // TODO(sky): implement me.
-  NOTIMPLEMENTED();
+  // TODO(sky): there is a race condition here. If this client and another
+  // client change the visibility at the same time the wrong value may be set.
+  // Deal with this some how.
+  View* view = GetViewById(view_id);
+  if (view)
+    view->SetVisible(visible);
 }
 
 void ViewManagerClientImpl::OnViewDrawnStateChanged(Id view_id, bool drawn) {
-  // TODO(sky): implement me.
-  NOTIMPLEMENTED();
+  View* view = GetViewById(view_id);
+  if (view)
+    ViewPrivate(view).LocalSetDrawn(drawn);
 }
 
 void ViewManagerClientImpl::OnViewInputEvent(
     Id view_id,
     EventPtr event,
     const Callback<void()>& ack_callback) {
   View* view = GetViewById(view_id);
   if (view) {
     FOR_EACH_OBSERVER(ViewObserver,
                       *ViewPrivate(view).observers(),
@@ skipping 65 matching lines @@
                     base::Unretained(this));
 }
 
 base::Callback<void(ErrorCode)>
     ViewManagerClientImpl::ActionCompletedCallbackWithErrorCode() {
   return base::Bind(&ViewManagerClientImpl::OnActionCompletedWithErrorCode,
                     base::Unretained(this));
 }
 
 }  // namespace mojo