Track permissions granted to extensions in prefs

chrome/common/extensions/extension.cc

 // Copyright (c) 2010 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 "chrome/common/extensions/extension.h"
 
 #include <algorithm>
 
 #include "app/l10n_util.h"
 #include "base/base64.h"
@@ skipping 1111 matching lines @@
                       std::inserter(new_only, new_only.end()));
 
   // If there are any new permission messages, then it's an increase.
   if (!new_only.empty())
     return true;
 
   return false;
 }
 
 // static
+// TODO(jstritar): This can be combined with the other IsPrivilegeIncrease
+// so that extensions can remove and re-add permissions during upgrades.

[Aaron Boodman, 2010/11/12 00:05:24]

I don't understand this comment. Can you combine these now? They seem likely to
get out of date otherwise.

[jstritar, 2010/11/19 21:38:36]

Okay, I combined both IsPrivilegeIncreases and updated the calls to it from
ExtensionService::OnExtensionLoaded. As an added benefit, extensions can now
remove permissions in one upgrade, then add them back via a silent upgrade since
we know they were already granted.

In adding this, I created a static version of
Extension::HasEffectiveAccessToAllHosts. This isn't in the right spot in the
*.cc file based on the conventions we discussed in other code reviews, but none
of the static methods are, so it seemed better not to rearrange them given how
big the file is.

+bool Extension::IsPrivilegeIncrease(const std::set<std::string>* granted_apis,
+                                    const std::set<std::string>* granted_hosts,
+                                    const Extension* extension) {
+  // TODO(erikkay) This will trip when you add a new distinct hostname,
+  // but we should unique based on RCD as well.  crbug.com/57042
+  std::set<std::string> new_hosts;
+  std::set<std::string> new_hosts_only;
+
+  extension->GetEffectiveHostPermissions().GetAsStringSet(&new_hosts);
+  std::set_difference(new_hosts.begin(), new_hosts.end(),
+                      granted_hosts->begin(), granted_hosts->end(),
+                      std::inserter(new_hosts_only, new_hosts_only.end()));
+
+  if (!new_hosts_only.empty())
+    return true;
+
+  std::set<std::string> new_apis = extension->api_permissions();
+  std::set<std::string> new_apis_only;
+  std::set_difference(new_apis.begin(), new_apis.end(),
+                      granted_apis->begin(), granted_apis->end(),
+                      std::inserter(new_apis_only, new_apis_only.end()));
+
+  if (!new_apis_only.empty())
+    return true;
+
+  return false;
+}
+
+// static
 void Extension::DecodeIcon(const Extension* extension,
                            Icons icon_size,
                            scoped_ptr<SkBitmap>* result) {
   FilePath icon_path = extension->GetIconResource(
       icon_size, ExtensionIconSet::MATCH_EXACTLY).GetFilePath();
   DecodeIconFromPath(icon_path, icon_size, result);
 }
 
 // static
 void Extension::DecodeIconFromPath(const FilePath& icon_path,
@@ skipping 557 matching lines @@
           continue;
         }
       } else {
         // Hosted apps only get access to a subset of the valid permissions.
         if (IsHostedAppPermission(permission_str)) {
           api_permissions_.insert(permission_str);
           continue;
         }
       }
 
-      // Otherwise, it's a host pattern permission.
+      // Check if it's a host pattern permission.
       URLPattern pattern = URLPattern(CanExecuteScriptEverywhere() ?
           URLPattern::SCHEME_ALL :
           (UserScript::kValidUserScriptSchemes |
               URLPattern::SCHEME_CHROMEUI) & ~URLPattern::SCHEME_FILE);
 
-      if (URLPattern::PARSE_SUCCESS != pattern.Parse(permission_str)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
-            errors::kInvalidPermission, base::IntToString(i));
-        return false;
+      if (URLPattern::PARSE_SUCCESS == pattern.Parse(permission_str)) {
+        if (!CanSpecifyHostPermission(pattern)) {
+          *error = ExtensionErrorUtils::FormatErrorMessage(
+              errors::kInvalidPermissionScheme, base::IntToString(i));
+          return false;
+        }
+
+        // The path component is not used for host permissions, so we force it
+        // to match all paths.
+        pattern.set_path("/*");
+
+        host_permissions_.push_back(pattern);
       }
 
-      if (!CanSpecifyHostPermission(pattern)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
-            errors::kInvalidPermissionScheme, base::IntToString(i));
-        return false;
-      }
-
-      // The path component is not used for host permissions, so we force it to
-      // match all paths.
-      pattern.set_path("/*");
-
-      host_permissions_.push_back(pattern);
+      // If it's not a host permission, then it's probably an unknown API
+      // permission. Do not throw an error so extensions can retain
+      // backwards compatability.

[Aaron Boodman, 2010/11/12 00:05:24]

This is a good place to add a link to the bug, so future readers can dig deeper.

[jstritar, 2010/11/19 21:38:36]

Done.

     }
   }
 
   if (source.HasKey(keys::kDefaultLocale)) {
     if (!source.GetString(keys::kDefaultLocale,
                           &default_locale_) ||
         default_locale_.empty()) {
       *error = errors::kInvalidDefaultLocale;
       return false;
     }
@@ skipping 468 matching lines @@
 UninstalledExtensionInfo::UninstalledExtensionInfo(
     const Extension& extension)
     : extension_id(extension.id()),
       extension_api_permissions(extension.api_permissions()),
       is_theme(extension.is_theme()),
       is_app(extension.is_app()),
       converted_from_user_script(extension.converted_from_user_script()),
       update_url(extension.update_url()) {}
 
 UninstalledExtensionInfo::~UninstalledExtensionInfo() {}