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

mojo/shell/application_manager.cc

 // 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.
 
 #include "mojo/shell/application_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 12 matching lines @@
 #include "mojo/shell/update_fetcher.h"
 
 namespace mojo {
 namespace shell {
 
 namespace {
 
 // Used by TestAPI.
 bool has_created_instance = false;
 
+void OnEmptyOnConnectCallback(uint32_t content_handler_id) {}
+
 }  // namespace
 
 // static
 ApplicationManager::TestAPI::TestAPI(ApplicationManager* manager)
     : manager_(manager) {
 }
 
 ApplicationManager::TestAPI::~TestAPI() {
 }
 
 bool ApplicationManager::TestAPI::HasCreatedInstance() {
   return has_created_instance;
 }
 
 bool ApplicationManager::TestAPI::HasRunningInstanceForURL(
     const GURL& url) const {
   return manager_->identity_to_instance_.find(Identity(url)) !=
          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_);
   for (auto& pair : url_to_content_handler)
     pair.second->CloseConnection();
   TerminateShellConnections();
   STLDeleteValues(&url_to_loader_);
   STLDeleteValues(&scheme_to_loader_);
 }
 
 void ApplicationManager::TerminateShellConnections() {
   STLDeleteValues(&identity_to_instance_);
 }
 
 void ApplicationManager::ConnectToApplication(
     ApplicationInstance* originator,
     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",
       TRACE_EVENT_SCOPE_THREAD, "requested_url", requested_gurl.spec());
   DCHECK(requested_gurl.is_valid());
 
   // We check both the mapped and resolved urls for existing instances because
   // external applications can be registered for the unresolved mojo:foo urls.
 
   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,
           base::Bind(callback, NativeApplicationCleanup::DONT_DELETE))) {
     return;
   }
 
   if (resolved_url.SchemeIsFile()) {
     // LocalFetcher uses the network service to infer MIME types from URLs.
     // Skip this for mojo URLs to avoid recursively loading the network service.
@@ skipping 39 matching lines @@
                      url_loader_factory_.get(), base::Bind(callback, cleanup));
 }
 
 bool ApplicationManager::ConnectToRunningApplication(
     ApplicationInstance* originator,
     const GURL& resolved_url,
     const std::string& qualifier,
     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;
 }
 
 bool ApplicationManager::ConnectToApplicationWithLoader(
     ApplicationInstance* originator,
     const GURL& requested_url,
     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;
 
   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;
 }
 
 InterfaceRequest<Application> ApplicationManager::RegisterInstance(
     ApplicationInstance* originator,
     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;
   InterfaceRequest<Application> application_request = GetProxy(&application);
   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();
 }
 
 ApplicationInstance* ApplicationManager::GetApplicationInstance(
     const Identity& identity) const {
   const auto& instance_it = identity_to_instance_.find(identity);
   if (instance_it != identity_to_instance_.end())
     return instance_it->second;
   return nullptr;
 }
 
 void ApplicationManager::HandleFetchCallback(
     ApplicationInstance* originator,
     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;
   }
 
   GURL redirect_url = fetcher->GetRedirectURL();
   if (!redirect_url.is_empty()) {
     // And around we go again... Whee!
     // TODO(sky): this loses |requested_url|.
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = mojo::String::From(redirect_url.spec());
     HttpHeaderPtr header = HttpHeader::New();
     header->name = "Referer";
     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;
   }
 
   // We already checked if the application was running before we fetched it, but
   // it might have started while the fetch was outstanding. We don't want to
   // have two copies of the app running, so check again.
   //
   // 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.
 
   // If the response begins with a #!mojo <content-handler-url>, use it.
   GURL content_handler_url;
   std::string shebang;
   bool enable_multi_process = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableMultiprocess);
 
   if (fetcher->PeekContentHandler(&shebang, &content_handler_url)) {
     URLResponsePtr response(fetcher->AsURLResponse(
         blocking_pool_, static_cast<int>(shebang.size())));
     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;
   }
 
   MimeTypeToURLMap::iterator iter = mime_type_to_url_.find(fetcher->MimeType());
   if (iter != mime_type_to_url_.end()) {
     URLResponsePtr response(fetcher->AsURLResponse(blocking_pool_, 0));
     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;
   }
 
   auto alias_iter = application_package_alias_.find(app_url);
   if (alias_iter != application_package_alias_.end()) {
     // We replace the qualifier with the one our package alias requested.
     URLResponsePtr response(URLResponse::New());
     response->url = String::From(app_url.spec());
 
     std::string qualifier;
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableMultiprocess)) {
       // Why can't we use this in single process mode? Because of
       // base::AtExitManager. If you link in ApplicationRunner into
       // your code, and then we make initialize multiple copies of the
       // application, we end up with multiple AtExitManagers and will check on
       // the second one being created.
       //
       // Why doesn't that happen when running different apps? Because
       // your_thing.mojo!base::AtExitManager and
       // my_thing.mojo!base::AtExitManager are different symbols.
       qualifier = alias_iter->second.second;
     }
 
     LoadWithContentHandler(originator, alias_iter->second.first, requestor_url,
-                           qualifier, filter, request.Pass(),
-                           response.Pass());
+                           qualifier, filter, connect_callback, app,
+                           request.Pass(), response.Pass());
     return;
   }
 
   // TODO(aa): Sanity check that the thing we got looks vaguely like a mojo
   // application. That could either mean looking for the platform-specific dll
   // header, or looking for some specific mojo signature prepended to the
   // library.
   // TODO(vtl): (Maybe this should be done by the factory/runner?)
 
   GURL base_resolved_url = GetBaseURLAndQuery(fetcher->GetURL(), nullptr);
   NativeRunnerFactory::Options options;
   if (url_to_native_options_.find(base_resolved_url) !=
       url_to_native_options_.end()) {
     DVLOG(2) << "Applying stored native options to resolved URL "
              << fetcher->GetURL();
     options = url_to_native_options_[base_resolved_url];
   }
 
   // TODO(erg): Have a better way of switching the sandbox on. For now, switch
   // it on hard coded when we're using some of the sandboxable core services.
   bool start_sandboxed = false;
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kMojoNoSandbox)) {
     if (app_url == GURL("mojo://core_services/") && qualifier == "Core")
       start_sandboxed = true;
     else if (app_url == GURL("mojo://html_viewer/"))
       start_sandboxed = true;
   }
 
