Communicate ExtensionSettings policy to renderers

extensions/common/extension_messages.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 "extensions/common/extension_messages.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 32 matching lines @@
 
 ExtensionMsg_PermissionSetStruct::~ExtensionMsg_PermissionSetStruct() {
 }
 
 std::unique_ptr<const PermissionSet>
 ExtensionMsg_PermissionSetStruct::ToPermissionSet() const {
   return base::WrapUnique(new PermissionSet(apis, manifest_permissions,
                                             explicit_hosts, scriptable_hosts));
 }
 
+ExtensionMsg_RuntimeBlockedAllowedHostsStruct::
+    ExtensionMsg_RuntimeBlockedAllowedHostsStruct() {}
+
+ExtensionMsg_RuntimeBlockedAllowedHostsStruct::
+    ExtensionMsg_RuntimeBlockedAllowedHostsStruct(
+        const extensions::URLPatternSet& runtime_blocked_hosts,
+        const extensions::URLPatternSet& runtime_allowed_hosts,
+        const base::ProcessHandle host) {
+  auto pickle_urlpatternset = [](
+      base::Pickle& pickle, const extensions::URLPatternSet& pattern_list) {

[dcheng, 2017/01/04 19:38:16]

Chromium style does not permit mutable reference parameters.

[nrpeter, 2017/01/19 01:50:45]

Done.

+    pickle.WriteUInt32(pattern_list.patterns().size());
+    for (URLPatternSet::const_iterator pattern = pattern_list.begin();
+         pattern != pattern_list.end(); ++pattern) {
+      pickle.WriteInt(pattern->valid_schemes());
+      pickle.WriteString(pattern->GetAsString());
+    }
+  };
+
+  base::Pickle pickle;
+
+  pickle_urlpatternset(pickle, runtime_blocked_hosts);
+  pickle_urlpatternset(pickle, runtime_allowed_hosts);
+
+  size_t alloc_size = pickle.size();
+  base::SharedMemoryCreateOptions options;
+  base::SharedMemory shared_memory;
+  options.size = alloc_size;
+  options.share_read_only = true;
+
+  if (!shared_memory.Create(options)) {
+    LOG(ERROR) << "Cannot create shared memory buffer";
+    hosts = base::SharedMemory::NULLHandle();
+    return;
+  }
+  if (!shared_memory.Map(alloc_size)) {
+    LOG(ERROR) << "Cannot map shared memory buffer to populate";
+    hosts = base::SharedMemory::NULLHandle();
+  }
+  memcpy(shared_memory.memory(), pickle.data(), alloc_size);
+  if (!shared_memory.ShareReadOnlyToProcess(host, &hosts)) {
+    LOG(ERROR) << "Cannot share memory buffer to renderer";
+    hosts = base::SharedMemory::NULLHandle();
+  }
+}
+
+ExtensionMsg_RuntimeBlockedAllowedHostsStruct::
+    ExtensionMsg_RuntimeBlockedAllowedHostsStruct(
+        const ExtensionMsg_RuntimeBlockedAllowedHostsStruct& other) = default;
+
+void ExtensionMsg_RuntimeBlockedAllowedHostsStruct::Unpickle(
+    extensions::URLPatternSet* runtime_blocked_hosts,
+    extensions::URLPatternSet* runtime_allowed_hosts) const {
+  auto unpickle_urlpatternset = [](URLPatternSet* pattern_list,
+                                   base::PickleIterator* iter) {
+    uint32_t num_patterns = 0;
+    CHECK(iter->ReadUInt32(&num_patterns));

[zmin, 2016/12/22 22:15:39]

Again, CHECK is a very strong assertion. It means Chrome will crash if it
failed. Do we have to shutdown Chrome here if this failed?

[nrpeter, 2017/01/19 01:50:45]

Done.

+    pattern_list->ClearPatterns();
+    for (uint32_t i = 0; i < num_patterns; ++i) {
+      int valid_schemes;
+      CHECK(iter->ReadInt(&valid_schemes));
+      std::string pattern_str;
+      CHECK(iter->ReadString(&pattern_str));
+      URLPattern pattern(valid_schemes);
+      URLPattern::ParseResult result = pattern.Parse(pattern_str);
+      CHECK(URLPattern::PARSE_SUCCESS == result)
+          << URLPattern::GetParseResultString(result) << " "
+          << pattern_str.c_str();
+      pattern_list->AddPattern(pattern);
+    }
+  };
+
+  base::SharedMemory shared_memory(hosts, true);
+
+  shared_memory.Map(sizeof(base::Pickle::Header));
+  base::Pickle::Header* pickle_header =
+      reinterpret_cast<base::Pickle::Header*>(shared_memory.memory());
+  int pickle_size = sizeof(base::Pickle::Header) + pickle_header->payload_size;
+  shared_memory.Unmap();
+  shared_memory.Map(pickle_size);
+
+  base::Pickle pickle(reinterpret_cast<char*>(shared_memory.memory()),
+                      pickle_size);
+  base::PickleIterator iter(pickle);
+  unpickle_urlpatternset(runtime_blocked_hosts, &iter);
+  unpickle_urlpatternset(runtime_allowed_hosts, &iter);
+}
+
+ExtensionMsg_RuntimeBlockedAllowedHostsStruct::
+    ~ExtensionMsg_RuntimeBlockedAllowedHostsStruct() {}
+
 ExtensionMsg_Loaded_Params::ExtensionMsg_Loaded_Params()
     : location(Manifest::INVALID_LOCATION),
       creation_flags(Extension::NO_FLAGS) {}
 
 ExtensionMsg_Loaded_Params::~ExtensionMsg_Loaded_Params() {}
 
 ExtensionMsg_Loaded_Params::ExtensionMsg_Loaded_Params(
     const Extension* extension,
-    bool include_tab_permissions)
+    bool include_tab_permissions,
+    const base::ProcessHandle handle)
     : manifest(extension->manifest()->value()->DeepCopy()),
       location(extension->location()),
       path(extension->path()),
       active_permissions(extension->permissions_data()->active_permissions()),
