Reify view ownership as a message pipe.

mojo/services/ui/views/interfaces/views.mojom

 // Copyright 2015 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.
 
 [DartPackage="mojo_services"]
 module mojo.ui;
 
 import "mojo/public/interfaces/application/service_provider.mojom";
 import "mojo/services/gfx/composition/interfaces/scenes.mojom";
 import "mojo/services/ui/views/interfaces/layouts.mojom";
 
 // A view token is an opaque transferable reference to a view.
 //
 // The ViewManager provides each view with a unique view token when
 // it is registered.  The token can subsequently be passed to other
 // applications and may be used to add the view as a child of some
 // other view or to set it as the root of a view tree.
 //
 // View tokens should be kept secret and should only be shared with
 // the view's intended container.
 //
 // TODO(jeffbrown): This implementation is a temporary placeholder until
 // we extend Mojo to provide a way to create tokens which cannot be forged.
 struct ViewToken {
   uint32 value;
 };
 
+// A view owner provides access to the view's token and keeps the
+// view alive.  When the view owner is closed, the view will be
+// unregistered from the view manager.
+//
+// This interface is only intended to be implemented by the view manager
+// to obtain the desired ownership semantics.
+interface ViewOwner {
+  // Gets the |ViewToken| associated with the view.
+  GetToken() => (ViewToken token);
+};
+
 // A view is a graphical user interface component which is responsible
 // for drawing and supporting user interactions in the area of the screen
 // that it occupies.
 //
 // A view may also act as a container for other views (known as the
 // view's children) which it may freely layout and position anywhere
 // within its bounds to form a composite user interface.  The hierarchy
 // of views thus formed is called a view tree.
 //
 // A view must registered with the view manager before it can be shown.
@@ skipping 55 matching lines @@
   OnChildUnavailable(uint32 child_key) => ();
 };
 
 // The view host provides an interface for a view to configure itself and
 // interact with its local environment, such as adding and removing
 // children and specifying layout constraints.
 //
 // Each view obtains its own view host when registered with the ViewManager.
 // To unregister the view, close its view host message pipe.
 interface ViewHost {
+  // Gets the view's token.
+  GetToken() => (ViewToken token);
+
   // Gets a service provider to access services which are associated with
   // the view such as input, accessibility and editing capabilities.
   // The view service provider is private to the view and should not be
   // shared with anyone else.
   //
   // See |mojo.ui.InputConnection|.
   GetServiceProvider(mojo.ServiceProvider& service_provider);
 
   // Creates the view's scene, replacing any previous scene the view
   // might have had.
   //
   // The |scene| is used to supply content for the scene.  The scene pipe
   // is private to the scene and should not be shared with anyone else.
   //
   // To destroy the scene, simply close the |scene| message pipe.
   //
   // See also: |mojo.gfx.composition.Compositor.CreateScene()|.
   CreateScene(mojo.gfx.composition.Scene& scene);
 
   // Requests that the view's OnLayout() method be called to compute a
   // new layout due to a change in the view's layout information.
   RequestLayout();
 
-  // Adds the view referenced by |child_view_token| as a child and assigns
+  // Adds the view referenced by |child_view_owner| as a child and assigns
   // it the provided |child_key| to identify it among its children.
   // The parent may remove the child later by passing the same |child_key|
   // to RemoveChild().
   //
+  // This method takes ownership of the view.
+  //
   // It is important for the parent to choose locally unique values for
   // |child_key| to ensure that each child can be distinguished even as
   // more children are added or removed.  We recommend using a simple
   // counter which is incremented on each (re-)addition.
   //
   // If the child becomes unavailable at any time prior to being removed
   // then an OnChildUnavailable() message will be sent.
   //
-  // If |child_view_token| refers to a view which is already unavailable or
+  // If |child_view_owner| refers to a view which is already unavailable or
   // if adding the view would create a cycle in the view tree then the
   // call proceeds as if it succeeded but an OnChildUnavailable() message
   // will be sent.
   //
-  // If |child_view_token| refers to a view which already has a parent or is
+  // If |child_view_owner| refers to a view which already has a parent or is
   // the root of a view tree then an OnChildUnavailable() or OnRootUnavailable()
   // message will be sent to its old parent or root and the the view will be
   // (re-)added to its new parent as usual.  This special case also applies
   // when the specified view is already a child of this view, in which
   // case the behavior is similar to the view having been transferred to
   // some other parent and then back again.
   //
   // Note that an unavailable child will remain in its parent's list of
   // children until its parent explicitly calls RemoveChild() to remove
   // it.
   //
   // It is an error to add a view whose |child_key| already appears
   // in the view's list of children; the connection will be closed.
-  AddChild(uint32 child_key, mojo.ui.ViewToken child_view_token);
+  AddChild(uint32 child_key, mojo.ui.ViewOwner child_view_owner);
 
   // Removes the view referenced by |child_key| from the view's
   // list of children.
   //
+  // If |transferred_view_owner| is not null, associates it with the
+  // previously added child to allow it to be transferred elsewhere or
+  // closes the |transferred_view_owner| message pipe if there was none.
+  //
   // It is an error to remove a view whose |child_key| does not appear
   // in the parent's list of children; the connection will be closed.
-  RemoveChild(uint32 child_key);
+  RemoveChild(uint32 child_key, mojo.ui.ViewOwner&? transferred_view_owner);
 
   // Sets the layout parameters of the child view referenced by |child_key|
   // and retrieves its layout information.
   //
   // The returned |info| is null if this layout request was canceled either
   // because it has been superceded by a subsequently issued layout request
   // or because the child has become unavailable.
   //
   // It is an error to specify a |child_key| that does not appear in
   // the parent's list of children; the connection will be closed.
   //
   // It is an error to specify malformed |child_layout_params| such
   // as invalid size constraints; the connection will be closed.
   LayoutChild(uint32 child_key, mojo.ui.ViewLayoutParams child_layout_params)
       => (mojo.ui.ViewLayoutInfo? info);
 };