Mojom cpp bindings: Enable non-nullable check.

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 {
@@ skipping 16 matching lines @@
 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).
@@ skipping 81 matching lines @@
   // 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,
         uint32 view_id,
-        ServiceProvider service_provider) => (bool success);
+        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);
 };
 
 // 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,
-          ServiceProvider& service_provider);
+          ServiceProvider&? service_provider);
 
   // Invoked when a view's bounds have changed.
   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.
@@ skipping 13 matching lines @@
   // Invoked when an event is targeted at the specified view.
   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);
 };
 
 }