-      withheld_permissions(extension->permissions_data()
-                               ->withheld_permissions()),
+      withheld_permissions(
+          extension->permissions_data()->withheld_permissions()),
+      hosts(ExtensionMsg_RuntimeBlockedAllowedHostsStruct(
+          extension->permissions_data()->runtime_blocked_hosts(),
+          extension->permissions_data()->runtime_allowed_hosts(),
+          handle)),
+      is_default_runtime_blocked_allowed_hosts(
+          extension->permissions_data()->IsRuntimeBlockedAllowedHostsDefault()),
       id(extension->id()),
       creation_flags(extension->creation_flags()) {
   if (include_tab_permissions) {
     for (const auto& pair :
          extension->permissions_data()->tab_specific_permissions()) {
       tab_specific_permissions[pair.first] =
           ExtensionMsg_PermissionSetStruct(*pair.second);
     }
   }
 }
@@ skipping 252 matching lines @@
   *r = HostID(type, id);
   return true;
 }
 
 void ParamTraits<HostID>::Log(
     const param_type& p, std::string* l) {
   LogParam(p.type(), l);
   LogParam(p.id(), l);
 }
 
+void ParamTraits<ExtensionMsg_RuntimeBlockedAllowedHostsStruct>::GetSize(
+    base::PickleSizer* s,
+    const param_type& p) {
+  GetParamSize(s, p.hosts);
+}
+
+void ParamTraits<ExtensionMsg_RuntimeBlockedAllowedHostsStruct>::Write(
+    base::Pickle* m,
+    const param_type& p) {
+  WriteParam(m, p.hosts);
+}
+
+bool ParamTraits<ExtensionMsg_RuntimeBlockedAllowedHostsStruct>::Read(
+    const base::Pickle* m,
+    base::PickleIterator* iter,
+    param_type* p) {
+  return ReadParam(m, iter, &p->hosts);
+}
+
+void ParamTraits<ExtensionMsg_RuntimeBlockedAllowedHostsStruct>::Log(
+    const param_type& p,
+    std::string* l) {
+  LogParam(p.hosts, l);
+}
+
 void ParamTraits<ExtensionMsg_PermissionSetStruct>::GetSize(
     base::PickleSizer* s, const param_type& p) {
   GetParamSize(s, p.apis);
   GetParamSize(s, p.manifest_permissions);
   GetParamSize(s, p.explicit_hosts);
   GetParamSize(s, p.scriptable_hosts);
 }
 
 void ParamTraits<ExtensionMsg_PermissionSetStruct>::Write(base::Pickle* m,
                                                           const param_type& p) {
@@ skipping 24 matching lines @@
 void ParamTraits<ExtensionMsg_Loaded_Params>::Write(base::Pickle* m,
                                                     const param_type& p) {
   WriteParam(m, p.location);
   WriteParam(m, p.path);
   WriteParam(m, *(p.manifest));
   WriteParam(m, p.creation_flags);
   WriteParam(m, p.id);
   WriteParam(m, p.active_permissions);
   WriteParam(m, p.withheld_permissions);
   WriteParam(m, p.tab_specific_permissions);
+  WriteParam(m, p.hosts);
+  WriteParam(m, p.is_default_runtime_blocked_allowed_hosts);
 }
 
 bool ParamTraits<ExtensionMsg_Loaded_Params>::Read(const base::Pickle* m,
                                                    base::PickleIterator* iter,
                                                    param_type* p) {
   p->manifest.reset(new base::DictionaryValue());
   return ReadParam(m, iter, &p->location) && ReadParam(m, iter, &p->path) &&
          ReadParam(m, iter, p->manifest.get()) &&
          ReadParam(m, iter, &p->creation_flags) && ReadParam(m, iter, &p->id) &&
          ReadParam(m, iter, &p->active_permissions) &&
          ReadParam(m, iter, &p->withheld_permissions) &&
-         ReadParam(m, iter, &p->tab_specific_permissions);
+         ReadParam(m, iter, &p->tab_specific_permissions) &&
+         ReadParam(m, iter, &p->hosts) &&
+         ReadParam(m, iter, &p->is_default_runtime_blocked_allowed_hosts);
 }
 
 void ParamTraits<ExtensionMsg_Loaded_Params>::Log(const param_type& p,
                                                   std::string* l) {
   l->append(p.id);
 }
 
 }  // namespace IPC