Makes content handlers see requestor url

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 17 matching lines @@
 
 // Used by TestAPI.
 bool has_created_instance = false;
 
 }  // namespace
 
 class ApplicationManager::ContentHandlerConnection : public ErrorHandler {
  public:
   ContentHandlerConnection(ApplicationManager* manager,
                            const GURL& content_handler_url,
+                           const GURL& requestor_url,
                            const std::string& qualifier)
       : manager_(manager),
         content_handler_url_(content_handler_url),
         content_handler_qualifier_(qualifier) {
     ServiceProviderPtr services;
     manager->ConnectToApplicationWithParameters(
-        content_handler_url, qualifier, GURL(), GetProxy(&services), nullptr,
-        base::Closure(), std::vector<std::string>());
+        content_handler_url, qualifier, requestor_url, GetProxy(&services),
+        nullptr, base::Closure(), std::vector<std::string>());
     MessagePipe pipe;
     content_handler_.Bind(pipe.handle0.Pass());
     services->ConnectToService(ContentHandler::Name_, pipe.handle1.Pass());
     content_handler_.set_error_handler(this);
   }
 
   ContentHandler* content_handler() { return content_handler_.get(); }
 
   GURL content_handler_url() { return content_handler_url_; }
   std::string content_handler_qualifier() { return content_handler_qualifier_; }
@@ skipping 102 matching lines @@
           default_loader_.get())) {
     return;
   }
 
   auto callback = base::Bind(
       &ApplicationManager::HandleFetchCallback, weak_ptr_factory_.GetWeakPtr(),
       requested_url, qualifier, requestor_url, base::Passed(services.Pass()),
       base::Passed(exposed_services.Pass()), on_application_end,
       pre_redirect_parameters);
 
+  if (delegate_->CreateFetcher(
+          resolved_url,
+          base::Bind(callback, NativeApplicationCleanup::DONT_DELETE))) {
+    return;
+  }
+
   if (resolved_url.SchemeIsFile()) {
     new LocalFetcher(
         resolved_url, GetBaseURLAndQuery(resolved_url, nullptr),
         base::Bind(callback, NativeApplicationCleanup::DONT_DELETE));
     return;
   }
 
   if (!network_service_)
     ConnectToService(GURL("mojo:network_service"), &network_service_);
 
@@ skipping 126 matching lines @@
 
   InterfaceRequest<Application> request(
       RegisterShell(app_url, qualifier, requestor_url, services.Pass(),
                     exposed_services.Pass(), on_application_end, parameters));
 
   // 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, qualifier, request.Pass(),
+        content_handler_url, requestor_url, qualifier, request.Pass(),
         fetcher->AsURLResponse(blocking_pool_,
                                static_cast<int>(shebang.size())));
     return;
   }
 
   MimeTypeToURLMap::iterator iter = mime_type_to_url_.find(fetcher->MimeType());
   if (iter != mime_type_to_url_.end()) {
-    LoadWithContentHandler(iter->second, qualifier, request.Pass(),
+    LoadWithContentHandler(iter->second, requestor_url, qualifier,
+                           request.Pass(),
                            fetcher->AsURLResponse(blocking_pool_, 0));
     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 ApplicationRunnerChromium 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, qualifier, request.Pass(),
-                           response.Pass());
+    LoadWithContentHandler(alias_iter->second.first, requestor_url, qualifier,
+                           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);
@@ skipping 50 matching lines @@
 void ApplicationManager::RegisterApplicationPackageAlias(
     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) {
   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, qualifier);
+    connection = new ContentHandlerConnection(this, content_handler_url,
+                                              requestor_url, qualifier);
     url_to_content_handler_[key] = connection;
   }
 
   connection->content_handler()->StartApplication(application_request.Pass(),
                                                   url_response.Pass());
 }
 
 void ApplicationManager::SetLoaderForURL(scoped_ptr<ApplicationLoader> loader,
                                          const GURL& url) {
   URLToLoaderMap::iterator it = url_to_loader_.find(url);
@@ skipping 71 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