Refactor and fix declarative webRequest API permissions

chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry.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/declarative_webrequest/webrequest_rules_registry.h"
 
 #include <limits>
 
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_condition.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
+#include "chrome/browser/extensions/api/web_request/web_request_permissions.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "net/url_request/url_request.h"
 
 namespace extensions {
 
 WebRequestRulesRegistry::WebRequestRulesRegistry(Profile* profile,
                                                  Delegate* delegate)
     : RulesRegistryWithCache(delegate) {
   if (profile)
     extension_info_map_ = ExtensionSystem::Get(profile)->info_map();
@@ skipping 18 matching lines @@
     WebRequestRule* rule = rule_trigger->second;
     if (rule->conditions().IsFulfilled(*url_match, request, request_stage))
       result.insert(rule->id());
   }
   return result;
 }
 
 std::list<LinkedPtrEventResponseDelta> WebRequestRulesRegistry::CreateDeltas(
     const ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
+    bool crosses_incognito,
     RequestStages request_stage,
     const WebRequestRule::OptionalRequestData& optional_request_data) {
   if (webrequest_rules_.empty())
     return std::list<LinkedPtrEventResponseDelta>();
 
   std::set<WebRequestRule::GlobalRuleId> matches =
       GetMatches(request, request_stage);
 
   // Sort all matching rules by their priority so that they can be processed
   // in decreasing order.
@@ skipping 26 matching lines @@
 
   // Create deltas until we have passed the minimum priority.
   std::list<LinkedPtrEventResponseDelta> result;
   for (std::vector<PriorityRuleIdPair>::iterator i = ordered_matches.begin();
        i != ordered_matches.end(); ++i) {
     const WebRequestRule::Priority priority_of_rule = i->first;
     const WebRequestRule::GlobalRuleId& rule_id = i->second;
     const ExtensionId& extension_id = rule_id.first;
     const WebRequestRule* rule = webrequest_rules_[rule_id].get();
     CHECK(rule);
-    const extensions::Extension* extension = NULL;
-    if (extension_info_map)
-      extension = extension_info_map->extensions().GetByID(extension_id);
 
     // Skip rule if a previous rule of this extension instructed to ignore
     // all rules with a lower priority than min_priorities[extension_id].
     int current_min_priority = min_priorities[extension_id];
     if (priority_of_rule < current_min_priority)
       continue;
 
     std::list<LinkedPtrEventResponseDelta> rule_result =
-        rule->CreateDeltas(extension, request, request_stage,
-                           optional_request_data);
+        rule->CreateDeltas(extension_info_map, request, crosses_incognito,
+                           request_stage, optional_request_data);
     result.splice(result.begin(), rule_result);
 
     min_priorities[extension_id] = std::max(current_min_priority,
                                             rule->GetMinimumPriority());
   }
   return result;
 }
 
 std::string WebRequestRulesRegistry::AddRulesImpl(
     const std::string& extension_id,
@@ skipping 116 matching lines @@
 
 base::Time WebRequestRulesRegistry::GetExtensionInstallationTime(
     const std::string& extension_id) const {
   if (!extension_info_map_.get())  // May be NULL during testing.
     return base::Time();
 
   return extension_info_map_->GetInstallTime(extension_id);
 }
 
 }  // namespace extensions