Do not cancel request when an error occurs in a webRequest event handler

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/bind_helpers.h"
@@ skipping 2211 matching lines @@
 
   helpers::ClearCacheOnNavigation();
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
       &helpers::NotifyWebRequestAPIUsed,
       profile_id(), make_scoped_refptr(GetExtension())));
 
   return true;
 }
 
-void WebRequestEventHandled::CancelWithError(
+void WebRequestEventHandled::RespondWithError(
     const std::string& event_name,
     const std::string& sub_event_name,
     uint64 request_id,
     scoped_ptr<ExtensionWebRequestEventRouter::EventResponse> response,
     const std::string& error) {
   error_ = error;
-  response->cancel = true;
   ExtensionWebRequestEventRouter::GetInstance()->OnEventHandled(
       profile_id(),
       extension_id(),
       event_name,
       sub_event_name,
       request_id,
       response.release());
 }
 
 bool WebRequestEventHandled::RunImpl() {
@@ skipping 17 matching lines @@
     if (!value->empty()) {
       base::Time install_time =
           extension_info_map()->GetInstallTime(extension_id());
       response.reset(new ExtensionWebRequestEventRouter::EventResponse(
           extension_id(), install_time));
     }
 
     if (value->HasKey("cancel")) {
       // Don't allow cancel mixed with other keys.
       if (value->size() != 1) {
-        CancelWithError(event_name,
-                        sub_event_name,
-                        request_id,
-                        response.Pass(),
-                        keys::kInvalidBlockingResponse);
+        RespondWithError(event_name,
+                         sub_event_name,
+                         request_id,
+                         response.Pass(),
+                         keys::kInvalidBlockingResponse);
         return false;
       }
 
       bool cancel = false;
       EXTENSION_FUNCTION_VALIDATE(value->GetBoolean("cancel", &cancel));
       response->cancel = cancel;
     }
 
     if (value->HasKey("redirectUrl")) {
       std::string new_url_str;
       EXTENSION_FUNCTION_VALIDATE(value->GetString("redirectUrl",
                                                    &new_url_str));
       response->new_url = GURL(new_url_str);
       if (!response->new_url.is_valid()) {
-        CancelWithError(event_name,
-                        sub_event_name,
-                        request_id,
-                        response.Pass(),
-                        ErrorUtils::FormatErrorMessage(
-                            keys::kInvalidRedirectUrl, new_url_str));
+        RespondWithError(event_name,
+                         sub_event_name,
+                         request_id,
+                         response.Pass(),
+                         ErrorUtils::FormatErrorMessage(
+                             keys::kInvalidRedirectUrl, new_url_str));
         return false;
       }
     }
 
     const bool hasRequestHeaders = value->HasKey("requestHeaders");
     const bool hasResponseHeaders = value->HasKey("responseHeaders");
     if (hasRequestHeaders || hasResponseHeaders) {
       if (hasRequestHeaders && hasResponseHeaders) {
         // Allow only one of the keys, not both.
-        CancelWithError(event_name,
-                        sub_event_name,
-                        request_id,
-                        response.Pass(),
-                        keys::kInvalidHeaderKeyCombination);
+        RespondWithError(event_name,
+                         sub_event_name,
+                         request_id,
+                         response.Pass(),
+                         keys::kInvalidHeaderKeyCombination);
         return false;
       }
 
       base::ListValue* headers_value = NULL;
+      scoped_ptr<net::HttpRequestHeaders> request_headers;
+      scoped_ptr<helpers::ResponseHeaders> response_headers;
       if (hasRequestHeaders) {
-        response->request_headers.reset(new net::HttpRequestHeaders());
+        request_headers.reset(new net::HttpRequestHeaders());
         EXTENSION_FUNCTION_VALIDATE(value->GetList(keys::kRequestHeadersKey,
                                                    &headers_value));
       } else {
-        response->response_headers.reset(new helpers::ResponseHeaders());
+        response_headers.reset(new helpers::ResponseHeaders());
         EXTENSION_FUNCTION_VALIDATE(value->GetList(keys::kResponseHeadersKey,
                                                    &headers_value));
       }
 
       for (size_t i = 0; i < headers_value->GetSize(); ++i) {
         base::DictionaryValue* header_value = NULL;
         std::string name;
         std::string value;
         EXTENSION_FUNCTION_VALIDATE(
             headers_value->GetDictionary(i, &header_value));
         if (!FromHeaderDictionary(header_value, &name, &value)) {
           std::string serialized_header;
           base::JSONWriter::Write(header_value, &serialized_header);
-          CancelWithError(event_name,
-                          sub_event_name,
-                          request_id,
-                          response.Pass(),
-                          ErrorUtils::FormatErrorMessage(keys::kInvalidHeader,
-                                                         serialized_header));
+          RespondWithError(event_name,
+                           sub_event_name,
+                           request_id,
+                           response.Pass(),
+                           ErrorUtils::FormatErrorMessage(keys::kInvalidHeader,
+                                                          serialized_header));
           return false;
         }
         if (!helpers::IsValidHeaderName(name)) {
-          CancelWithError(event_name,
-                          sub_event_name,
-                          request_id,
-                          response.Pass(),
-                          keys::kInvalidHeaderName);
+          RespondWithError(event_name,
+                           sub_event_name,
+                           request_id,
+                           response.Pass(),
+                           keys::kInvalidHeaderName);
           return false;
         }
         if (!helpers::IsValidHeaderValue(value)) {
-          CancelWithError(event_name,
-                          sub_event_name,
-                          request_id,
-                          response.Pass(),
-                          ErrorUtils::FormatErrorMessage(
-                              keys::kInvalidHeaderValue, name));
+          RespondWithError(event_name,
+                           sub_event_name,
+                           request_id,
+                           response.Pass(),
+                           ErrorUtils::FormatErrorMessage(
+                               keys::kInvalidHeaderValue, name));
           return false;
         }
         if (hasRequestHeaders)
-          response->request_headers->SetHeader(name, value);
+          request_headers->SetHeader(name, value);
         else
-          response->response_headers->push_back(helpers::ResponseHeader(name,
-                                                                        value));
+          response_headers->push_back(helpers::ResponseHeader(name, value));
       }
+      if (hasRequestHeaders)
+        response->request_headers.reset(request_headers.release());
+      else
+        response->response_headers.reset(response_headers.release());
     }
 
     if (value->HasKey(keys::kAuthCredentialsKey)) {
       base::DictionaryValue* credentials_value = NULL;
       EXTENSION_FUNCTION_VALIDATE(value->GetDictionary(
           keys::kAuthCredentialsKey,
           &credentials_value));
       base::string16 username;
       base::string16 password;
       EXTENSION_FUNCTION_VALIDATE(
@@ skipping 66 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));
 }