DNR Prototype: With flatbuffers

extensions/common/file_util.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/file_util.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
+#include "extensions/common/api/declarative_net_request/rules_indexer_util.h"
+#include "extensions/common/api/declarative_net_request/rules_manifest_info.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_icon_set.h"
 #include "extensions/common/extension_l10n_util.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/install_warning.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handler.h"
 #include "extensions/common/manifest_handlers/default_locale_handler.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
+#include "extensions/common/permissions/api_permission.h"
+#include "extensions/common/permissions/permissions_data.h"
 #include "extensions/strings/grit/extensions_strings.h"
 #include "net/base/escape.h"
 #include "net/base/filename_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 namespace extensions {
 namespace file_util {
 namespace {
 
@@ skipping 151 matching lines @@
 }
 
 scoped_refptr<Extension> LoadExtension(const base::FilePath& extension_path,
                                        const std::string& extension_id,
                                        Manifest::Location location,
                                        int flags,
                                        std::string* error) {
   std::unique_ptr<base::DictionaryValue> manifest =
       LoadManifest(extension_path, error);
   if (!manifest.get())
-    return NULL;
+    return nullptr;
   if (!extension_l10n_util::LocalizeExtension(
           extension_path, manifest.get(), error)) {
-    return NULL;
+    return nullptr;
   }
 
   scoped_refptr<Extension> extension(Extension::Create(
       extension_path, location, *manifest, flags, extension_id, error));
   if (!extension.get())
-    return NULL;
+    return nullptr;
 
   std::vector<InstallWarning> warnings;
   if (!ValidateExtension(extension.get(), error, &warnings))
-    return NULL;
+    return nullptr;
+
+  // Rulesets for unpacked extensions need to be indexed and persisted, since
+  // they don't go through the CrxInstaller.
+  if (Manifest::IsUnpackedLocation(extension->location()) &&
+      !IndexAndPersistRulesetIfNeeded(
+          extension.get(), GetIndexedRulesetPath(extension_path), error)) {
+    return nullptr;
+  }
+
   extension->AddInstallWarnings(warnings);
 
   return extension;
 }
 
 std::unique_ptr<base::DictionaryValue> LoadManifest(
     const base::FilePath& extension_path,
     std::string* error) {
   return LoadManifest(extension_path, kManifestFilename, error);
 }
 
 std::unique_ptr<base::DictionaryValue> LoadManifest(
     const base::FilePath& extension_path,
     const base::FilePath::CharType* manifest_filename,
     std::string* error) {
   base::FilePath manifest_path = extension_path.Append(manifest_filename);
   if (!base::PathExists(manifest_path)) {
     *error = l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_UNREADABLE);
-    return NULL;
+    return nullptr;
   }
 
   JSONFileValueDeserializer deserializer(manifest_path);
-  std::unique_ptr<base::Value> root(deserializer.Deserialize(NULL, error));
+  std::unique_ptr<base::Value> root(deserializer.Deserialize(nullptr, error));
   if (!root.get()) {
     if (error->empty()) {
       // If |error| is empty, than the file could not be read.
       // It would be cleaner to have the JSON reader give a specific error
       // in this case, but other code tests for a file error with
       // error->empty().  For now, be consistent.
       *error = l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_UNREADABLE);
     } else {
       *error = base::StringPrintf(
           "%s  %s", manifest_errors::kManifestParseError, error->c_str());
     }
-    return NULL;
+    return nullptr;
   }
 
   if (!root->IsType(base::Value::Type::DICTIONARY)) {
     *error = l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_INVALID);
-    return NULL;
+    return nullptr;
   }
 
   return base::DictionaryValue::From(std::move(root));
 }
 
+bool IndexAndPersistRulesetIfNeeded(const Extension* extension,
+                                    const base::FilePath& indexed_ruleset_path,
+                                    std::string* error) {
+  const base::FilePath* json_ruleset_path =
+      declarative_net_request::RulesManifestData::GetJSONRulesetPath(extension);
+  if (!json_ruleset_path)
+    return true;
+
+  DCHECK(extension->permissions_data()->HasAPIPermission(
+      APIPermission::kDeclarativeNetRequest));
+  return declarative_net_request::IndexAndPersistRuleset(
+      *json_ruleset_path, indexed_ruleset_path, error);
+}
+
 bool ValidateExtension(const Extension* extension,
                        std::string* error,
                        std::vector<InstallWarning>* warnings) {
   // Ask registered manifest handlers to validate their paths.
   if (!ManifestHandler::ValidateExtension(extension, error, warnings))
     return false;
 
   // Check children of extension root to see if any of them start with _ and is
   // not on the reserved list. We only warn, and do not block the loading of the
   // extension.
@@ skipping 54 matching lines @@
     }
 
     result.push_back(current);
   }
   return result;
 }
 
 bool CheckForIllegalFilenames(const base::FilePath& extension_path,
                               std::string* error) {
   // Reserved underscore names.
+  // TODO add kIndexedRulesetFilename, kMetadata and other?
   static const base::FilePath::CharType* reserved_names[] = {
-      kLocaleFolder, kPlatformSpecificFolder, FILE_PATH_LITERAL("__MACOSX"), };
+      kLocaleFolder, kPlatformSpecificFolder, FILE_PATH_LITERAL("__MACOSX"),
+      kIndexedRulesetFilename};
   CR_DEFINE_STATIC_LOCAL(
       std::set<base::FilePath::StringType>,
       reserved_underscore_names,
       (reserved_names, reserved_names + arraysize(reserved_names)));
 
   // Enumerate all files and directories in the extension root.
   // There is a problem when using pattern "_*" with FileEnumerator, so we have
   // to cheat with find_first_of and match all.
   const int kFilesAndDirectories =
       base::FileEnumerator::DIRECTORIES | base::FileEnumerator::FILES;
@@ skipping 121 matching lines @@
 }
 
 MessageBundle* LoadMessageBundle(
     const base::FilePath& extension_path,
     const std::string& default_locale,
     std::string* error) {
   error->clear();
   // Load locale information if available.
   base::FilePath locale_path = extension_path.Append(kLocaleFolder);
   if (!base::PathExists(locale_path))
-    return NULL;
+    return nullptr;
 
   std::set<std::string> chrome_locales;
   extension_l10n_util::GetAllLocales(&chrome_locales);
 
   base::FilePath default_locale_path = locale_path.AppendASCII(default_locale);
   if (default_locale.empty() ||
       chrome_locales.find(default_locale) == chrome_locales.end() ||
       !base::PathExists(default_locale_path)) {
     *error = l10n_util::GetStringUTF8(
         IDS_EXTENSION_LOCALES_NO_DEFAULT_LOCALE_SPECIFIED);
-    return NULL;
+    return nullptr;
   }
 
   MessageBundle* message_bundle =
       extension_l10n_util::LoadMessageCatalogs(
           locale_path,
           default_locale,
           extension_l10n_util::CurrentLocaleOrDefault(),
           error);
 
   return message_bundle;
@@ skipping 48 matching lines @@
 }
 
 base::FilePath GetVerifiedContentsPath(const base::FilePath& extension_path) {
   return extension_path.Append(kMetadataFolder)
       .Append(kVerifiedContentsFilename);
 }
 base::FilePath GetComputedHashesPath(const base::FilePath& extension_path) {
   return extension_path.Append(kMetadataFolder).Append(kComputedHashesFilename);
 }
 
+base::FilePath GetIndexedRulesetPath(const base::FilePath& extension_path) {
+  return extension_path.Append(kIndexedRulesetFilename);
+}
+
 }  // namespace file_util
 }  // namespace extensions