Start refractoring extension permissions into ExtensionPermissionSet.

chrome/browser/extensions/extension_preference_api.cc

 // Copyright (c) 2011 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/browser/extensions/extension_preference_api.h"
 
 #include <map>
 
 #include "base/json/json_writer.h"
 #include "base/memory/singleton.h"
 #include "base/stl_util-inl.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_preference_api_constants.h"
 #include "chrome/browser/extensions/extension_preference_helpers.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_prefs_scope.h"
 #include "chrome/browser/extensions/extension_proxy_api.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/extension_error_utils.h"
+#include "chrome/common/extensions/extension_permission_set.h"
 #include "chrome/common/pref_names.h"
 #include "content/common/notification_type.h"
 #include "content/common/notification_service.h"
 
 namespace {
 
 struct PrefMappingEntry {
   const char* extension_pref;
   const char* browser_pref;
-  const char* permission;
+  ExtensionAPIPermission::ID permission;
 };
 
 const char kNotControllable[] = "not_controllable";
 const char kControlledByOtherExtensions[] = "controlled_by_other_extensions";
 const char kControllableByThisExtension[] = "controllable_by_this_extension";
 const char kControlledByThisExtension[] = "controlled_by_this_extension";
 
 const char kIncognitoSpecific[] = "incognitoSpecific";
 const char kLevelOfControl[] = "levelOfControl";
 const char kValue[] = "value";
 
 const char kOnPrefChangeFormat[] = "types.ChromeSetting.%s.onChange";
 
 PrefMappingEntry kPrefMapping[] = {
   { "thirdPartyCookiesAllowed",
     prefs::kBlockThirdPartyCookies,
-    Extension::kContentSettingsPermission
+    ExtensionAPIPermission::kContentSettings
   },
   { "referrersEnabled",
     prefs::kEnableReferrers,
-    Extension::kContentSettingsPermission
+    ExtensionAPIPermission::kContentSettings
   },
   { "hyperlinkAuditingEnabled",
     prefs::kEnableHyperlinkAuditing,
-    Extension::kContentSettingsPermission
+    ExtensionAPIPermission::kContentSettings
   },
   { "proxy",
     prefs::kProxy,
-    Extension::kProxyPermission
+    ExtensionAPIPermission::kProxy
   },
 };
 
 class IdentityPrefTransformer : public PrefTransformerInterface {
  public:
   virtual Value* ExtensionToBrowserPref(const Value* extension_pref,
                                         std::string* error,
                                         bool* bad_message) {
     return extension_pref->DeepCopy();
   }
@@ skipping 51 matching lines @@
 }
 
 class PrefMapping {
  public:
   static PrefMapping* GetInstance() {
     return Singleton<PrefMapping>::get();
   }
 
   bool FindBrowserPrefForExtensionPref(const std::string& extension_pref,
                                        std::string* browser_pref,
-                                       std::string* permission) {
-    std::map<std::string, std::pair<std::string, std::string> >::iterator it =
-        mapping_.find(extension_pref);
+                                       ExtensionAPIPermission::ID* permission) {
+    PrefMap::iterator it = mapping_.find(extension_pref);
     if (it != mapping_.end()) {
       *browser_pref = it->second.first;
       *permission = it->second.second;
       return true;
     }
     return false;
   }
 
   bool FindEventForBrowserPref(const std::string& browser_pref,
                                std::string* event_name,
-                               std::string* permission) {
-    std::map<std::string, std::pair<std::string, std::string> >::iterator it =
-        event_mapping_.find(browser_pref);
+                               ExtensionAPIPermission::ID* permission) {
+    PrefMap::iterator it = event_mapping_.find(browser_pref);
     if (it != event_mapping_.end()) {
       *event_name = it->second.first;
       *permission = it->second.second;
       return true;
     }
     return false;
   }
 
   PrefTransformerInterface* FindTransformerForBrowserPref(
       const std::string& browser_pref) {
@@ skipping 32 matching lines @@
                                          transformers_.end());
   }
 
   void RegisterPrefTransformer(const std::string& browser_pref,
                                PrefTransformerInterface* transformer) {
     DCHECK_EQ(0u, transformers_.count(browser_pref)) <<
         "Trying to register pref transformer for " << browser_pref << " twice";
     transformers_[browser_pref] = transformer;
   }
 
+  typedef std::map<std::string,
+                   std::pair<std::string, ExtensionAPIPermission::ID> >
+          PrefMap;
+
   // Mapping from extension pref keys to browser pref keys and permissions.
-  std::map<std::string, std::pair<std::string, std::string> > mapping_;
+  PrefMap mapping_;
 
   // Mapping from browser pref keys to extension event names and permissions.
-  std::map<std::string, std::pair<std::string, std::string> > event_mapping_;
+  PrefMap event_mapping_;
 
   // Mapping from browser pref keys to transformers.
   std::map<std::string, PrefTransformerInterface*> transformers_;
 
   scoped_ptr<PrefTransformerInterface> identity_transformer_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefMapping);
 };
 
 }  // namespace
