Refactor PermissionsData pt1

chrome/browser/extensions/api/tabs/tabs_api.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/api/tabs/tabs_api.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 1160 matching lines @@
   // Don't let the extension crash the browser or renderers.
   if (ExtensionTabUtil::IsCrashURL(url)) {
     error_ = keys::kNoCrashBrowserError;
     return false;
   }
 
   // JavaScript URLs can do the same kinds of things as cross-origin XHR, so
   // we need to check host permissions before allowing them.
   if (url.SchemeIs(url::kJavaScriptScheme)) {
     content::RenderProcessHost* process = web_contents_->GetRenderProcessHost();
-    if (!PermissionsData::CanExecuteScriptOnPage(
-            GetExtension(),
-            web_contents_->GetURL(),
-            web_contents_->GetURL(),
-            tab_id,
-            NULL,
-            process ? process->GetID() : -1,
-            &error_)) {
+    if (!PermissionsData::ForExtension(GetExtension())
+             ->CanExecuteScriptOnPage(GetExtension(),
+                                      web_contents_->GetURL(),
+                                      web_contents_->GetURL(),
+                                      tab_id,
+                                      NULL,
+                                      process ? process->GetID() : -1,
+                                      &error_)) {
       return false;
     }
 
     TabHelper::FromWebContents(web_contents_)->script_executor()->ExecuteScript(
         extension_id(),
         ScriptExecutor::JAVASCRIPT,
         url.GetContent(),
         ScriptExecutor::TOP_FRAME,
         ScriptExecutor::DONT_MATCH_ABOUT_BLANK,
         UserScript::DOCUMENT_IDLE,
@@ skipping 298 matching lines @@
   Browser* browser = NULL;
   if (!GetBrowserFromWindowID(this, window_id, &browser))
     return NULL;
 
   WebContents* contents = browser->tab_strip_model()->GetActiveWebContents();
   if (!contents) {
     error_ = keys::kInternalVisibleTabCaptureError;
     return NULL;
   }
 
-  if (!PermissionsData::CanCaptureVisiblePage(GetExtension(),
-                                              SessionID::IdForTab(contents),
-                                              &error_)) {
+  if (!PermissionsData::ForExtension(GetExtension())
+           ->CanCaptureVisiblePage(SessionID::IdForTab(contents), &error_)) {
     return NULL;
   }
   return contents;
 }
 
 void TabsCaptureVisibleTabFunction::OnCaptureFailure(FailureReason reason) {
   error_ = keys::kInternalVisibleTabCaptureError;
   SendResponse(false);
 }
 
@@ skipping 95 matching lines @@
   Release();  // Balanced in Run()
 }
 
 ExecuteCodeInTabFunction::ExecuteCodeInTabFunction()
     : execute_tab_id_(-1) {
 }
 
 ExecuteCodeInTabFunction::~ExecuteCodeInTabFunction() {}
 
 bool ExecuteCodeInTabFunction::HasPermission() {
-  if (Init() && PermissionsData::HasAPIPermissionForTab(
-                    extension_.get(), execute_tab_id_, APIPermission::kTab)) {
+  if (Init() &&
+      PermissionsData::ForExtension(extension_)
+          ->HasAPIPermissionForTab(execute_tab_id_, APIPermission::kTab)) {
     return true;
   }
   return ExtensionFunction::HasPermission();
 }
 
 bool ExecuteCodeInTabFunction::CanExecuteScriptOnPage() {
   content::WebContents* contents = NULL;
 
   // If |tab_id| is specified, look for the tab. Otherwise default to selected
   // tab in the current window.
   CHECK_GE(execute_tab_id_, 0);
   if (!GetTabById(execute_tab_id_,
                   GetProfile(),
                   include_incognito(),
                   NULL,
                   NULL,
                   &contents,
                   NULL,
                   &error_)) {
     return false;
   }
 
   CHECK(contents);
 
   // NOTE: This can give the wrong answer due to race conditions, but it is OK,
   // we check again in the renderer.
   content::RenderProcessHost* process = contents->GetRenderProcessHost();
-  if (!PermissionsData::CanExecuteScriptOnPage(
-          GetExtension(),
-          contents->GetURL(),
-          contents->GetURL(),
-          execute_tab_id_,
-          NULL,
-          process ? process->GetID() : -1,
-          &error_)) {
+  if (!PermissionsData::ForExtension(GetExtension())
+           ->CanExecuteScriptOnPage(GetExtension(),
+                                    contents->GetURL(),
+                                    contents->GetURL(),
+                                    execute_tab_id_,
+                                    NULL,
+                                    process ? process->GetID() : -1,
+                                    &error_)) {
     return false;
   }
 
   return true;
 }
 
 ScriptExecutor* ExecuteCodeInTabFunction::GetScriptExecutor() {
   Browser* browser = NULL;
   content::WebContents* contents = NULL;
 
@@ skipping 67 matching lines @@
   execute_tab_id_ = tab_id;
   details_ = details.Pass();
   return true;
 }
 
 bool TabsInsertCSSFunction::ShouldInsertCSS() const {
   return true;
 }
 
 }  // namespace extensions