Communicate ExtensionSettings policy to renderers

extensions/common/extension_messages.cc

Index: extensions/common/extension_messages.cc
diff --git a/extensions/common/extension_messages.cc b/extensions/common/extension_messages.cc
index 34b15ed89879781b77bbc59636d0d0a2420a2d89..e55112f9b5c4b669d26f543ee789ce1d1deed260 100644
--- a/extensions/common/extension_messages.cc
+++ b/extensions/common/extension_messages.cc
@@ -50,6 +50,96 @@ ExtensionMsg_PermissionSetStruct::ToPermissionSet() const {
                                             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) {}
@@ -58,13 +148,20 @@ 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) {
@@ -337,6 +434,31 @@ void ParamTraits<HostID>::Log(
   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);
@@ -381,6 +503,8 @@ void ParamTraits<ExtensionMsg_Loaded_Params>::Write(base::Pickle* m,
   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,
@@ -392,7 +516,9 @@ bool ParamTraits<ExtensionMsg_Loaded_Params>::Read(const base::Pickle* m,
          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,