Allow shared modules to whitelist extensions that import them.

extensions/common/manifest_handlers/shared_module_info.cc

 // Copyright 2013 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 "extensions/common/manifest_handlers/shared_module_info.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 66 matching lines @@
 }
 
 // static
 bool SharedModuleInfo::IsExportAllowed(const Extension* extension,
                                        const std::string& relative_path) {
   return GetSharedModuleInfo(extension).
       exported_set_.MatchesURL(extension->url().Resolve(relative_path));
 }
 
 // static
+bool SharedModuleInfo::IsExportAllowedByWhitelist(const Extension* extension,
+                                                  const std::string& other_id) {
+  const SharedModuleInfo& info = GetSharedModuleInfo(extension);
+  if (info.export_whitelist_.empty())
+    return true;
+  if (info.export_whitelist_.find(other_id) != info.export_whitelist_.end())
+    return true;
+  return false;
+}
+
+// static
 bool SharedModuleInfo::ImportsExtensionById(const Extension* extension,
                                             const std::string& other_id) {
   const SharedModuleInfo& info = GetSharedModuleInfo(extension);
   for (size_t i = 0; i < info.imports_.size(); i++) {
     if (info.imports_[i].extension_id == other_id)
       return true;
   }
   return false;
 }
 
@@ skipping 24 matching lines @@
     const base::DictionaryValue* export_value = NULL;
     if (!extension->manifest()->GetDictionary(keys::kExport, &export_value)) {
       *error = base::ASCIIToUTF16(errors::kInvalidExport);
       return false;
     }
     const base::ListValue* resources_list = NULL;
     if (!export_value->GetList(keys::kResources, &resources_list)) {
       *error = base::ASCIIToUTF16(errors::kInvalidExportResources);
       return false;
     }
+    if (export_value->HasKey(keys::kWhitelist)) {
+      const base::ListValue* whitelist = NULL;
+      if (!export_value->GetList(keys::kWhitelist, &whitelist)) {
+        *error = base::ASCIIToUTF16(errors::kInvalidExportWhitelist);
+        return false;
+      }
+      for (size_t i = 0; i < whitelist->GetSize(); ++i) {
+        std::string extension_id;
+        if (!whitelist->GetString(i, &extension_id) ||
+            !Extension::IdIsValid(extension_id)) {
+          *error = ErrorUtils::FormatErrorMessageUTF16(
+              errors::kInvalidExportWhitelistString, base::IntToString(i));
+          return false;
+        }
+        export_whitelist_.insert(extension_id);
+      }
+    }
     for (size_t i = 0; i < resources_list->GetSize(); ++i) {
       std::string resource_path;
       if (!resources_list->GetString(i, &resource_path)) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidExportResourcesString, base::IntToString(i));
         return false;
       }
       const GURL& resolved_path = extension->url().Resolve(resource_path);
       if (!resolved_path.is_valid()) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
@@ skipping 78 matching lines @@
 
 const std::vector<std::string> SharedModuleHandler::Keys() const {
   static const char* keys[] = {
     keys::kExport,
     keys::kImport
   };
   return std::vector<std::string>(keys, keys + arraysize(keys));
 }
 
 }  // namespace extensions