Communicate ExtensionSettings policy to renderers

extensions/common/extension_messages.h

 // 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.
 
 // IPC messages for extensions.
 // Multiply-included message file, hence no include guard.
 
 #include <stdint.h>
 
 #include <string>
@@ skipping 240 matching lines @@
 #define EXTENSIONS_COMMON_EXTENSION_MESSAGES_H_
 
 // IPC_MESSAGE macros choke on extra , in the std::map, when expanding. We need
 // to typedef it to avoid that.
 // Substitution map for l10n messages.
 typedef std::map<std::string, std::string> SubstitutionMap;
 
 // Map of extensions IDs to the executing script paths.
 typedef std::map<std::string, std::set<std::string> > ExecutingScriptsMap;
 
+// Define hosts extension may or may not interact with. This is used as part of
+// the ExtensionSetitngs policy. Since there is no limit to the amount of
+// URLPatterns in a URLPatternSet we're using shared memory. This object
+// includes functions to pickle/unpickle and allocate shared memory as this is
+// used from various parts in the code.
+struct ExtensionMsg_RuntimeBlockedAllowedHostsStruct {
+  ExtensionMsg_RuntimeBlockedAllowedHostsStruct();
+  explicit ExtensionMsg_RuntimeBlockedAllowedHostsStruct(
+      const extensions::URLPatternSet& runtime_blocked_hosts,
+      const extensions::URLPatternSet& runtime_allowed_hosts,
+      const base::ProcessHandle host);
+  ExtensionMsg_RuntimeBlockedAllowedHostsStruct(
+      const ExtensionMsg_RuntimeBlockedAllowedHostsStruct& other);
+  ~ExtensionMsg_RuntimeBlockedAllowedHostsStruct();
+
+  void Unpickle(extensions::URLPatternSet* runtime_blocked_hosts,
+                extensions::URLPatternSet* runtime_allowed_hosts) const;
+
+  base::SharedMemoryHandle hosts;
+};
+
 struct ExtensionMsg_PermissionSetStruct {
   ExtensionMsg_PermissionSetStruct();
   explicit ExtensionMsg_PermissionSetStruct(
       const extensions::PermissionSet& permissions);
   ExtensionMsg_PermissionSetStruct(
       const ExtensionMsg_PermissionSetStruct& other);
   ~ExtensionMsg_PermissionSetStruct();
 
   std::unique_ptr<const extensions::PermissionSet> ToPermissionSet() const;
 
   extensions::APIPermissionSet apis;
   extensions::ManifestPermissionSet manifest_permissions;
   extensions::URLPatternSet explicit_hosts;
   extensions::URLPatternSet scriptable_hosts;
 };
 
 struct ExtensionMsg_Loaded_Params {
   ExtensionMsg_Loaded_Params();
   ~ExtensionMsg_Loaded_Params();
   ExtensionMsg_Loaded_Params(const extensions::Extension* extension,
-                             bool include_tab_permissions);
+                             bool include_tab_permissions,
+                             const base::ProcessHandle handle);
   ExtensionMsg_Loaded_Params(const ExtensionMsg_Loaded_Params& other);
 
   // Creates a new extension from the data in this object.
   scoped_refptr<extensions::Extension> ConvertToExtension(
       std::string* error) const;
 
   // The subset of the extension manifest data we send to renderers.
   linked_ptr<base::DictionaryValue> manifest;
 
   // The location the extension was installed from.
   extensions::Manifest::Location location;
 
   // The path the extension was loaded from. This is used in the renderer only
   // to generate the extension ID for extensions that are loaded unpacked.
   base::FilePath path;
 
   // The extension's active and withheld permissions.
   ExtensionMsg_PermissionSetStruct active_permissions;
   ExtensionMsg_PermissionSetStruct withheld_permissions;
   std::map<int, ExtensionMsg_PermissionSetStruct> tab_specific_permissions;
 
+  // Contians URLPatternSets defining which URLs an extension may not interact
+  // with by policy. This is mapped to shared memory to deal with large lists.
+  ExtensionMsg_RuntimeBlockedAllowedHostsStruct hosts;
+
+  // If the extension uses the default list of blocked / allowed URLs. If false,
+  // then the 'hosts' struct in this struct must be populated with a valid
+  // shared memory handle.
+  bool is_default_runtime_blocked_allowed_hosts;
+
   // We keep this separate so that it can be used in logging.
   std::string id;
 
   // Send creation flags so extension is initialized identically.
   int creation_flags;
 };
 
 struct ExtensionHostMsg_AutomationQuerySelector_Error {
   enum Value { kNone, kNoMainFrame, kNoDocument, kNodeDestroyed };
 
@@ skipping 64 matching lines @@
   typedef HostID param_type;
   static void GetSize(base::PickleSizer* s, const param_type& p);
   static void Write(base::Pickle* m, const param_type& p);
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r);
   static void Log(const param_type& p, std::string* l);
 };
 
 template <>
