Adds a way to determine id of content handler that created app

mojo/shell/application_manager.cc

Index: mojo/shell/application_manager.cc
diff --git a/mojo/shell/application_manager.cc b/mojo/shell/application_manager.cc
index 782163c9a4c8814291190669bb41e3664e47953e..71c5de47af7bde2fa8c9d6f6e185599d544aaed0 100644
--- a/mojo/shell/application_manager.cc
+++ b/mojo/shell/application_manager.cc
@@ -30,6 +30,8 @@ namespace {
 // Used by TestAPI.
 bool has_created_instance = false;
 
+void OnEmptyOnConnectCallback(uint32_t content_handler_id) {}
+
 }  // namespace
 
 // static
@@ -50,9 +52,14 @@ bool ApplicationManager::TestAPI::HasRunningInstanceForURL(
          manager_->identity_to_instance_.end();
 }
 
+// static
+const uint32_t ApplicationManager::kInvalidContentHandlerID = 0u;
+
 ApplicationManager::ApplicationManager(Delegate* delegate)
-    : delegate_(delegate), weak_ptr_factory_(this) {
-}
+    : delegate_(delegate),
+      disable_cache_(false),
+      content_handler_id_counter_(0u),
+      weak_ptr_factory_(this) {}
 
 ApplicationManager::~ApplicationManager() {
   URLToContentHandlerMap url_to_content_handler(url_to_content_handler_);
@@ -72,10 +79,12 @@ void ApplicationManager::ConnectToApplication(
     mojo::URLRequestPtr requested_url,
     const std::string& qualifier,
     const GURL& requestor_url,
+    uint32_t requesting_content_handler_id,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
     const CapabilityFilter& filter,
-    const base::Closure& on_application_end) {
+    const base::Closure& on_application_end,
+    const Shell::ConnectToApplicationCallback& connect_callback) {
   GURL requested_gurl(requested_url->url.To<std::string>());
   TRACE_EVENT_INSTANT1(
       "mojo_shell", "ApplicationManager::ConnectToApplication",
@@ -87,45 +96,47 @@ void ApplicationManager::ConnectToApplication(
 
   GURL mapped_url = delegate_->ResolveMappings(requested_gurl);
   if (ConnectToRunningApplication(originator, mapped_url, qualifier,
-                                  requestor_url, &services,
-                                  &exposed_services, filter)) {
+                                  requestor_url, &services, &exposed_services,
+                                  filter, connect_callback)) {
     return;
   }
 
   GURL resolved_url = delegate_->ResolveMojoURL(mapped_url);
   if (ConnectToRunningApplication(originator, resolved_url, qualifier,
-                                  requestor_url, &services,
-                                  &exposed_services, filter)) {
+                                  requestor_url, &services, &exposed_services,
+                                  filter, connect_callback)) {
     return;
   }
 
   // The application is not running, let's compute the parameters.
   if (ConnectToApplicationWithLoader(
           originator, requested_gurl, qualifier, mapped_url, requestor_url,
-          &services, &exposed_services, filter, on_application_end,
-          GetLoaderForURL(mapped_url))) {
+          requesting_content_handler_id, &services, &exposed_services, filter,
+          on_application_end, connect_callback, GetLoaderForURL(mapped_url))) {
     return;
   }
 
   if (ConnectToApplicationWithLoader(
           originator, requested_gurl, qualifier, resolved_url, requestor_url,
-          &services, &exposed_services, filter, on_application_end,
+          requesting_content_handler_id, &services, &exposed_services, filter,
+          on_application_end, connect_callback,
           GetLoaderForURL(resolved_url))) {
     return;
   }
 
   if (ConnectToApplicationWithLoader(
           originator, requested_gurl, qualifier, resolved_url, requestor_url,
-          &services, &exposed_services, filter, on_application_end,
-          default_loader_.get())) {
+          requesting_content_handler_id, &services, &exposed_services, filter,
+          on_application_end, connect_callback, default_loader_.get())) {
     return;
   }
 
   auto callback = base::Bind(
       &ApplicationManager::HandleFetchCallback, weak_ptr_factory_.GetWeakPtr(),
       originator, requested_gurl, qualifier, requestor_url,
-      base::Passed(services.Pass()), base::Passed(exposed_services.Pass()),
-      filter, on_application_end);
+      requesting_content_handler_id, base::Passed(services.Pass()),
+      base::Passed(exposed_services.Pass()), filter, on_application_end,
+      connect_callback);
 
   if (delegate_->CreateFetcher(
           resolved_url,
@@ -185,15 +196,16 @@ bool ApplicationManager::ConnectToRunningApplication(
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider>* services,
     ServiceProviderPtr* exposed_services,
-    const CapabilityFilter& filter) {
+    const CapabilityFilter& filter,
+    const Shell::ConnectToApplicationCallback& connect_callback) {
   ApplicationInstance* instance =
       GetApplicationInstance(Identity(resolved_url, qualifier));
   if (!instance)
     return false;
 
   instance->ConnectToClient(originator, resolved_url, requestor_url,
-                            services->Pass(), exposed_services->Pass(),
-                            filter);
+                            services->Pass(), exposed_services->Pass(), filter);
+  connect_callback.Run(instance->requesting_content_handler_id());
   return true;
 }
 
@@ -203,10 +215,12 @@ bool ApplicationManager::ConnectToApplicationWithLoader(
     const std::string& qualifier,
     const GURL& resolved_url,
     const GURL& requestor_url,
+    uint32_t requesting_content_handler_id,
     InterfaceRequest<ServiceProvider>* services,
     ServiceProviderPtr* exposed_services,
     const CapabilityFilter& filter,
     const base::Closure& on_application_end,
+    const Shell::ConnectToApplicationCallback& connect_callback,
     ApplicationLoader* loader) {
   if (!loader)
     return false;
@@ -214,11 +228,11 @@ bool ApplicationManager::ConnectToApplicationWithLoader(
   const GURL app_url =
       requested_url.SchemeIs("mojo") ? requested_url : resolved_url;
 
-  loader->Load(
-      resolved_url,
-      RegisterInstance(originator, app_url, qualifier, requestor_url,
-                       services->Pass(), exposed_services->Pass(),
-                       filter, on_application_end));
+  loader->Load(resolved_url,
+               RegisterInstance(originator, app_url, qualifier, requestor_url,
+                                requesting_content_handler_id, services->Pass(),
+                                exposed_services->Pass(), filter,
+                                on_application_end, connect_callback, nullptr));
   return true;
 }
 
@@ -227,10 +241,13 @@ InterfaceRequest<Application> ApplicationManager::RegisterInstance(
     const GURL& app_url,
     const std::string& qualifier,
     const GURL& requestor_url,
+    const uint32_t requesting_content_handler_id,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
     const CapabilityFilter& filter,
-    const base::Closure& on_application_end) {
+    const base::Closure& on_application_end,
+    const Shell::ConnectToApplicationCallback& connect_callback,
+    ApplicationInstance** resulting_instance) {
   Identity app_identity(app_url, qualifier);
 
   ApplicationPtr application;
@@ -238,13 +255,16 @@ InterfaceRequest<Application> ApplicationManager::RegisterInstance(
   ApplicationInstance* instance = new ApplicationInstance(
       application.Pass(), this,
       originator ? originator->identity() : Identity(GURL()), app_identity,
-      filter, on_application_end);
+      filter, requesting_content_handler_id, on_application_end);
   DCHECK(identity_to_instance_.find(app_identity) ==
          identity_to_instance_.end());
   identity_to_instance_[app_identity] = instance;
   instance->InitializeApplication();
   instance->ConnectToClient(originator, app_url, requestor_url, services.Pass(),
                             exposed_services.Pass(), filter);
+  connect_callback.Run(kInvalidContentHandlerID);

[Ben Goodger (Google), 2015/08/31 17:41:07]

Specifically I'm trying to understand the flow of this content handler id. Why
if a content handler id is passed do you call this callback with invalid id?

[sky, 2015/08/31 19:46:07]

Ya, this code is a bit cryptic. The key places that enabled the id are
ApplicationManager::LoadWithContentHandler, which is called to start a new
application loaded from a content handler. In that case the callback is run with
the id of the content handler. The other place is if the app already exists, in
which case we have to supply the id used at the time of creation of the app.
That code is ConnectToRunningApplication.

Much of the code for content handlers is done in HandleFetchCallback. As
AppInstance is actually created before we make the decision as to whether the
app is going to be loaded by a content handler HandleFetchCallback supplies a
callback to RegisterInstance() that does nothing. It's only once we know the app
is going to be loaded by a content handler that the real callback is called.
RegisterInstance() is called from a number of different code paths though, and
it simplifies things to have this run the callback too.

+  if (resulting_instance)
+    *resulting_instance = instance;
   return application_request.Pass();
 }
 
@@ -261,14 +281,17 @@ void ApplicationManager::HandleFetchCallback(
     const GURL& requested_url,
     const std::string& qualifier,
     const GURL& requestor_url,
+    uint32_t requesting_content_handler_id,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
     const CapabilityFilter& filter,
     const base::Closure& on_application_end,
+    const Shell::ConnectToApplicationCallback& connect_callback,
     NativeApplicationCleanup cleanup,
     scoped_ptr<Fetcher> fetcher) {
   if (!fetcher) {
     // Network error. Drop |application_request| to tell requestor.
+    connect_callback.Run(kInvalidContentHandlerID);
     return;
   }
 
@@ -283,8 +306,9 @@ void ApplicationManager::HandleFetchCallback(
     header->value = fetcher->GetRedirectReferer().spec();
     request->headers.push_back(header.Pass());
     ConnectToApplication(originator, request.Pass(), qualifier, requestor_url,
-                         services.Pass(), exposed_services.Pass(), filter,
-                         on_application_end);
+                         requesting_content_handler_id, services.Pass(),
+                         exposed_services.Pass(), filter, on_application_end,
+                         connect_callback);
     return;
   }
 
@@ -295,18 +319,19 @@ void ApplicationManager::HandleFetchCallback(
   // Also, it's possible the original URL was redirected to an app that is
   // already running.
   if (ConnectToRunningApplication(originator, requested_url, qualifier,
-                                  requestor_url, &services,
-                                  &exposed_services, filter)) {
+                                  requestor_url, &services, &exposed_services,
+                                  filter, connect_callback)) {
     return;
   }
 
   const GURL app_url =
       requested_url.scheme() == "mojo" ? requested_url : fetcher->GetURL();
 
-  InterfaceRequest<Application> request(
-      RegisterInstance(originator, app_url, qualifier, requestor_url,
-                       services.Pass(), exposed_services.Pass(), filter,
-                       on_application_end));
+  ApplicationInstance* app = nullptr;
+  InterfaceRequest<Application> request(RegisterInstance(
+      originator, app_url, qualifier, requestor_url,
+      requesting_content_handler_id, services.Pass(), exposed_services.Pass(),
+      filter, on_application_end, EmptyConnectCallback(), &app));
 
   // For resources that are loaded with content handlers, we group app instances
   // by site.
@@ -323,7 +348,8 @@ void ApplicationManager::HandleFetchCallback(
     std::string site =
         enable_multi_process ? response->site.To<std::string>() : std::string();
     LoadWithContentHandler(originator, content_handler_url, requestor_url, site,
-                           filter, request.Pass(), response.Pass());
+                           filter, connect_callback, app, request.Pass(),
+                           response.Pass());
     return;
   }
 
@@ -333,7 +359,8 @@ void ApplicationManager::HandleFetchCallback(
     std::string site =
         enable_multi_process ? response->site.To<std::string>() : std::string();
     LoadWithContentHandler(originator, iter->second, requestor_url, site,
-                           filter, request.Pass(), response.Pass());
+                           filter, connect_callback, app, request.Pass(),
+                           response.Pass());
     return;
   }
 
