Communicate ExtensionSettings policy to renderers

extensions/browser/renderer_startup_helper.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/browser/renderer_startup_helper.h"
 
 #include "base/values.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/extension_function_dispatcher.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/guest_view/web_view/web_view_guest.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/extensions_client.h"
 #include "extensions/common/features/feature_channel.h"
 #include "extensions/common/features/feature_session_type.h"
+#include "extensions/common/permissions/permissions_data.h"
+#include "ipc/ipc_message_attachment_set.h"
 #include "ui/base/webui/web_ui_util.h"
 
 using content::BrowserContext;
 
 namespace extensions {
 
 RendererStartupHelper::RendererStartupHelper(BrowserContext* browser_context)
     : browser_context_(browser_context) {
   DCHECK(browser_context);
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
@@ skipping 53 matching lines @@
       extensions::ExtensionsClient::Get()->GetScriptingWhitelist()));
 
   // If the new render process is a WebView guest process, propagate the WebView
   // partition ID to it.
   std::string webview_partition_id = WebViewGuest::GetPartitionID(process);
   if (!webview_partition_id.empty()) {
     process->Send(new ExtensionMsg_SetWebViewPartitionID(
         WebViewGuest::GetPartitionID(process)));
   }
 
+  // Load default runtime_blocked_hosts and runtime_allowed_hosts settings, part
+  // of the ExtensionSettings policy.
+  ExtensionMsg_RuntimeBlockedAllowedHostsStruct params(
+      PermissionsData::default_runtime_blocked_hosts(),
+      PermissionsData::default_runtime_allowed_hosts(), process->GetHandle());
+  process->Send(new ExtensionMsg_UpdateDefaultAllowedAndBlockedHosts(params));
+
   // Loaded extensions.
   std::vector<ExtensionMsg_Loaded_Params> loaded_extensions;
   const ExtensionSet& extensions =
       ExtensionRegistry::Get(browser_context_)->enabled_extensions();
   for (const auto& ext : extensions) {
     // Renderers don't need to know about themes.
     if (!ext->is_theme()) {
       // TODO(kalman): Only include tab specific permissions for extension
       // processes, no other process needs it, so it's mildly wasteful.
       // I am not sure this is possible to know this here, at such a low
       // level of the stack. Perhaps site isolation can help.
       bool include_tab_permissions = true;
-      loaded_extensions.push_back(
-          ExtensionMsg_Loaded_Params(ext.get(), include_tab_permissions));
+      loaded_extensions.push_back(ExtensionMsg_Loaded_Params(
+          ext.get(), include_tab_permissions, process->GetHandle()));
     }
+#if defined(OS_POSIX)
+    if (loaded_extensions.size() ==
+        IPC::MessageAttachmentSet::kMaxDescriptorsPerMessage) {
+      process->Send(new ExtensionMsg_Loaded(loaded_extensions));
+      loaded_extensions.clear();
+    }
+#endif
   }
-  process->Send(new ExtensionMsg_Loaded(loaded_extensions));
+  if (loaded_extensions.size() > 0) {
+    process->Send(new ExtensionMsg_Loaded(loaded_extensions));
+  }
   auto iter = pending_active_extensions_.find(process);
   if (iter != pending_active_extensions_.end()) {
     for (const ExtensionId& id : iter->second) {
       DCHECK(extensions.Contains(id));
       process->Send(new ExtensionMsg_ActivateExtension(id));
     }
   }
 
   initialized_processes_.insert(process);
 }
@@ skipping 26 matching lines @@
 
 void RendererStartupHelper::OnExtensionLoaded(const Extension& extension) {
   // Renderers don't need to know about themes.
   if (extension.is_theme())
     return;
 
   // We don't need to include tab permisisons here, since the extension
   // was just loaded.
   // Uninitialized renderers will be informed of the extension load during the
   // first batch of messages.
-  std::vector<ExtensionMsg_Loaded_Params> params(
-      1,
-      ExtensionMsg_Loaded_Params(&extension, false /* no tab permissions */));
-  for (content::RenderProcessHost* process : initialized_processes_)
+  for (content::RenderProcessHost* process : initialized_processes_) {
+    std::vector<ExtensionMsg_Loaded_Params> params(
+        1,
+        ExtensionMsg_Loaded_Params(&extension, false /* no tab permissions */,
+                                   process->GetHandle()));
     process->Send(new ExtensionMsg_Loaded(params));
+  }
 }
 
 void RendererStartupHelper::OnExtensionUnloaded(const Extension& extension) {
   // Renderers don't need to know about themes.
   if (extension.is_theme())
     return;
 
   for (content::RenderProcessHost* process : initialized_processes_)
     process->Send(new ExtensionMsg_Unloaded(extension.id()));
   for (auto& process_extensions_pair : pending_active_extensions_)
@@ skipping 32 matching lines @@
     BrowserContext* context) const {
   // Redirected in incognito.
   return ExtensionsBrowserClient::Get()->GetOriginalContext(context);
 }
 
 bool RendererStartupHelperFactory::ServiceIsCreatedWithBrowserContext() const {
   return true;
 }
 
 }  // namespace extensions