Move each permission classes to its own files in extensions/permissions

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2012 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_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 116 matching lines @@
 using base::Time;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::DevToolsAgentHostRegistry;
 using content::PluginService;
 using extensions::Extension;
 using extensions::ExtensionIdSet;
 using extensions::ExtensionInfo;
 using extensions::UnloadedExtensionInfo;
+using extensions::PermissionMessage;
+using extensions::PermissionMessages;
+using extensions::PermissionSet;
 
 namespace errors = extension_manifest_errors;
 
 namespace {
 
 #if defined(OS_LINUX)
 static const int kOmniboxIconPaddingLeft = 2;
 static const int kOmniboxIconPaddingRight = 2;
 #elif defined(OS_MACOSX)
 static const int kOmniboxIconPaddingLeft = 0;
@@ skipping 749 matching lines @@
 }
 
 // static
 void ExtensionService::RecordPermissionMessagesHistogram(
     const Extension* e, const char* histogram) {
   // Since this is called from multiple sources, and since the Histogram macros
   // use statics, we need to manually lookup the Histogram ourselves.
   base::Histogram* counter = base::LinearHistogram::FactoryGet(
       histogram,
       1,
-      ExtensionPermissionMessage::kEnumBoundary,
-      ExtensionPermissionMessage::kEnumBoundary + 1,
+      PermissionMessage::kEnumBoundary,
+      PermissionMessage::kEnumBoundary + 1,
       base::Histogram::kUmaTargetedHistogramFlag);
 
-  ExtensionPermissionMessages permissions = e->GetPermissionMessages();
+  PermissionMessages permissions = e->GetPermissionMessages();
   if (permissions.empty()) {
-    counter->Add(ExtensionPermissionMessage::kNone);
+    counter->Add(PermissionMessage::kNone);
   } else {
-    for (ExtensionPermissionMessages::iterator it = permissions.begin();
+    for (PermissionMessages::iterator it = permissions.begin();
          it != permissions.end(); ++it)
       counter->Add(it->id());
   }
 }
 
 void ExtensionService::NotifyExtensionLoaded(const Extension* extension) {
   // The ChromeURLRequestContexts need to be first to know that the extension
   // was loaded, otherwise a race can arise where a renderer that is created
   // for the extension may try to load an extension URL with an extension id
   // that the request context doesn't yet know about. The profile is responsible
@@ skipping 1024 matching lines @@
 
   extensions_.Insert(scoped_extension);
   SyncExtensionChangeIfNeeded(*extension);
   NotifyExtensionLoaded(extension);
 }
 
 void ExtensionService::InitializePermissions(const Extension* extension) {
   // If the extension has used the optional permissions API, it will have a
   // custom set of active permissions defined in the extension prefs. Here,
   // we update the extension's active permissions based on the prefs.
-  scoped_refptr<ExtensionPermissionSet> active_permissions =
+  scoped_refptr<PermissionSet> active_permissions =
       extension_prefs()->GetActivePermissions(extension->id());
 
   if (active_permissions.get()) {
     // We restrict the active permissions to be within the bounds defined in the
     // extension's manifest.
     //  a) active permissions must be a subset of optional + default permissions
     //  b) active permissions must contains all default permissions
-    scoped_refptr<ExtensionPermissionSet> total_permissions =
-        ExtensionPermissionSet::CreateUnion(
+    scoped_refptr<PermissionSet> total_permissions =
+        PermissionSet::CreateUnion(
             extension->required_permission_set(),
             extension->optional_permission_set());
 
     // Make sure the active permissions contain no more than optional + default.
-    scoped_refptr<ExtensionPermissionSet> adjusted_active =
-        ExtensionPermissionSet::CreateIntersection(
+    scoped_refptr<PermissionSet> adjusted_active =
+        PermissionSet::CreateIntersection(
             total_permissions.get(), active_permissions.get());
 
     // Make sure the active permissions contain the default permissions.
-    adjusted_active = ExtensionPermissionSet::CreateUnion(
+    adjusted_active = PermissionSet::CreateUnion(
             extension->required_permission_set(), adjusted_active.get());
 
     extensions::PermissionsUpdater perms_updater(profile());
     perms_updater.UpdateActivePermissions(extension, adjusted_active);
   }
 
   // We keep track of all permissions the user has granted each extension.
   // This allows extensions to gracefully support backwards compatibility
   // by including unknown permissions in their manifests. When the user
   // installs the extension, only the recognized permissions are recorded.
@@ skipping 20 matching lines @@
   bool is_privilege_increase = false;
   bool previously_disabled = false;
   Extension::DisableReason disable_reason =
       extension_prefs_->GetDisableReason(extension->id());
 
   // We only need to compare the granted permissions to the current permissions
   // if the extension is not allowed to silently increase its permissions.
   if (!extension->CanSilentlyIncreasePermissions()) {
     // Add all the recognized permissions if the granted permissions list
     // hasn't been initialized yet.
-    scoped_refptr<ExtensionPermissionSet> granted_permissions =
+    scoped_refptr<PermissionSet> granted_permissions =
         extension_prefs_->GetGrantedPermissions(extension->id());
     CHECK(granted_permissions.get());
 
     // Here, we check if an extension's privileges have increased in a manner
     // that requires the user's approval. This could occur because the browser
     // upgraded and recognized additional privileges, or an extension upgrades
     // to a version that requires additional privileges.
     is_privilege_increase =
         granted_permissions->HasLessPrivilegesThan(
             extension->GetActivePermissions());
@@ skipping 526 matching lines @@
 
   // To coexist with certain unit tests that don't have a work-thread message
   // loop available at ExtensionService shutdown, we lazy-initialize this
   // object so that those cases neither create nor destroy an
   // APIResourceController.
   if (!api_resource_controller_.get()) {
     api_resource_controller_.reset(new extensions::APIResourceController());
   }
   return api_resource_controller_.get();
 }