@@ skipping 25 matching lines @@
     NOTREACHED();
   }
 }
 
 void ExtensionPreferenceEventRouter::OnPrefChanged(
     PrefService* pref_service,
     const std::string& browser_pref) {
   bool incognito = (pref_service != profile_->GetPrefs());
 
   std::string event_name;
-  std::string permission;
+  ExtensionAPIPermission::ID permission = ExtensionAPIPermission::kInvalid;
   bool rv = PrefMapping::GetInstance()->FindEventForBrowserPref(
       browser_pref, &event_name, &permission);
   DCHECK(rv);
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   args.Append(dict);
   const PrefService::Preference* pref =
       pref_service->FindPreference(browser_pref.c_str());
   CHECK(pref);
   ExtensionService* extension_service = profile_->GetExtensionService();
   PrefTransformerInterface* transformer =
       PrefMapping::GetInstance()->FindTransformerForBrowserPref(browser_pref);
   dict->Set(kValue, transformer->BrowserToExtensionPref(pref->GetValue()));
   if (incognito) {
     ExtensionPrefs* ep = extension_service->extension_prefs();
     dict->SetBoolean(kIncognitoSpecific,
                      ep->HasIncognitoPrefValue(browser_pref));
   }
 
   ExtensionEventRouter* router = profile_->GetExtensionEventRouter();
   if (!router || !router->HasEventListener(event_name))
     return;
   const ExtensionList* extensions = extension_service->extensions();
   for (ExtensionList::const_iterator it = extensions->begin();
        it != extensions->end(); ++it) {
     std::string extension_id = (*it)->id();
     // TODO(bauerb): Only iterate over registered event listeners.
     if (router->ExtensionHasEventListener(extension_id, event_name) &&
-        (*it)->HasApiPermission(permission) &&
+        (*it)->HasAPIPermission(permission) &&
         (!incognito || extension_service->CanCrossIncognito(*it))) {
       std::string level_of_control =
           GetLevelOfControl(profile_, extension_id, browser_pref, incognito);
       dict->SetString(kLevelOfControl, level_of_control);
 
       std::string json_args;
       base::JSONWriter::Write(&args, false, &json_args);
 
       DispatchEvent(extension_id, event_name, json_args);
     }
@@ skipping 24 matching lines @@
                                                     &incognito));
 
   if (incognito && !include_incognito()) {
     error_ = keys::kIncognitoErrorMessage;
     return false;
   }
 
   PrefService* prefs = incognito ? profile_->GetOffTheRecordPrefs()
                                  : profile_->GetPrefs();
   std::string browser_pref;
-  std::string permission;
+  ExtensionAPIPermission::ID permission = ExtensionAPIPermission::kInvalid;
   EXTENSION_FUNCTION_VALIDATE(
       PrefMapping::GetInstance()->FindBrowserPrefForExtensionPref(
           pref_key, &browser_pref, &permission));
-  if (!GetExtension()->HasApiPermission(permission)) {
+  if (!GetExtension()->HasAPIPermission(permission)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kPermissionErrorMessage, pref_key);
     return false;
   }
 
   const PrefService::Preference* pref =
       prefs->FindPreference(browser_pref.c_str());
   CHECK(pref);
   std::string level_of_control =
       GetLevelOfControl(profile_, extension_id(), browser_pref, incognito);
@@ skipping 49 matching lines @@
     }
   }
 
   if (scope == kExtensionPrefsScopeIncognitoSessionOnly &&
       !profile_->HasOffTheRecordProfile()) {
     error_ = keys::kIncognitoSessionOnlyErrorMessage;
     return false;
   }
 
   std::string browser_pref;
-  std::string permission;
+  ExtensionAPIPermission::ID permission = ExtensionAPIPermission::kInvalid;
   EXTENSION_FUNCTION_VALIDATE(
       PrefMapping::GetInstance()->FindBrowserPrefForExtensionPref(
           pref_key, &browser_pref, &permission));
-  if (!GetExtension()->HasApiPermission(permission)) {
+  if (!GetExtension()->HasAPIPermission(permission)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kPermissionErrorMessage, pref_key);
     return false;
   }
   ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
   const PrefService::Preference* pref =
       prefs->pref_service()->FindPreference(browser_pref.c_str());
   CHECK(pref);
   EXTENSION_FUNCTION_VALIDATE(value->GetType() == pref->GetType());
   PrefTransformerInterface* transformer =
@@ skipping 39 matching lines @@
   } else {
     // Incognito profiles can't access regular mode ever, they only exist in
     // split mode.
     if (profile()->IsOffTheRecord()) {
       error_ = "Can't modify regular settings from an incognito context.";
       return false;
     }
   }
 
   std::string browser_pref;
-  std::string permission;
+  ExtensionAPIPermission::ID permission = ExtensionAPIPermission::kInvalid;
   EXTENSION_FUNCTION_VALIDATE(
       PrefMapping::GetInstance()->FindBrowserPrefForExtensionPref(
           pref_key, &browser_pref, &permission));
-  if (!GetExtension()->HasApiPermission(permission)) {
+  if (!GetExtension()->HasAPIPermission(permission)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kPermissionErrorMessage, pref_key);
     return false;
   }
   ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
   prefs->RemoveExtensionControlledPref(extension_id(), browser_pref, scope);
   return true;
 }