+struct ParamTraits<ExtensionMsg_RuntimeBlockedAllowedHostsStruct> {
+  typedef ExtensionMsg_RuntimeBlockedAllowedHostsStruct param_type;
+  static void GetSize(base::PickleSizer* s, const param_type& p);
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* p);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
 struct ParamTraits<ExtensionMsg_PermissionSetStruct> {
   typedef ExtensionMsg_PermissionSetStruct param_type;
   static void GetSize(base::PickleSizer* s, const param_type& p);
   static void Write(base::Pickle* m, const param_type& p);
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* p);
   static void Log(const param_type& p, std::string* l);
 };
 
@@ skipping 19 matching lines @@
 IPC_STRUCT_TRAITS_MEMBER(value)
 IPC_STRUCT_TRAITS_END()
 
 // Parameters structure for ExtensionMsg_UpdatePermissions.
 IPC_STRUCT_BEGIN(ExtensionMsg_UpdatePermissions_Params)
   IPC_STRUCT_MEMBER(std::string, extension_id)
   IPC_STRUCT_MEMBER(ExtensionMsg_PermissionSetStruct, active_permissions)
   IPC_STRUCT_MEMBER(ExtensionMsg_PermissionSetStruct, withheld_permissions)
 IPC_STRUCT_END()
 
+// Parameters structure for ExtensionMsg_UpdateAllowedAndBlockedHosts.
+IPC_STRUCT_BEGIN(ExtensionMsg_UpdateAllowedAndBlockedHosts_Params)
+  IPC_STRUCT_MEMBER(std::string, extension_id)
+  IPC_STRUCT_MEMBER(ExtensionMsg_RuntimeBlockedAllowedHostsStruct, hosts)
+  IPC_STRUCT_MEMBER(bool, is_default)
+IPC_STRUCT_END()
+
+// Parameters structure for ExtensionMsg_UpdateDefaultAllowedAndBlockedHosts.
+IPC_STRUCT_BEGIN(ExtensionMsg_UpdateDefaultAllowedAndBlockedHosts_Params)
+  IPC_STRUCT_MEMBER(base::SharedMemoryHandle, default_runtime_blocked_hosts)
+  IPC_STRUCT_MEMBER(base::SharedMemoryHandle, default_runtime_allowed_hosts)
+IPC_STRUCT_END()
+
 // Messages sent from the browser to the renderer:
 
 // The browser sends this message in response to all extension api calls. The
 // response data (if any) is one of the base::Value subclasses, wrapped as the
 // first element in a ListValue.
 IPC_MESSAGE_ROUTED4(ExtensionMsg_Response,
                     int /* request_id */,
                     bool /* success */,
                     base::ListValue /* response wrapper (see comment above) */,
                     std::string /* error */)
@@ skipping 78 matching lines @@
                     int /* id of browser window */)
 
 // Tell the render view what its tab ID is.
 IPC_MESSAGE_ROUTED1(ExtensionMsg_SetTabId,
                     int /* id of tab */)
 
 // Tell the renderer to update an extension's permission set.
 IPC_MESSAGE_CONTROL1(ExtensionMsg_UpdatePermissions,
                      ExtensionMsg_UpdatePermissions_Params)
 
+// Tell the renderer to update an extension's runtime_blocked_hosts set.
+IPC_MESSAGE_CONTROL1(ExtensionMsg_UpdateAllowedAndBlockedHosts,
+                     ExtensionMsg_UpdateAllowedAndBlockedHosts_Params)
+
+// Tell the renderer to update an extension's runtime_blocked_hosts set.
+IPC_MESSAGE_CONTROL1(ExtensionMsg_UpdateDefaultAllowedAndBlockedHosts,
+                     ExtensionMsg_RuntimeBlockedAllowedHostsStruct)
+
 // Tell the render view about new tab-specific permissions for an extension.
 IPC_MESSAGE_CONTROL5(ExtensionMsg_UpdateTabSpecificPermissions,
                      GURL /* url */,
                      std::string /* extension_id */,
                      extensions::URLPatternSet /* hosts */,
                      bool /* update origin whitelist */,
                      int /* tab_id */)
 
 // Tell the render view to clear tab-specific permissions for some extensions.
 IPC_MESSAGE_CONTROL3(ExtensionMsg_ClearTabSpecificPermissions,
@@ skipping 360 matching lines @@
                      int64_t /* service_worker_version_id */,
                      std::string /* request_uuid */)
 
 // Asks the browser to decrement the pending activity count for
 // the worker with version id |service_worker_version_id|.
 // |request_uuid| must match the GUID of a previous request, otherwise the
 // browser process ignores the IPC.
 IPC_MESSAGE_CONTROL2(ExtensionHostMsg_DecrementServiceWorkerActivity,
                      int64_t /* service_worker_version_id */,
                      std::string /* request_uuid */)