chrome.webRequest support for ExtensionSettings

extensions/common/permissions/permissions_data.h

 // Copyright (c) 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.
 
 #ifndef EXTENSIONS_COMMON_PERMISSIONS_PERMISSIONS_DATA_H_
 #define EXTENSIONS_COMMON_PERMISSIONS_PERMISSIONS_DATA_H_
 
 #include <map>
 #include <memory>
 #include <string>
@@ skipping 245 matching lines @@
   // This should only be used for 1. Serialization when initializing renderers
   // or 2. Called from utility methods above. For all other uses, call utility
   // methods instead (e.g. CanAccessPage()).
   const URLPatternSet policy_allowed_hosts() const;
 
 #if defined(UNIT_TEST)
   const PermissionSet* GetTabSpecificPermissionsForTesting(int tab_id) const {
     base::AutoLock auto_lock(runtime_lock_);
     return GetTabSpecificPermissions(tab_id);
   }
+#endif
 
-  bool IsRuntimeBlockedHostForTesting(const GURL& url) const {
+  bool IsRuntimeBlockedHost(const GURL& url) const {

[Devlin, 2017/05/25 20:38:33]

We should put this above for-testing methods.

[nrpeter, 2017/05/26 02:46:52]

Done.

     base::AutoLock auto_lock(runtime_lock_);
-    return IsRuntimeBlockedHost(url);
+    return IsRuntimeBlockedHostUnsafe(url);
   }
-#endif
 
  private:
   // Gets the tab-specific host permissions of |tab_id|, or NULL if there
   // aren't any.
   // Must be called with |runtime_lock_| acquired.
   const PermissionSet* GetTabSpecificPermissions(int tab_id) const;
 
   // Returns true if the |extension| has tab-specific permission to operate on
   // the tab specified by |tab_id| with the given |url|.
   // Note that if this returns false, it doesn't mean the extension can't run on
   // the given tab, only that it does not have tab-specific permission to do so.
   // Must be called with |runtime_lock_| acquired.
   bool HasTabSpecificPermissionToExecuteScript(int tab_id,
                                                const GURL& url) const;
 
   // Returns whether or not the extension is permitted to run on the given page,
   // checking against |permitted_url_patterns| in addition to blocking special
   // sites (like the webstore or chrome:// urls).
   // Must be called with |runtime_lock_| acquired.
   AccessType CanRunOnPage(const Extension* extension,
                           const GURL& document_url,
                           int tab_id,
                           const URLPatternSet& permitted_url_patterns,
                           const URLPatternSet& withheld_url_patterns,
                           std::string* error) const;
 
   // Check if a specific URL is blocked by policy from extension use at runtime.
-  bool IsRuntimeBlockedHost(const GURL& url) const;
+  // You must acquire the runtime_lock_ before calling.
+  bool IsRuntimeBlockedHostUnsafe(const GURL& url) const;
 
   // Same as policy_blocked_hosts but instead returns a reference.
   // You must acquire runtime_lock_ before calling this.
   const URLPatternSet& PolicyBlockedHostsUnsafe() const;
 
   // Same as policy_allowed_hosts but instead returns a reference.
   // You must acquire runtime_lock_ before calling this.
   const URLPatternSet& PolicyAllowedHostsUnsafe() const;
 
   // The associated extension's id.
@@ skipping 35 matching lines @@
   mutable TabPermissionsMap tab_specific_permissions_;
 
   mutable std::unique_ptr<base::ThreadChecker> thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(PermissionsData);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_PERMISSIONS_PERMISSIONS_DATA_H_