Improve merging of header modifications in webRequest.OnHeadersReceived

chrome/browser/extensions/extension_webrequest_api.cc

 // Copyright (c) 2011 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/extension_webrequest_api.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
@@ skipping 1178 matching lines @@
     case ExtensionWebRequestEventRouter::kOnBeforeSendHeaders: {
       net::HttpRequestHeaders* old_headers = blocked_request->request_headers;
       net::HttpRequestHeaders* new_headers = response->request_headers.get();
       return helpers::CalculateOnBeforeSendHeadersDelta(
           response->extension_id, response->extension_install_time,
           response->cancel, old_headers, new_headers);
     }
     case ExtensionWebRequestEventRouter::kOnHeadersReceived: {
       net::HttpResponseHeaders* old_headers =
           blocked_request->original_response_headers.get();
+      helpers::ResponseHeaders* new_headers =
+          response->response_headers.get();
       return helpers::CalculateOnHeadersReceivedDelta(
           response->extension_id, response->extension_install_time,
-          response->cancel, old_headers->GetStatusLine(),
-          response->response_headers_string);
+          response->cancel, old_headers, new_headers);
     }
     case ExtensionWebRequestEventRouter::kOnAuthRequired:
       return helpers::CalculateOnAuthRequiredDelta(
           response->extension_id, response->extension_install_time,
           response->cancel, &response->auth_credentials);
     default:
       NOTREACHED();
       break;
   }
   return NULL;
@@ skipping 56 matching lines @@
       CHECK(blocked_request.callback);
       helpers::MergeOnBeforeSendHeadersResponses(
           blocked_request.response_deltas,
           blocked_request.request_headers,
           &conflicting_extensions,
           &event_log_entries);
     } else if (blocked_request.event == kOnHeadersReceived) {
       CHECK(blocked_request.callback);
       helpers::MergeOnHeadersReceivedResponses(
           blocked_request.response_deltas,
+          blocked_request.original_response_headers.get(),
           blocked_request.override_response_headers,
           &conflicting_extensions,
           &event_log_entries);
     } else if (blocked_request.event == kOnAuthRequired) {
       CHECK(!blocked_request.callback);
       CHECK(!blocked_request.auth_callback.is_null());
       credentials_set = helpers::MergeOnAuthRequiredResponses(
          blocked_request.response_deltas,
          blocked_request.auth_credentials,
          &conflicting_extensions,
@@ skipping 257 matching lines @@
         std::string value;
         EXTENSION_FUNCTION_VALIDATE(
             request_headers_value->GetDictionary(i, &header_value));
         EXTENSION_FUNCTION_VALIDATE(
             FromHeaderDictionary(header_value, &name, &value));
         response->request_headers->SetHeader(name, value);
       }
     }
 
     if (value->HasKey("responseHeaders")) {
-      std::string response_headers_string;
+      helpers::ResponseHeaders* response_headers =
+          new helpers::ResponseHeaders();
       ListValue* response_headers_value = NULL;
       EXTENSION_FUNCTION_VALIDATE(value->GetList(keys::kResponseHeadersKey,
                                                  &response_headers_value));
       for (size_t i = 0; i < response_headers_value->GetSize(); ++i) {
         DictionaryValue* header_value = NULL;
         std::string name;
         std::string value;
         EXTENSION_FUNCTION_VALIDATE(
             response_headers_value->GetDictionary(i, &header_value));
         EXTENSION_FUNCTION_VALIDATE(
             FromHeaderDictionary(header_value, &name, &value));
-        response_headers_string += name + ": " + value + '\n';
+        response_headers->push_back(helpers::ResponseHeader(name, value));
       }
-      response_headers_string += '\n';
-      response->response_headers_string.swap(response_headers_string);
+      response->response_headers.reset(response_headers);
     }
 
     if (value->HasKey(keys::kAuthCredentialsKey)) {
       DictionaryValue* credentials_value = NULL;
       EXTENSION_FUNCTION_VALIDATE(value->GetDictionary(
           keys::kAuthCredentialsKey,
           &credentials_value));
       string16 username;
       string16 password;
       EXTENSION_FUNCTION_VALIDATE(
@@ skipping 65 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));
 }