@@ -359,8 +386,8 @@ void ApplicationManager::HandleFetchCallback(
     }
 
     LoadWithContentHandler(originator, alias_iter->second.first, requestor_url,
-                           qualifier, filter, request.Pass(),
-                           response.Pass());
+                           qualifier, filter, connect_callback, app,
+                           request.Pass(), response.Pass());
     return;
   }
 
@@ -390,6 +417,8 @@ void ApplicationManager::HandleFetchCallback(
       start_sandboxed = true;
   }
 
+  connect_callback.Run(kInvalidContentHandlerID);
+
   fetcher->AsPath(blocking_pool_,
                   base::Bind(&ApplicationManager::RunNativeApplication,
                              weak_ptr_factory_.GetWeakPtr(),
@@ -447,6 +476,8 @@ void ApplicationManager::LoadWithContentHandler(
     const GURL& requestor_url,
     const std::string& qualifier,
     const CapabilityFilter& filter,
+    const Shell::ConnectToApplicationCallback& connect_callback,
+    ApplicationInstance* app,
     InterfaceRequest<Application> application_request,
     URLResponsePtr url_response) {
   ContentHandlerConnection* connection = nullptr;
@@ -458,13 +489,16 @@ void ApplicationManager::LoadWithContentHandler(
     connection = iter->second;
   } else {
     connection = new ContentHandlerConnection(
-        originator, this, content_handler_url, requestor_url, qualifier,
-        filter);
+        originator, this, content_handler_url, requestor_url, qualifier, filter,
+        ++content_handler_id_counter_);
     url_to_content_handler_[key] = connection;
   }
 
+  // TODO(sky): this isn't right if there is a nested content handler.
+  app->set_requesting_content_handler_id(connection->id());
   connection->content_handler()->StartApplication(application_request.Pass(),
                                                   url_response.Pass());
+  connection->ScheduleTargetIdCallback(connect_callback);
 }
 
 void ApplicationManager::SetLoaderForURL(scoped_ptr<ApplicationLoader> loader,
@@ -545,12 +579,17 @@ ScopedMessagePipeHandle ApplicationManager::ConnectToServiceByName(
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From(application_url.spec());
   ConnectToApplication(nullptr, request.Pass(), std::string(), GURL(),
-                       GetProxy(&services), nullptr,
-                       GetPermissiveCapabilityFilter(), base::Closure());
+                       kInvalidContentHandlerID, GetProxy(&services), nullptr,
+                       GetPermissiveCapabilityFilter(), base::Closure(),
+                       EmptyConnectCallback());
   MessagePipe pipe;
   services->ConnectToService(interface_name, pipe.handle1.Pass());
   return pipe.handle0.Pass();
 }
 
+Shell::ConnectToApplicationCallback EmptyConnectCallback() {
+  return base::Bind(&OnEmptyOnConnectCallback);
+}
+
 }  // namespace shell
 }  // namespace mojo