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

chrome/browser/chrome_content_browser_client.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/chrome_content_browser_client.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 117 matching lines @@
 #endif
 
 using content::AccessTokenStore;
 using content::BrowserThread;
 using content::BrowserURLHandler;
 using content::ChildProcessSecurityPolicy;
 using content::QuotaPermissionContext;
 using content::RenderViewHost;
 using content::SiteInstance;
 using content::WebContents;
+using extensions::APIPermission;
 using extensions::Extension;
 using webkit_glue::WebPreferences;
 
 namespace {
 
 const char* kPredefinedAllowedSocketOrigins[] = {
   "okddffdblfhhnmhodogpojmfkjmhinfp",  // Test SSH Client
   "pnhechapfaindjhompbnflcldabbghjo",  // HTerm App (SSH Client)
   "bglhmjfplikpjnfoegeomebmfnkjomhe",  // see crbug.com/122126
   "gbchcmhmhahfdphkhkmpfmihenigjmpp",  // Chrome Remote Desktop
@@ skipping 341 matching lines @@
   const Extension* extension = profile->GetExtensionService()->extensions()->
       GetExtensionOrAppByURL(ExtensionURLInfo(effective_url));
   if (!extension)
     return false;
 
   // If the URL is part of a hosted app that does not have the background
   // permission, or that does not allow JavaScript access to the background
   // page, we want to give each instance its own process to improve
   // responsiveness.
   if (extension->GetType() == Extension::TYPE_HOSTED_APP) {
-    if (!extension->HasAPIPermission(ExtensionAPIPermission::kBackground) ||
+    if (!extension->HasAPIPermission(APIPermission::kBackground) ||
         !extension->allow_background_js_access()) {
       return false;
     }
   }
 
   // Hosted apps that have script access to their background page must use
   // process per site, since all instances can make synchronous calls to the
   // background window.  Other extensions should use process per site as well.
   return true;
 }
@@ skipping 641 matching lines @@
 
   // Skip showing the infobar if the request comes from an extension, and that
   // extension has the 'notify' permission. (If the extension does not have the
   // permission, the user will still be prompted.)
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   ExtensionService* service = profile->GetExtensionService();
   const Extension* extension = !service ? NULL :
       service->extensions()->GetExtensionOrAppByURL(ExtensionURLInfo(
           source_origin));
   if (extension &&
-      extension->HasAPIPermission(ExtensionAPIPermission::kNotification)) {
+      extension->HasAPIPermission(APIPermission::kNotification)) {
     RenderViewHost* rvh =
         RenderViewHost::FromID(render_process_id, render_view_id);
     if (rvh)
       rvh->DesktopNotificationPermissionRequestDone(callback_context);
     return;
   }
 
   DesktopNotificationService* notifications =
       DesktopNotificationServiceFactory::GetForProfile(profile);
   notifications->RequestPermission(source_origin, render_process_id,
       render_view_id, callback_context, contents);
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 WebKit::WebNotificationPresenter::Permission
     ChromeContentBrowserClient::CheckDesktopNotificationPermission(
         const GURL& source_origin,
         content::ResourceContext* context,
         int render_process_id) {
 #if defined(ENABLE_NOTIFICATIONS)
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
   if (io_data->GetExtensionInfoMap()->SecurityOriginHasAPIPermission(
         source_origin, render_process_id,
-        ExtensionAPIPermission::kNotification))
+        APIPermission::kNotification))
     return WebKit::WebNotificationPresenter::PermissionAllowed;
 
   // Fall back to the regular notification preferences, which works on an
   // origin basis.
   return io_data->GetNotificationService() ?
       io_data->GetNotificationService()->HasPermission(source_origin) :
       WebKit::WebNotificationPresenter::PermissionNotAllowed;
 #else
   return WebKit::WebNotificationPresenter::PermissionAllowed;
 #endif
@@ skipping 61 matching lines @@
 
   // If the opener is trying to create a background window but doesn't have
   // the appropriate permission, fail the attempt.
   if (container_type == WINDOW_CONTAINER_TYPE_BACKGROUND) {
     ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
     ExtensionInfoMap* map = io_data->GetExtensionInfoMap();
 
     if (!map->SecurityOriginHasAPIPermission(
             source_origin,
             render_process_id,
-            ExtensionAPIPermission::kBackground)) {
+            APIPermission::kBackground)) {
       return false;
     }
 
     // Note: this use of GetExtensionOrAppByURL is safe but imperfect.  It may
     // return a recently installed Extension even if this CanCreateWindow call
     // was made by an old copy of the page in a normal web process.  That's ok,
     // because the permission check above would have caused an early return
     // already. We must use the full URL to find hosted apps, though, and not
     // just the origin.
     const Extension* extension = map->extensions().GetExtensionOrAppByURL(
@@ skipping 288 matching lines @@
     StringTokenizer t(allowed_list, ",");
     while (t.GetNext()) {
       if (t.token() == host)
         return true;
     }
   }
 
   if (!extension)
     return false;
 
-  if (extension->HasAPIPermission(ExtensionAPIPermission::kSocket))
+  if (extension->HasAPIPermission(APIPermission::kSocket))
     return true;
 
   return false;
 }
 
 bool ChromeContentBrowserClient::AllowPepperPrivateFileAPI() {
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kPpapiFlashInProcess);
 }
 
@@ skipping 43 matching lines @@
     io_thread_application_locale_ = locale;
 }
 
 void ChromeContentBrowserClient::SetApplicationLocaleOnIOThread(
     const std::string& locale) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   io_thread_application_locale_ = locale;
 }
 
 }  // namespace chrome