Mandoline: Implement basic "process per site" support

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 272 matching lines @@
     return;
   }
 
   const GURL app_url =
       requested_url.scheme() == "mojo" ? requested_url : fetcher->GetURL();
 
   InterfaceRequest<Application> request(
       RegisterShell(app_url, qualifier, requestor_url, services.Pass(),
                     exposed_services.Pass(), on_application_end));
 
+  // 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;
   if (fetcher->PeekContentHandler(&shebang, &content_handler_url)) {
-    LoadWithContentHandler(
-        content_handler_url, requestor_url, qualifier, request.Pass(),
-        fetcher->AsURLResponse(blocking_pool_,
-                               static_cast<int>(shebang.size())));
+    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnableMultiprocess)) {

[jam, 2015/07/09 22:32:37]

why should this behavior change with multiprocess? seems like using qualifier
and having multiple threads of html_viewer when running single process can also
work? the more similar multi-process and single-process, the easier for
testing/maintenance

+      if (!network_service_)
+        ConnectToService(GURL("mojo:network_service"), &network_service_);
+      network_service_->GetSiteForURL(
+          fetcher->GetURL().spec(),
+          base::Bind(&ApplicationManager::LoadWithContentHandler,
+                    weak_ptr_factory_.GetWeakPtr(),
+                    content_handler_url,
+                    requestor_url,
+                    base::Passed(request.Pass()),
+                    base::Passed(fetcher->AsURLResponse(blocking_pool_, 0))));
+    } else {
+      LoadWithContentHandler(
+          content_handler_url, requestor_url,
+          request.Pass(),
+          fetcher->AsURLResponse(blocking_pool_,
+                                static_cast<int>(shebang.size())),
+          qualifier);
+    }
     return;
   }
 
   MimeTypeToURLMap::iterator iter = mime_type_to_url_.find(fetcher->MimeType());
   if (iter != mime_type_to_url_.end()) {
-    LoadWithContentHandler(iter->second, requestor_url, qualifier,
-                           request.Pass(),
-                           fetcher->AsURLResponse(blocking_pool_, 0));
+    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnableMultiprocess)) {
+      if (!network_service_)
+        ConnectToService(GURL("mojo:network_service"), &network_service_);
+      network_service_->GetSiteForURL(
+          fetcher->GetURL().spec(),
+          base::Bind(&ApplicationManager::LoadWithContentHandler,
+                    weak_ptr_factory_.GetWeakPtr(),
+                    iter->second,
+                    requestor_url,
+                    base::Passed(request.Pass()),
+                    base::Passed(fetcher->AsURLResponse(blocking_pool_, 0))));
+    } else {
+      LoadWithContentHandler(
+          iter->second, requestor_url,
+          request.Pass(),
+          fetcher->AsURLResponse(blocking_pool_,
+                                static_cast<int>(shebang.size())),
+          qualifier);
+    }
     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(alias_iter->second.first, requestor_url, qualifier,
-                           request.Pass(), response.Pass());
+    LoadWithContentHandler(alias_iter->second.first, requestor_url,
+                           request.Pass(), response.Pass(), qualifier);
     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);
@@ skipping 51 matching lines @@
     const GURL& alias,
     const GURL& content_handler_package,
     const std::string& qualifier) {
   application_package_alias_[alias] =
       std::make_pair(content_handler_package, qualifier);
 }
 
 void ApplicationManager::LoadWithContentHandler(
     const GURL& content_handler_url,
     const GURL& requestor_url,
-    const std::string& qualifier,
     InterfaceRequest<Application> application_request,
-    URLResponsePtr url_response) {
+    URLResponsePtr url_response,
+    const std::string& qualifier) {
   ContentHandlerConnection* connection = nullptr;
   std::pair<GURL, std::string> key(content_handler_url, qualifier);
   URLToContentHandlerMap::iterator iter = url_to_content_handler_.find(key);
   if (iter != url_to_content_handler_.end()) {
     connection = iter->second;
   } else {
     connection = new ContentHandlerConnection(this, content_handler_url,
                                               requestor_url, qualifier);
     url_to_content_handler_[key] = connection;
   }
@@ skipping 80 matching lines @@
   return pipe.handle0.Pass();
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 }  // namespace shell
 }  // namespace mojo