Make ActiveScriptController use Active Tab-style permissions

extensions/common/permissions/permission_set.cc

 // Copyright 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.
 
 #include "extensions/common/permissions/permission_set.h"
 
 #include <algorithm>
 #include <iterator>
 #include <string>
 
+#include "base/strings/stringprintf.h"
 #include "extensions/common/permissions/permissions_info.h"
 #include "extensions/common/url_pattern.h"
 #include "extensions/common/url_pattern_set.h"
+#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "url/gurl.h"
 
-using extensions::URLPatternSet;
+namespace extensions {
 
 namespace {
 
 void AddPatternsAndRemovePaths(const URLPatternSet& set, URLPatternSet* out) {
   DCHECK(out);
   for (URLPatternSet::const_iterator i = set.begin(); i != set.end(); ++i) {
     URLPattern p = *i;
     p.SetPath("/*");
     out->AddPattern(p);
   }
 }
 
 }  // namespace
 
-namespace extensions {
-
 //
 // PermissionSet
 //
 
-PermissionSet::PermissionSet() {}
+PermissionSet::PermissionSet() : should_warn_all_hosts_(UNINITIALIZED) {}
 
 PermissionSet::PermissionSet(
     const APIPermissionSet& apis,
     const ManifestPermissionSet& manifest_permissions,
     const URLPatternSet& explicit_hosts,
     const URLPatternSet& scriptable_hosts)
     : apis_(apis),
       manifest_permissions_(manifest_permissions),
-      scriptable_hosts_(scriptable_hosts) {
+      scriptable_hosts_(scriptable_hosts),
+      should_warn_all_hosts_(UNINITIALIZED) {
   AddPatternsAndRemovePaths(explicit_hosts, &explicit_hosts_);
   InitImplicitPermissions();
   InitEffectiveHosts();
 }
 
 // static
 PermissionSet* PermissionSet::CreateDifference(
     const PermissionSet* set1,
     const PermissionSet* set2) {
   scoped_refptr<PermissionSet> empty = new PermissionSet();
@@ skipping 166 matching lines @@
   }
 
   for (APIPermissionSet::const_iterator i = apis().begin();
        i != apis().end(); ++i) {
     if (i->info()->implies_full_url_access())
       return true;
   }
   return false;
 }
 
+bool PermissionSet::ShouldWarnAllHosts() const {
+  if (should_warn_all_hosts_ == UNINITIALIZED)
+    InitShouldWarnAllHosts();
+  return should_warn_all_hosts_ == WARN_ALL_HOSTS;
+}
+
 bool PermissionSet::HasEffectiveAccessToURL(const GURL& url) const {
   return effective_hosts().MatchesURL(url);
 }
 
 bool PermissionSet::HasEffectiveFullAccess() const {
   for (APIPermissionSet::const_iterator i = apis().begin();
        i != apis().end(); ++i) {
     if (i->info()->implies_full_access())
       return true;
   }
@@ skipping 12 matching lines @@
     apis_.insert(APIPermission::kFileBrowserHandlerInternal);
 }
 
 void PermissionSet::InitEffectiveHosts() {
   effective_hosts_.ClearPatterns();
 
   URLPatternSet::CreateUnion(
       explicit_hosts(), scriptable_hosts(), &effective_hosts_);
 }
 
+void PermissionSet::InitShouldWarnAllHosts() const {
+  if (HasEffectiveAccessToAllHosts()) {
+    should_warn_all_hosts_ = WARN_ALL_HOSTS;
+    return;
+  }
+
+  for (URLPatternSet::const_iterator iter = effective_hosts_.begin();
+       iter != effective_hosts_.end();
+       ++iter) {
+    // If this doesn't even match subdomains, it can't possibly imply all hosts.
+    if (!iter->match_subdomains())
+      continue;
+
+    // If iter->host() is a recognized TLD, this will be 0. We don't include
+    // private TLDs, so that, e.g., *.appspot.com does not imply all hosts.
+    size_t registry_length =
+        net::registry_controlled_domains::GetRegistryLength(
+            iter->host(),
+            net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
+            net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
+    // If there was more than just a TLD in the host (e.g., *.foobar.com), it
+    // doesn't imply all hosts.
+    if (registry_length > 0)
+      continue;
+
+    // At this point the host could either be just a TLD ("com") or some unknown
+    // TLD-like string ("notatld"). To disambiguate between them construct a
+    // fake URL, and check the registry. This returns 0 if the TLD is
+    // unrecognized, or the length of the recognized TLD.
+    registry_length = net::registry_controlled_domains::GetRegistryLength(
+        base::StringPrintf("foo.%s", iter->host().c_str()),
+        net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
+        net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
+    // If we recognized this TLD, then this is a pattern like *.com, and it
+    // should imply all hosts.
+    if (registry_length > 0) {
+      should_warn_all_hosts_ = WARN_ALL_HOSTS;
+      return;
+    }
+  }
+
+  should_warn_all_hosts_ = DONT_WARN_ALL_HOSTS;
+}
+
 }  // namespace extensions