Mojom: Blanket change to mark all pointer/handle fields as nullable.

mojo/services/public/interfaces/view_manager/view_manager.mojom

 // 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.
 
 import "mojo/public/interfaces/application/service_provider.mojom"
 import "mojo/services/public/interfaces/geometry/geometry.mojom"
 import "mojo/services/public/interfaces/input_events/input_events.mojom"
 import "mojo/services/public/interfaces/view_manager/view_manager_constants.mojom"
 
 module mojo {
 
 struct ViewData {
   uint32 parent_id;
   uint32 view_id;
-  mojo.Rect bounds;
+  mojo.Rect? bounds;
   // TODO(sky): add visible.
 };
 
 enum ErrorCode {
   NONE,
   VALUE_IN_USE,
   ILLEGAL_ARGUMENT,
 };
 
 // ViewManagerInitService is used to grant an application a connection to the
 // ViewManager by embedding it at an approriate View.
 interface ViewManagerInitService {
   // Embed the application @ |url| at an appropriate View.
   // The first time this method is called in the lifetime of a View Manager
   // application instance, the "appropriate View" is defined as being the
   // service root View.
   // Subsequent times, implementation of this method is delegated to the
   // application embedded at the service root View. This application is
   // typically referred to as the "window manager", and will have a specific
   // definition of where within its View hierarchy to embed an unparented URL.
   // See ViewManagerService below for more details about |service_provider|.
-  Embed(string url, ServiceProvider? service_provider) => (bool success);
+  Embed(string? url, ServiceProvider? service_provider) => (bool success);
 };
 
 // Views are identified by a uint32. The upper 16 bits are the connection id,
 // and the lower 16 the id assigned by the client.
 //
 // The root view is identified with a connection id of 0, and value of 1.
 [Client=ViewManagerClient]
 interface ViewManagerService {
   // Creates a new view with the specified id. It is up to the client to ensure
   // the id is unique to the connection (the id need not be globally unique).
   // Additionally the connection id (embedded in |view_id|) must match that of
   // the connection.
   // Errors:
   //   ERROR_CODE_VALUE_IN_USE: a view already exists with the specified id.
   //   ERROR_CODE_ILLEGAL_ARGUMENT: The connection part of |view_id| does not
   //     match the connection id of the client.
   CreateView(uint32 view_id) => (ErrorCode error_code);
 
   // Deletes a view. This does not recurse. No hierarchy change notifications
   // are sent as a result of this. Only the connection that created the view can
   // delete it.
   DeleteView(uint32 view_id) => (bool success);
 
   // Sets the specified bounds of the specified view.
-  SetViewBounds(uint32 view_id, mojo.Rect bounds) => (bool success);
+  SetViewBounds(uint32 view_id, mojo.Rect? bounds) => (bool success);
 
   // Sets the visibility of the specified view to |visible|. Connections are
   // allowed to change the visibility of any view they have created, as well as
   // any of their roots.
   SetViewVisibility(uint32 view_id, bool visible) => (bool success);
 
   // Reparents a view.
   // This fails for any of the following reasons:
   // . |parent| or |child| does not identify a valid view.
   // . |child| is an ancestor of |parent|.
@@ skipping 18 matching lines @@
   // Only the connection that created the view's parent can reorder its
   // children.
   ReorderView(uint32 view_id,
               uint32 relative_view_id,
               OrderDirection direction) => (bool success);
 
   // Returns the views comprising the tree starting at |view_id|. |view_id| is
   // the first result in the return value, unless |view_id| is invalid, in which
   // case an empty vector is returned. The views are visited using a depth first
   // search (pre-order).
-  GetViewTree(uint32 view_id) => (ViewData[] views);
+  GetViewTree(uint32 view_id) => (ViewData?[]? views);
 
   // Shows the specified image (png encoded) in the specified view.
   SetViewContents(uint32 view_id,
-                  handle<shared_buffer> buffer,
+                  handle<shared_buffer>? buffer,
                   uint32 buffer_size) => (bool success);
 
   // Embeds the app for |url| in the specified view. More specifically this
   // creates a new connection to the specified url, expecting to get a
   // ViewManagerClient and configures it with the root view |view|. Fails
   // if |view| was not created by this connection.
   //
   // If a particular client invokes Embed() multiple times with the same url,
   // the connection is reused. When this happens the ViewManagerClient is
   // notified of the additional roots by way of OnEmbed().
@@ skipping 11 matching lines @@
   // If |view_id| is 0, the View Manager delegates determination of what view to
   // embed |url| at to the app embedded at the service root view (i.e. the
   // window manager).
   // 
   // |service_provider| encapsulates services offered by the embedder to the
   // embedded app alongside this Embed() call. It also provides a means for
   // the embedder to connect to services symmetrically exposed by the embedded
   // app. Note that if a different app is subsequently embedded at |view_id|
   // the |service_provider|'s connection to its client in the embedded app and
   // any services it provided are not broken and continue to be valid.
-  Embed(string url,
+  Embed(string? url,
         uint32 view_id,
         ServiceProvider? service_provider) => (bool success);
 
   // TODO(sky): move these to a separate interface when FIFO works.
 
   // Sends OnViewInputEvent() to the owner of the specified view.
-  DispatchOnViewInputEvent(uint32 view_id, mojo.Event event);
+  DispatchOnViewInputEvent(uint32 view_id, mojo.Event? event);
 };
 
 // Changes to views are not sent to the connection that originated the
 // change. For example, if connection 1 changes the bounds of a view by calling
 // SetBounds(), connection 1 does not receive OnViewBoundsChanged().
 [Client=ViewManagerService]
 interface ViewManagerClient {
   // Invoked when the client application has been embedded at |root|.
   // See Embed() on ViewManagerService for more details.
   OnEmbed(uint16 connection_id,
-          string embedder_url,
-          ViewData root,
+          string? embedder_url,
+          ViewData? root,
           ServiceProvider&? service_provider);
 
   // Invoked when a view's bounds have changed.
-  OnViewBoundsChanged(uint32 view, mojo.Rect old_bounds, mojo.Rect new_bounds);
+  OnViewBoundsChanged(uint32 view,
+                      mojo.Rect? old_bounds,
+                      mojo.Rect? new_bounds);
 
   // Invoked when a change is done to the hierarchy. A value of 0 is used to
   // identify a null view. For example, if the old_parent is NULL, 0 is
   // supplied.
   // |views| contains any views that are that the client has not been told
   // about. This is not sent for hierarchy changes of views not known to this
   // client or not attached to the tree.
   OnViewHierarchyChanged(uint32 view,
                          uint32 new_parent,
                          uint32 old_parent,
-                         ViewData[] views);
+                         ViewData?[]? views);
 
   // Invoked when the order of views within a parent changes.
   OnViewReordered(uint32 view_id,
                   uint32 relative_view_id,
                   OrderDirection direction);                     
 
   // Invoked when a view is deleted.
   OnViewDeleted(uint32 view);
 
   // Invoked when an event is targeted at the specified view.
-  OnViewInputEvent(uint32 view, mojo.Event event) => ();
+  OnViewInputEvent(uint32 view, mojo.Event? event) => ();
 
   // TODO(sky): The following methods represent an interface between the view
   //            manager and the application embedded at the service root view
   //            (i.e. the window manager). These methods are not called on
   //            any other clients. They should be moved to a separate interface
   //            once support for derived FIFOs is landed.
 
   // Requests the window manager create a "top level" view embedding |url|.
-  Embed(string url, ServiceProvider&? service_provider);
+  Embed(string? url, ServiceProvider&? service_provider);
 
   // Requests the view manager dispatch the event.
-  DispatchOnViewInputEvent(mojo.Event event);
+  DispatchOnViewInputEvent(mojo.Event? event);
 };
 
 }