Refactor and fix declarative webRequest API permissions

chrome/browser/extensions/api/declarative_webrequest/webrequest_action.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_WEBREQUEST_WEBREQUEST_ACTION_H_
 #define CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_WEBREQUEST_WEBREQUEST_ACTION_H_
 
 #include <list>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/linked_ptr.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/request_stages.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_rule.h"
 #include "chrome/common/extensions/api/events.h"
 #include "googleurl/src/gurl.h"
 #include "unicode/regex.h"
 
+class WebRequestPermission;
+
 namespace base {
 class DictionaryValue;
 class Time;
 class Value;
 }
 
 namespace extension_web_request_api_helpers {
 struct EventResponseDelta;
 }
 
@@ skipping 35 matching lines @@
   // contains a 1 for each request stage during which the condition can be
   // tested.
   virtual int GetStages() const = 0;
 
   virtual Type GetType() const = 0;
 
   // Returns the minimum priority of rules that may be evaluated after
   // this rule. Defaults to MIN_INT.
   virtual int GetMinimumPriority() const;
 
-  // Returns whether |extension| has permission to execute this action
-  // on |request|. Defaults to checking the host permission.
-  // |extension| may only be NULL for during testing, in which case
-  // host permissions are ignored.
-  virtual bool HasPermission(const extensions::Extension* extension,
-                             const net::URLRequest* request) const;
+  // Returns whether the specified extension has permission to execute this
+  // action on |request|. Checks the host permission if
+  // ShouldEnforceHostPermissions instructs to do that.
+  // |extension_info_map| may only be NULL for during testing, in which case
+  // host permissions are ignored. |crosses_incognito| specifies
+  // whether the request comes from a different profile than |extension_id|
+  // but was processed because the extension is in spanning mode.
+  virtual bool HasPermission(const ExtensionInfoMap* extension_info_map,
+                             const std::string& extension_id,
+                             const net::URLRequest* request,
+                             bool crosses_incognito) const;
+
+  // Returns whether host permissions shall be enforced by this actions.
+  // Used by the standard implementation of HasPermission. Defaults to true.
+  virtual bool ShouldEnforceHostPermissions() const;
 
   // Factory method that instantiates a concrete WebRequestAction
   // implementation according to |json_action|, the representation of the
   // WebRequestAction as received from the extension API.
   // Sets |error| and returns NULL in case of a semantic error that cannot
   // be caught by schema validation. Sets |bad_message| and returns NULL
   // in case the input is syntactically unexpected.
   static scoped_ptr<WebRequestAction> Create(const base::Value& json_action,
                                              std::string* error,
                                              bool* bad_message);
@@ skipping 25 matching lines @@
   // |actions| which represents the array of actions received from the
   // extension API.
   static scoped_ptr<WebRequestActionSet> Create(const AnyVector& actions,
                                                 std::string* error,
                                                 bool* bad_message);
 
   // Returns a description of the modifications to |request| caused by the
   // |actions_| that can be executed at |request_stage|. If |extension|
   // is not NULL, permissions of extensions are checked.
   std::list<LinkedPtrEventResponseDelta> CreateDeltas(
-      const extensions::Extension* extension,
+      const ExtensionInfoMap* extension_info_map,
+      const std::string& extension_id,
       net::URLRequest* request,
+      bool crosses_incognito,
       RequestStages request_stage,
       const WebRequestRule::OptionalRequestData& optional_request_data,
-      const std::string& extension_id,
       const base::Time& extension_install_time) const;
 
   // Returns the minimum priority of rules that may be evaluated after
   // this rule. Defaults to MIN_INT.
   int GetMinimumPriority() const;
 
   const Actions& actions() const { return actions_; }
 
  private:
   Actions actions_;
@@ skipping 49 matching lines @@
 
 // Action that instructs to redirect a network request to a transparent image.
 class WebRequestRedirectToTransparentImageAction : public WebRequestAction {
  public:
   WebRequestRedirectToTransparentImageAction();
   virtual ~WebRequestRedirectToTransparentImageAction();
 
   // Implementation of WebRequestAction:
   virtual int GetStages() const OVERRIDE;
   virtual Type GetType() const OVERRIDE;
-  virtual bool HasPermission(const extensions::Extension* extension,
-                             const net::URLRequest* request) const OVERRIDE;
+  virtual bool ShouldEnforceHostPermissions() const OVERRIDE;
   virtual LinkedPtrEventResponseDelta CreateDelta(
       net::URLRequest* request,
       RequestStages request_stage,
       const WebRequestRule::OptionalRequestData& optional_request_data,
       const std::string& extension_id,
       const base::Time& extension_install_time) const OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebRequestRedirectToTransparentImageAction);
 };
 
 
 // Action that instructs to redirect a network request to an empty document.
 class WebRequestRedirectToEmptyDocumentAction : public WebRequestAction {
  public:
   WebRequestRedirectToEmptyDocumentAction();
   virtual ~WebRequestRedirectToEmptyDocumentAction();
 
   // Implementation of WebRequestAction:
   virtual int GetStages() const OVERRIDE;
   virtual Type GetType() const OVERRIDE;
-  virtual bool HasPermission(const extensions::Extension* extension,
-                             const net::URLRequest* request) const OVERRIDE;
+  virtual bool ShouldEnforceHostPermissions() const OVERRIDE;
   virtual LinkedPtrEventResponseDelta CreateDelta(
       net::URLRequest* request,
       RequestStages request_stage,
       const WebRequestRule::OptionalRequestData& optional_request_data,
       const std::string& extension_id,
       const base::Time& extension_install_time) const OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebRequestRedirectToEmptyDocumentAction);
 };
@@ skipping 124 matching lines @@
 // Action that instructs to ignore rules below a certain priority.
 class WebRequestIgnoreRulesAction : public WebRequestAction {
  public:
   explicit WebRequestIgnoreRulesAction(int minimum_priority);
   virtual ~WebRequestIgnoreRulesAction();
 
   // Implementation of WebRequestAction:
   virtual int GetStages() const OVERRIDE;
   virtual Type GetType() const OVERRIDE;
   virtual int GetMinimumPriority() const OVERRIDE;
-  virtual bool HasPermission(const extensions::Extension* extension,
-                             const net::URLRequest* request) const OVERRIDE;
+  virtual bool ShouldEnforceHostPermissions() const OVERRIDE;
   virtual LinkedPtrEventResponseDelta CreateDelta(
       net::URLRequest* request,
       RequestStages request_stage,
       const WebRequestRule::OptionalRequestData& optional_request_data,
       const std::string& extension_id,
       const base::Time& extension_install_time) const OVERRIDE;
 
  private:
   int minimum_priority_;
   DISALLOW_COPY_AND_ASSIGN(WebRequestIgnoreRulesAction);
 };
 
 // TODO(battre) Implement further actions:
 // Redirect by RegEx, Cookie manipulations, ...
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_WEBREQUEST_WEBREQUEST_ACTION_H_