Add support for response header manipulation in Declarative WebRequest API

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"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_content_browser_client.h"
+#include "chrome/browser/extensions/api/declarative_webrequest/webrequest_rule.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_constants.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
 #include "chrome/browser/extensions/api/web_request/web_request_time_tracker.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_id_map.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 452 matching lines @@
 
   request_time_tracker_->LogRequestStartTime(request->identifier(),
                                              base::Time::Now(),
                                              request->url(),
                                              profile);
 
   // Whether to initialized blocked_requests_.
   bool initialize_blocked_requests = false;
 
   initialize_blocked_requests |=
-      ProcessDeclarativeRules(request, extensions::ON_BEFORE_REQUEST);
+      ProcessDeclarativeRules(request, extensions::ON_BEFORE_REQUEST, NULL);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map, keys::kOnBeforeRequest,
                            request, &extra_info_spec);
   if (!listeners.empty() &&
       !GetAndSetSignaled(request->identifier(), kOnBeforeRequest)) {
     ListValue args;
     DictionaryValue* dict = new DictionaryValue();
     ExtractRequestInfo(request, dict);
@@ skipping 27 matching lines @@
     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::HideRequestForURL(request->url()))
     return net::OK;
 
   bool initialize_blocked_requests = false;
 
   initialize_blocked_requests |=
-      ProcessDeclarativeRules(request, extensions::ON_BEFORE_SEND_HEADERS);
+      ProcessDeclarativeRules(request, extensions::ON_BEFORE_SEND_HEADERS,
+                              NULL);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map,
                            keys::kOnBeforeSendHeaders, request,
                            &extra_info_spec);
   if (!listeners.empty() &&
       !GetAndSetSignaled(request->identifier(), kOnBeforeSendHeaders)) {
     ListValue args;
     DictionaryValue* dict = new DictionaryValue();
@@ skipping 59 matching lines @@
     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::HideRequestForURL(request->url()))
     return net::OK;
 
+  bool initialize_blocked_requests = false;
+
+  initialize_blocked_requests |=
+      ProcessDeclarativeRules(request, extensions::ON_HEADERS_RECEIVED,
+                              original_response_headers);
+
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map,
                            keys::kOnHeadersReceived, request,
                            &extra_info_spec);
 
-  if (listeners.empty())
-    return net::OK;
+  if (!listeners.empty() &&
+      !GetAndSetSignaled(request->identifier(), kOnHeadersReceived)) {
+    ListValue args;
+    DictionaryValue* dict = new DictionaryValue();
+    ExtractRequestInfo(request, dict);
+    dict->SetString(keys::kStatusLineKey,
+        original_response_headers->GetStatusLine());
+    if (extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS) {
+      dict->Set(keys::kResponseHeadersKey,
+          GetResponseHeadersList(original_response_headers));
+    }
+    args.Append(dict);
 
-  if (GetAndSetSignaled(request->identifier(), kOnHeadersReceived))
-    return net::OK;
+    initialize_blocked_requests |=
+        DispatchEvent(profile, request, listeners, args);
+  }
 
-  ListValue args;
-  DictionaryValue* dict = new DictionaryValue();
-  ExtractRequestInfo(request, dict);
-  dict->SetString(keys::kStatusLineKey,
-      original_response_headers->GetStatusLine());
-  if (extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS) {
-    dict->Set(keys::kResponseHeadersKey,
-        GetResponseHeadersList(original_response_headers));
-  }
-  args.Append(dict);
+  if (!initialize_blocked_requests)
+    return net::OK;  // Nobody saw a reason for modifying the request.
 
-  if (DispatchEvent(profile, request, listeners, args)) {
-    blocked_requests_[request->identifier()].event = kOnHeadersReceived;
-    blocked_requests_[request->identifier()].callback = callback;
-    blocked_requests_[request->identifier()].net_log = &request->net_log();
-    blocked_requests_[request->identifier()].override_response_headers =
-        override_response_headers;
-    blocked_requests_[request->identifier()].original_response_headers =
-        original_response_headers;
+  blocked_requests_[request->identifier()].event = kOnHeadersReceived;
+  blocked_requests_[request->identifier()].callback = callback;
+  blocked_requests_[request->identifier()].net_log = &request->net_log();
+  blocked_requests_[request->identifier()].override_response_headers =
+      override_response_headers;
+  blocked_requests_[request->identifier()].original_response_headers =
+      original_response_headers;
+
+  if (blocked_requests_[request->identifier()].num_handlers_blocking == 0) {
+    // If there are no blocking handlers, only the declarative rules tried
+    // to modify the request and we can respond synchronously.
+    return ExecuteDeltas(profile, request->identifier(),
+                         false /* call_callback*/);
+  } else {
     return net::ERR_IO_PENDING;
   }
-  return net::OK;
 }
 
 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) {
@@ skipping 714 matching lines @@
     if (call_callback)
       callback.Run(response);
   } else {
     blocked_requests_.erase(request_id);
   }
   return rv;
 }
 
 bool ExtensionWebRequestEventRouter::ProcessDeclarativeRules(
     net::URLRequest* request,
-    extensions::RequestStages request_stage) {
+    extensions::RequestStages request_stage,
+    net::HttpResponseHeaders* original_response_headers) {
   if (!rules_registry_.get())
     return false;
 
   base::Time start = base::Time::Now();
 
   // TODO(battre): Annotate deltas with extension IDs, so that we can
   // - Sort deltas by precedence
   // - Check whether extensions have host permissions.
+  extensions::WebRequestRule::OptionalRequestData optional_request_data;
+  optional_request_data.original_response_headers =
+      original_response_headers;
   std::list<linked_ptr<helpers::EventResponseDelta> > result =
-      rules_registry_->CreateDeltas(request, request_stage);
+      rules_registry_->CreateDeltas(request, request_stage,
+                                    optional_request_data);
 
   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;
@@ skipping 322 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));
 }