+  connect_callback.Run(kInvalidContentHandlerID);
+
   fetcher->AsPath(blocking_pool_,
                   base::Bind(&ApplicationManager::RunNativeApplication,
                              weak_ptr_factory_.GetWeakPtr(),
                              base::Passed(request.Pass()), start_sandboxed,
                              options, cleanup, base::Passed(fetcher.Pass())));
 }
 
 void ApplicationManager::RunNativeApplication(
     InterfaceRequest<Application> application_request,
     bool start_sandboxed,
@@ skipping 37 matching lines @@
   application_package_alias_[alias] =
       std::make_pair(content_handler_package, qualifier);
 }
 
 void ApplicationManager::LoadWithContentHandler(
     ApplicationInstance* originator,
     const GURL& content_handler_url,
     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;
   std::pair<GURL, std::string> key(content_handler_url, qualifier);
   // TODO(beng): Figure out the extent to which capability filter should be
   //             factored into handler identity.
   URLToContentHandlerMap::iterator iter = url_to_content_handler_.find(key);
   if (iter != url_to_content_handler_.end()) {
     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,
                                          const GURL& url) {
   URLToLoaderMap::iterator it = url_to_loader_.find(url);
   if (it != url_to_loader_.end())
     delete it->second;
   url_to_loader_[url] = loader.release();
 }
 
@@ skipping 60 matching lines @@
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 ScopedMessagePipeHandle ApplicationManager::ConnectToServiceByName(
     const GURL& application_url,
     const std::string& interface_name) {
   ServiceProviderPtr services;
   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