Refactor and fix declarative webRequest API permissions

chrome/browser/extensions/api/web_request/web_request_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/web_request/web_request_api.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
@@ skipping 437 matching lines @@
 }
 
 ExtensionWebRequestEventRouter::ExtensionWebRequestEventRouter()
     : request_time_tracker_(new ExtensionWebRequestTimeTracker) {
 }
 
 ExtensionWebRequestEventRouter::~ExtensionWebRequestEventRouter() {
 }
 
 void ExtensionWebRequestEventRouter::RegisterRulesRegistry(
+    void* profile,
     scoped_refptr<extensions::WebRequestRulesRegistry> rules_registry) {
-  rules_registry_ = rules_registry;
+  if (rules_registry.get())
+    rules_registries_[profile] = rules_registry;
+  else
+    rules_registries_.erase(profile);
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeRequest(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     GURL* new_url) {
   // We hide events from the system context as well as sensitive requests.
-  if (!profile || helpers::HideRequest(request))
+  if (!profile || WebRequestPermissions::HideRequest(request))
     return net::OK;
 
   if (IsPageLoad(request))
     NotifyPageLoad();
 
   request_time_tracker_->LogRequestStartTime(request->identifier(),
                                              base::Time::Now(),
                                              request->url(),
                                              profile);
 
@@ skipping 38 matching lines @@
   }
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeSendHeaders(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     net::HttpRequestHeaders* headers) {
   // We hide events from the system context as well as sensitive requests.
-  if (!profile || helpers::HideRequest(request))
+  if (!profile || WebRequestPermissions::HideRequest(request))
     return net::OK;
 
   bool initialize_blocked_requests = false;
 
   initialize_blocked_requests |=
       ProcessDeclarativeRules(profile, extension_info_map,
                               keys::kOnBeforeSendHeaders, request,
                               extensions::ON_BEFORE_SEND_HEADERS, NULL);
 
   int extra_info_spec = 0;
@@ skipping 31 matching lines @@
     return net::ERR_IO_PENDING;
   }
 }
 
 void ExtensionWebRequestEventRouter::OnSendHeaders(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const net::HttpRequestHeaders& headers) {
   // We hide events from the system context as well as sensitive requests.
-  if (!profile || helpers::HideRequest(request))
+  if (!profile || WebRequestPermissions::HideRequest(request))
     return;
 
   if (GetAndSetSignaled(request->identifier(), kOnSendHeaders))
     return;
 
   ClearSignaled(request->identifier(), kOnBeforeRedirect);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map,
@@ skipping 12 matching lines @@
 }
 
 int ExtensionWebRequestEventRouter::OnHeadersReceived(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers) {
   // We hide events from the system context as well as sensitive requests.
-  if (!profile || helpers::HideRequest(request))
+  if (!profile || WebRequestPermissions::HideRequest(request))
     return net::OK;
 
   bool initialize_blocked_requests = false;
 
   initialize_blocked_requests |=
       ProcessDeclarativeRules(profile, extension_info_map,
                               keys::kOnHeadersReceived, request,
                               extensions::ON_HEADERS_RECEIVED,
                               original_response_headers);
 
@@ skipping 44 matching lines @@
 net::NetworkDelegate::AuthRequiredResponse
 ExtensionWebRequestEventRouter::OnAuthRequired(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const net::AuthChallengeInfo& auth_info,
     const net::NetworkDelegate::AuthCallback& callback,
     net::AuthCredentials* credentials) {
   // No profile means that this is for authentication challenges in the
   // system context. Skip in that case. Also skip sensitive requests.
-  if (!profile || helpers::HideRequest(request))
+  if (!profile || WebRequestPermissions::HideRequest(request))
     return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map,
                            keys::kOnAuthRequired, request, &extra_info_spec);
   if (listeners.empty())
     return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 
   ListValue args;
@@ skipping 24 matching lines @@
   }
   return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 }
 
 void ExtensionWebRequestEventRouter::OnBeforeRedirect(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const GURL& new_location) {
   // We hide events from the system context as well as sensitive requests.
-  if (!profile || helpers::HideRequest(request))
+  if (!profile || WebRequestPermissions::HideRequest(request))
     return;
 
   if (GetAndSetSignaled(request->identifier(), kOnBeforeRedirect))
     return;
 
   ClearSignaled(request->identifier(), kOnBeforeRequest);
   ClearSignaled(request->identifier(), kOnBeforeSendHeaders);
   ClearSignaled(request->identifier(), kOnSendHeaders);
   ClearSignaled(request->identifier(), kOnHeadersReceived);
 
@@ skipping 24 matching lines @@
   args.Append(dict);
 
   DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnResponseStarted(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request) {
   // We hide events from the system context as well as sensitive requests.
-  if (!profile || helpers::HideRequest(request))
+  if (!profile || WebRequestPermissions::HideRequest(request))
     return;
 
   // OnResponseStarted is even triggered, when the request was cancelled.
   if (request->status().status() != net::URLRequestStatus::SUCCESS)
     return;
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map,
                            keys::kOnResponseStarted, request, &extra_info_spec);
@@ skipping 22 matching lines @@
   args.Append(dict);
 
   DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnCompleted(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request) {
   // We hide events from the system context as well as sensitive requests.
-  if (!profile || helpers::HideRequest(request))
+  if (!profile || WebRequestPermissions::HideRequest(request))
     return;
 
   request_time_tracker_->LogRequestEndTime(request->identifier(),
                                            base::Time::Now());
 
   DCHECK(request->status().status() == net::URLRequestStatus::SUCCESS);
 
   DCHECK(!GetAndSetSignaled(request->identifier(), kOnCompleted));
 
   ClearPendingCallbacks(request);
@@ skipping 28 matching lines @@
 
   DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnErrorOccurred(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     bool started) {
   // We hide events from the system context as well as sensitive requests.
-  if (!profile || helpers::HideRequest(request))
+  if (!profile || WebRequestPermissions::HideRequest(request))
     return;
 
   request_time_tracker_->LogRequestEndTime(request->identifier(),
                                            base::Time::Now());
 
   DCHECK(request->status().status() == net::URLRequestStatus::FAILED ||
          request->status().status() == net::URLRequestStatus::CANCELED);
 
   DCHECK(!GetAndSetSignaled(request->identifier(), kOnErrorOccurred));
 
@@ skipping 209 matching lines @@
 
 void ExtensionWebRequestEventRouter::NotifyPageLoad() {
   for (CallbacksForPageLoad::const_iterator i =
            callbacks_for_page_load_.begin();
        i != callbacks_for_page_load_.end(); ++i) {
     i->Run();
   }
   callbacks_for_page_load_.clear();
 }
 
+void* ExtensionWebRequestEventRouter::GetCrossProfile(void* profile) const {
+  CrossProfileMap::const_iterator cross_profile =
+      cross_profile_map_.find(profile);
+  if (cross_profile == cross_profile_map_.end())
+    return NULL;
+  return cross_profile->second;
+}
+
 void ExtensionWebRequestEventRouter::GetMatchingListenersImpl(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     bool crosses_incognito,
     const std::string& event_name,
     const GURL& url,
     int tab_id,
     int window_id,
     ResourceType::Type resource_type,
     bool is_request_from_extension,
@@ skipping 13 matching lines @@
       continue;
     if (it->filter.tab_id != -1 && tab_id != it->filter.tab_id)
       continue;
     if (it->filter.window_id != -1 && window_id != it->filter.window_id)
       continue;
     if (!it->filter.types.empty() &&
         std::find(it->filter.types.begin(), it->filter.types.end(),
                   resource_type) == it->filter.types.end())
       continue;
 
-    // extension_info_map can be NULL if this is a system-level request.
-    if (extension_info_map) {
-      const Extension* extension =
-          extension_info_map->extensions().GetByID(it->extension_id);
+    if (!WebRequestPermissions::CanExtensionAccessURL(
+            extension_info_map, it->extension_id, url, crosses_incognito, true))
+      continue;
 
-      // Check if this event crosses incognito boundaries when it shouldn't.
-      if (!extension ||
-          (crosses_incognito &&
-           !extension_info_map->CanCrossIncognito(extension)))
-        continue;
+    bool blocking_listener =
+        (it->extra_info_spec &
+            (ExtraInfoSpec::BLOCKING | ExtraInfoSpec::ASYNC_BLOCKING)) != 0;
 
-      bool blocking_listener =
-          (it->extra_info_spec &
-              (ExtraInfoSpec::BLOCKING | ExtraInfoSpec::ASYNC_BLOCKING)) != 0;
+    // We do not want to notify extensions about XHR requests that are
+    // triggered by themselves. This is a workaround to prevent deadlocks
+    // in case of synchronous XHR requests that block the extension renderer
+    // and therefore prevent the extension from processing the request
+    // handler. This is only a problem for blocking listeners.
+    // http://crbug.com/105656
+    bool possibly_synchronous_xhr_from_extension =
+        is_request_from_extension && resource_type == ResourceType::XHR;
 
-      // We do not want to notify extensions about XHR requests that are
-      // triggered by themselves. This is a workaround to prevent deadlocks
-      // in case of synchronous XHR requests that block the extension renderer
-      // and therefore prevent the extension from processing the request
-      // handler. This is only a problem for blocking listeners.
-      // http://crbug.com/105656
-      bool possibly_synchronous_xhr_from_extension =
-          is_request_from_extension && resource_type == ResourceType::XHR;
-
-      // Only send webRequest events for URLs the extension has access to.
-      if (!helpers::CanExtensionAccessURL(extension, url) ||
-          (blocking_listener && possibly_synchronous_xhr_from_extension)) {
-        continue;
-      }
-    }
+    // Only send webRequest events for URLs the extension has access to.
+    if (blocking_listener && possibly_synchronous_xhr_from_extension)
+      continue;
 
     matching_listeners->push_back(&(*it));
     *extra_info_spec |= it->extra_info_spec;
   }
 }
 
 std::vector<const ExtensionWebRequestEventRouter::EventListener*>
 ExtensionWebRequestEventRouter::GetMatchingListeners(
     void* profile,
     ExtensionInfoMap* extension_info_map,
@@ skipping 19 matching lines @@
   std::vector<const ExtensionWebRequestEventRouter::EventListener*>
       matching_listeners;
 
   bool is_request_from_extension =
       IsRequestFromExtension(request, extension_info_map);
 
   GetMatchingListenersImpl(
       profile, extension_info_map, false, event_name, url,
       tab_id, window_id, resource_type, is_request_from_extension,
       extra_info_spec, &matching_listeners);
-  CrossProfileMap::const_iterator cross_profile =
-      cross_profile_map_.find(profile);
-  if (cross_profile != cross_profile_map_.end()) {
+  void* cross_profile = GetCrossProfile(profile);
+  if (cross_profile) {
     GetMatchingListenersImpl(
-        cross_profile->second, extension_info_map, true, event_name, url,
-        tab_id, window_id, resource_type, is_request_from_extension,
-        extra_info_spec, &matching_listeners);
+        cross_profile, extension_info_map, true, event_name, url, tab_id,
+        window_id, resource_type, is_request_from_extension, extra_info_spec,
+        &matching_listeners);
   }
 
   return matching_listeners;
 }
 
 namespace {
 
 helpers::EventResponseDelta* CalculateDelta(
     ExtensionWebRequestEventRouter::BlockedRequest* blocked_request,
     ExtensionWebRequestEventRouter::EventResponse* response) {
@@ skipping 185 matching lines @@
   return rv;
 }
 
 bool ExtensionWebRequestEventRouter::ProcessDeclarativeRules(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     const std::string& event_name,
     net::URLRequest* request,
     extensions::RequestStages request_stage,
     net::HttpResponseHeaders* original_response_headers) {
-  if (!rules_registry_.get())
-    return false;
+  // Rules of the current |profile| may apply but we need to check also whether
+  // there are applicable rules from extensions whose background page
+  // spans from regular to incognito mode.
+
+  // First parameter identifies the registry, the second indicates whether the
+  // registry belongs to the cross profile.
+  typedef std::pair<extensions::WebRequestRulesRegistry*, bool>
+      RelevantRegistry;
+  typedef std::vector<RelevantRegistry> RelevantRegistries;
+  RelevantRegistries relevant_registries;
+
+  if (rules_registries_.find(profile) != rules_registries_.end()) {
+    relevant_registries.push_back(
+        std::make_pair(rules_registries_[profile].get(), false));
+  }
+
+  void* cross_profile = GetCrossProfile(profile);
+  if (cross_profile &&
+      rules_registries_.find(cross_profile) != rules_registries_.end()) {
+    relevant_registries.push_back(
+        std::make_pair(rules_registries_[cross_profile].get(), true));
+  }
 
   // TODO(mpcomplete): Eventually we'll want to turn this on, but for now,
   // we won't block startup for declarative webrequest. I want to measure
   // its effect first.
 #if defined(BLOCK_STARTUP_ON_DECLARATIVE_RULES)
-  if (!rules_registry_->IsReady()) {
-    // The rules registry is still loading. Block this request until it
-    // finishes.
-    rules_registry_->AddReadyCallback(
-        base::Bind(&ExtensionWebRequestEventRouter::OnRulesRegistryReady,
-                   AsWeakPtr(), profile, event_name, request->identifier(),
-                   request_stage));
-    blocked_requests_[request->identifier()].num_handlers_blocking++;
-    blocked_requests_[request->identifier()].request = request;
-    blocked_requests_[request->identifier()].blocking_time = base::Time::Now();
-    blocked_requests_[request->identifier()].original_response_headers =
-        original_response_headers;
-    blocked_requests_[request->identifier()].extension_info_map =
-        extension_info_map;
-    return true;
+  for (RelevantRegistries::iterator i = relevant_registries.begin();
+       i != relevant_registries.end(); ++i) {
+    extensions::WebRequestRulesRegistry* rules_registry = i->first;
+    if (!rules_registry->IsReady()) {
+      // The rules registry is still loading. Block this request until it
+      // finishes.
+      rules_registry->AddReadyCallback(
+          base::Bind(&ExtensionWebRequestEventRouter::OnRulesRegistryReady,
+                     AsWeakPtr(), profile, event_name, request->identifier(),
+                     request_stage));
+      blocked_requests_[request->identifier()].num_handlers_blocking++;
+      blocked_requests_[request->identifier()].request = request;
+      blocked_requests_[request->identifier()].blocking_time =
+          base::Time::Now();
+      blocked_requests_[request->identifier()].original_response_headers =
+          original_response_headers;
+      blocked_requests_[request->identifier()].extension_info_map =
+          extension_info_map;
+      return true;
+    }
   }
 #endif
 
   base::Time start = base::Time::Now();
 
-  extensions::WebRequestRule::OptionalRequestData optional_request_data;
-  optional_request_data.original_response_headers =
-      original_response_headers;
-  helpers::EventResponseDeltas result =
-      rules_registry_->CreateDeltas(extension_info_map, request,
-                                    request_stage, optional_request_data);
+  bool deltas_created = false;
+  for (RelevantRegistries::iterator i = relevant_registries.begin();
+       i != relevant_registries.end(); ++i) {
+    extensions::WebRequestRulesRegistry* rules_registry =
+        i->first;
+    extensions::WebRequestRule::OptionalRequestData optional_request_data;
+    optional_request_data.original_response_headers =
+        original_response_headers;
+    helpers::EventResponseDeltas result =
+        rules_registry->CreateDeltas(extension_info_map, request,
+            i->second, request_stage, optional_request_data);
+
+    if (!result.empty()) {
+      helpers::EventResponseDeltas& deltas =
+          blocked_requests_[request->identifier()].response_deltas;
+      deltas.insert(deltas.end(), result.begin(), result.end());
+      deltas_created = true;
+    }
+  }
 
   base::TimeDelta elapsed_time = start - base::Time::Now();
   UMA_HISTOGRAM_TIMES("Extensions.DeclarativeWebRequestNetworkDelay",
                       elapsed_time);
 
-  if (result.empty())
-    return false;
-
-  helpers::EventResponseDeltas& deltas =
-      blocked_requests_[request->identifier()].response_deltas;
-  deltas.insert(deltas.end(), result.begin(), result.end());
-  return true;
+  return deltas_created;
 }
 
 void ExtensionWebRequestEventRouter::OnRulesRegistryReady(
     void* profile,
     const std::string& event_name,
     uint64 request_id,
     extensions::RequestStages request_stage) {
   // It's possible that this request was deleted, or cancelled by a previous
   // event handler. If so, ignore this response.
   if (blocked_requests_.find(request_id) == blocked_requests_.end())
@@ skipping 328 matching lines @@
       } else if ((*it)->name().find("AdBlock") != std::string::npos) {
         adblock = true;
       } else {
         other = true;
       }
     }
   }
 
   host->Send(new ExtensionMsg_UsingWebRequestAPI(adblock, adblock_plus, other));
 }