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();
 }
 
 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,
     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))) {
+          connect_callback, GetLoaderForURL(mapped_url))) {
     return;
   }
 
   if (ConnectToApplicationWithLoader(
           originator, requested_gurl, qualifier, resolved_url, requestor_url,
           &services, &exposed_services, filter, on_application_end,
-          GetLoaderForURL(resolved_url))) {
+          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())) {
+          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);
+      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);
   return true;
 }
 
 bool ApplicationManager::ConnectToApplicationWithLoader(
     ApplicationInstance* originator,
     const GURL& requested_url,
     const std::string& qualifier,
     const GURL& resolved_url,
     const GURL& requestor_url,
     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));
+                       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,
     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, Shell::kInvalidContentHandlerID, 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);
+                            exposed_services.Pass(), filter, connect_callback);
+  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,
     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(Shell::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);
+                         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();
 
+  ApplicationInstance* app = nullptr;
   InterfaceRequest<Application> request(
       RegisterInstance(originator, app_url, qualifier, requestor_url,
                        services.Pass(), exposed_services.Pass(), filter,
-                       on_application_end));
+                       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(Shell::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;
   }
 
+  app->set_requesting_content_handler_id(connection->id());
   connection->content_handler()->StartApplication(application_request.Pass(),
                                                   url_response.Pass());
+  connect_callback.Run(connection->id());
 }
 
 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 61 matching lines @@
 }
 
 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());
+                       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