Pass the final URL an app was loaded from to the app in Initialize().

mojo/public/interfaces/application/application.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.
 
 module mojo;
 
 import "mojo/public/interfaces/application/service_provider.mojom";
 import "mojo/public/interfaces/application/shell.mojom";
 
 // This is the primary interface implemented by every Mojo application. It
 // allows the application to receive its startup arguments from the shell, and
 // to be notified of events that occur during its execution.
 interface Application {
   // Initializes the application with the specified arguments. This method is
   // guaranteed to be called before any other method is called, and will only be
-  // called once.
-  Initialize(Shell shell, array<string>? args);
+  // called once. The |url| parameter is the final url the application was found
+  // at, after all redirects and resolutions.
+  Initialize(Shell shell, string url, array<string>? args);

[sky, 2015/02/05 23:41:22]

Is there a reason we don't want to pass the url as a chain? What if there was
redirects or other things, might the urls along the path be interesting?

[Aaron Boodman, 2015/02/05 23:45:27]

I guess since we don't know the shape of the sandbox yet (origin-shaped?
url-shaped? something else?) we don't know what information makes sense to share
with the app.

And since the final URL seems like all that is needed right now, I thought it
made sense to be conservative.

[sky, 2015/02/05 23:49:51]

Doesn't the array<string> provide you with more flexibility for the future? It
can be one for now, but it's easy to make it contain more in the future.

As to the specific case, IMO we should share all and restrict that in the future
if necessary.

[Aaron Boodman, 2015/02/06 00:11:54]

AFAIK, after release, it would not be possible to restrict because interfaces
have to be backward compatible.

True, we are a long way away from that. But another reason that I prefer to just
pass the single URL is so that if there is a reason to add more of the URLs in
the future, we will find out about it and have a discussion, rather than just
silently growing dependencies on parts of an API that we weren't sure we should
have.

[Aaron Boodman, 2015/02/06 00:27:55]

With a moment more thought (and double checking with Yuzhu) I realized that
changing the type either way would not be possible without breaking backward
compat.

But it doesn't matter because we would use the ordinal system to rename the old
method to InitializeDeprecated and add a new method with the new params named
Initialize.

So moving the interface either direction -- to more permissive or less
permissive will work.

It's true that just having an array now would be less work in the future, but by
that logic we should just make all our types array<string>, or just JavaScript
:).

 
   // Called when another application (identified by |requestor_url|) attempts to
   // open a connection to this application.
   //
   // If the other application wants to request services from this application,
   // it will have passed a valid interface request through the |services|
   // parameter (i.e. one containing a valid message pipe endpoint). This
   // application may then bind an implementation of |ServiceProvider| to that
   // request in order to make services available to the other application.
   //
   // If the other application wants to offer services to this application, it
   // will have passed a bound interface through the |exposed_services|
   // parameter. This application may then request services through that
   // interface.
   //
   // It is possible that both parameters will be valid/bound if the other
   // application wants to both request services from and offer services to this
   // application.
   //
   // This application is free to ignore the |services| or |exposed_services|
   // parameters if it does not wish to offer or request services.
   AcceptConnection(string requestor_url,
                    ServiceProvider&? services,
                    ServiceProvider? exposed_services);
 
   // Called to request the application shut itself down gracefully.
   RequestQuit();
 };