Basic multi-module support

chrome/browser/extensions/extension_protocols.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/extension_protocols.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/image_loader.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/csp_handler.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/incognito_handler.h"
 #include "chrome/common/extensions/manifest_handlers/icons_handler.h"
+#include "chrome/common/extensions/manifest_handlers/shared_module_info.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/extensions/web_accessible_resources_handler.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/resource_request_info.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_resource.h"
 #include "googleurl/src/url_util.h"
 #include "grit/component_extension_resources_map.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_file_job.h"
 #include "net/url_request/url_request_simple_job.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::ResourceRequestInfo;
 using extensions::Extension;
+using extensions::SharedModuleInfo;
 
 namespace {
 
 net::HttpResponseHeaders* BuildHttpHeaders(
     const std::string& content_security_policy, bool send_cors_header) {
   std::string raw_headers;
   raw_headers.append("HTTP/1.1 200 OK");
   if (!content_security_policy.empty()) {
     raw_headers.append(1, '\0');
     raw_headers.append("Content-Security-Policy: ");
@@ skipping 140 matching lines @@
                           base::FilePath* file_path) {
   *file_path = resource.GetFilePath();
 }
 
 class URLRequestExtensionJob : public net::URLRequestFileJob {
  public:
   URLRequestExtensionJob(net::URLRequest* request,
                          net::NetworkDelegate* network_delegate,
                          const std::string& extension_id,
                          const base::FilePath& directory_path,
+                         const base::FilePath& relative_path,
                          const std::string& content_security_policy,
                          bool send_cors_header)
     : net::URLRequestFileJob(request, network_delegate, base::FilePath()),
       // TODO(tc): Move all of these files into resources.pak so we don't break
       // when updating on Linux.
-      resource_(extension_id, directory_path,
-                extension_file_util::ExtensionURLToRelativeFilePath(
-                    request->url())),
+      resource_(extension_id, directory_path, relative_path),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
       response_info_.headers = BuildHttpHeaders(content_security_policy,
                                                 send_cors_header);
   }
 
   virtual void GetResponseInfo(net::HttpResponseInfo* info) OVERRIDE {
     *info = response_info_;
   }
 
   virtual void Start() OVERRIDE {
@@ skipping 155 matching lines @@
   const bool is_incognito_;
   ExtensionInfoMap* const extension_info_map_;
   DISALLOW_COPY_AND_ASSIGN(ExtensionProtocolHandler);
 };
 
 // Creates URLRequestJobs for extension:// URLs.
 net::URLRequestJob*
 ExtensionProtocolHandler::MaybeCreateJob(
     net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
   // chrome-extension://extension-id/resource/path.js
-  const std::string& extension_id = request->url().host();
+  std::string extension_id = request->url().host();
   const Extension* extension =
       extension_info_map_->extensions().GetByID(extension_id);
 
   // TODO(mpcomplete): better error code.
   if (!AllowExtensionResourceLoad(
            request, is_incognito_, extension, extension_info_map_)) {
     return new net::URLRequestErrorJob(
         request, network_delegate, net::ERR_ADDRESS_UNREACHABLE);
   }
 
@@ skipping 53 matching lines @@
       return new URLRequestResourceBundleJob(
           request,
           network_delegate,
           relative_path,
           resource_id,
           content_security_policy,
           send_cors_header);
     }
   }
 
+  relative_path =
+      extension_file_util::ExtensionURLToRelativeFilePath(request->url());
+
+  if (SharedModuleInfo::IsImportedPath(path)) {
+    std::string new_extension_id;
+    std::string new_relative_path;
+    SharedModuleInfo::ParseImportedPath(path, &new_extension_id,
+                                        &new_relative_path);
+    const Extension* new_extension =
+        extension_info_map_->extensions().GetByID(new_extension_id);
+
+    bool first_party_in_import = false;
+    // NB: This first_party_for_cookies call is not for security, it is only
+    // used so an exported extension can limit the visible surface to the
+    // extension that imports it, more or less constituting its API.
+    const std::string& first_party_path =
+        request->first_party_for_cookies().path();
+    if (SharedModuleInfo::IsImportedPath(first_party_path)) {
+      std::string first_party_id;
+      std::string dummy;
+      SharedModuleInfo::ParseImportedPath(first_party_path, &first_party_id,
+                                          &dummy);
+      if (first_party_id == new_extension_id) {
+        first_party_in_import = true;
+      }
+    }
+
+    if (SharedModuleInfo::ImportsExtensionById(extension, new_extension_id) &&
+        new_extension &&
+        (first_party_in_import ||
+         SharedModuleInfo::IsExportAllowed(new_extension, new_relative_path))) {
+      directory_path = new_extension->path();
+      extension_id = new_extension_id;
+      relative_path = base::FilePath(new_relative_path);
+    } else {
+      return NULL;
+    }
+  }
+
   return new URLRequestExtensionJob(request,
                                     network_delegate,
                                     extension_id,
                                     directory_path,
+                                    relative_path,
                                     content_security_policy,
                                     send_cors_header);
 }
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler* CreateExtensionProtocolHandler(
     bool is_incognito,
     ExtensionInfoMap* extension_info_map) {
   return new ExtensionProtocolHandler(is_incognito, extension_info_map);
 }