Make ServiceWorkerFetchRequest and ServiceWorkerResponse header maps case insensitive

When storing headers in a map the map should be case insensitive (like HTTPHeaderMap in Blink) so that headers can be easily searched for and coalesced when necessary.

BUG=392621

Review URL: https://codereview.chromium.org/576973004

Cr-Commit-Position: refs/heads/master@{#296387}

content/browser/service_worker/embedded_worker_test_helper.cc

@@ -143,16 +143,12 @@ void EmbeddedWorkerTestHelper::OnFetchEvent(
     int embedded_worker_id,
     int request_id,
     const ServiceWorkerFetchRequest& request) {
-  SimulateSend(
-      new ServiceWorkerHostMsg_FetchEventFinished(
-          embedded_worker_id,
-          request_id,
-          SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
-          ServiceWorkerResponse(GURL(""),
-                                200,
-                                "OK",
-                                std::map<std::string, std::string>(),
-                                std::string())));
+  SimulateSend(new ServiceWorkerHostMsg_FetchEventFinished(
+      embedded_worker_id,
+      request_id,
+      SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
+      ServiceWorkerResponse(
+          GURL(""), 200, "OK", ServiceWorkerHeaderMap(), std::string())));
 }
 
 void EmbeddedWorkerTestHelper::SimulatePausedAfterDownload(

content/browser/service_worker/service_worker_browsertest.cc

@@ -544,7 +544,7 @@ class ServiceWorkerVersionBrowserTest : public ServiceWorkerBrowserTest {
     ServiceWorkerFetchRequest request(
         embedded_test_server()->GetURL("/service_worker/empty.html"),
         "GET",
-        std::map<std::string, std::string>(),
+        ServiceWorkerHeaderMap(),
         GURL(""),
         false);
     version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
@@ -701,7 +701,7 @@ IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, FetchEvent_Response) {
   ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, result);
   EXPECT_EQ(301, response.status_code);
   EXPECT_EQ("Moved Permanently", response.status_text);
-  std::map<std::string, std::string> expected_headers;
+  ServiceWorkerHeaderMap expected_headers;
   expected_headers["content-language"] = "fi";
   expected_headers["content-type"] = "text/html; charset=UTF-8";
   EXPECT_EQ(expected_headers, response.headers);

content/browser/service_worker/service_worker_cache.cc

@@ -248,8 +248,7 @@ void PutDidCreateEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
 
   headers.set_status_code(response->status_code);
   headers.set_status_text(response->status_text);
-  for (std::map<std::string, std::string>::const_iterator it =
-           request->headers.begin();
+  for (ServiceWorkerHeaderMap::const_iterator it = request->headers.begin();
        it != request->headers.end();
        ++it) {
     ServiceWorkerRequestResponseHeaders::HeaderMap* header_map =
@@ -258,8 +257,7 @@ void PutDidCreateEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
     header_map->set_value(it->second);
   }
 
-  for (std::map<std::string, std::string>::const_iterator it =
-           response->headers.begin();
+  for (ServiceWorkerHeaderMap::const_iterator it = response->headers.begin();
        it != response->headers.end();
        ++it) {
     ServiceWorkerRequestResponseHeaders::HeaderMap* header_map =
@@ -390,7 +388,7 @@ void MatchDidReadHeaderData(
       new ServiceWorkerResponse(request->url,
                                 headers->status_code(),
                                 headers->status_text(),
-                                std::map<std::string, std::string>(),
+                                ServiceWorkerHeaderMap(),
                                 ""));
 
   for (int i = 0; i < headers->response_headers_size(); ++i) {
@@ -904,11 +902,11 @@ void ServiceWorkerCache::KeysDidReadHeaders(
     keys_context->out_keys->push_back(
         ServiceWorkerFetchRequest(GURL(entry->GetKey()),
                                   headers->method(),
-                                  std::map<std::string, std::string>(),
+                                  ServiceWorkerHeaderMap(),
                                   GURL(),
                                   false));
 
-    std::map<std::string, std::string>& req_headers =
+    ServiceWorkerHeaderMap& req_headers =
         keys_context->out_keys->back().headers;
 
     for (int i = 0; i < headers->request_headers_size(); ++i) {

content/browser/service_worker/service_worker_cache_unittest.cc

@@ -89,7 +89,7 @@ class ServiceWorkerCacheTest : public testing::Test {
   }
 
   void CreateRequests(ChromeBlobStorageContext* blob_storage_context) {
-    std::map<std::string, std::string> headers;
+    ServiceWorkerHeaderMap headers;
     headers.insert(std::make_pair("a", "a"));
     headers.insert(std::make_pair("b", "b"));
     body_request_ = ServiceWorkerFetchRequest(
@@ -398,6 +398,29 @@ TEST_P(ServiceWorkerCacheTestP, QuickStressBody) {
 }
 #endif  // OS_WIN
 
+TEST_F(ServiceWorkerCacheTest, CaselessServiceWorkerResponseHeaders) {
+  // ServiceWorkerCache depends on ServiceWorkerResponse having caseless
+  // headers so that it can quickly lookup vary headers.
+  ServiceWorkerResponse response(
+      GURL("http://www.example.com"), 200, "OK", ServiceWorkerHeaderMap(), "");
+  response.headers["content-type"] = "foo";
+  response.headers["Content-Type"] = "bar";
+  EXPECT_EQ("bar", response.headers["content-type"]);
+}
+
+TEST_F(ServiceWorkerCacheTest, CaselessServiceWorkerFetchRequestHeaders) {
+  // ServiceWorkerCache depends on ServiceWorkerFetchRequest having caseless
+  // headers so that it can quickly lookup vary headers.
+  ServiceWorkerFetchRequest request(GURL("http://www.example.com"),
+                                         "GET",
+                                         ServiceWorkerHeaderMap(),
+                                         GURL(""),
+                                         false);
+  request.headers["content-type"] = "foo";
+  request.headers["Content-Type"] = "bar";
+  EXPECT_EQ("bar", request.headers["content-type"]);
+}
+
 INSTANTIATE_TEST_CASE_P(ServiceWorkerCacheTest,
                         ServiceWorkerCacheTestP,
                         ::testing::Values(false, true));

content/browser/service_worker/service_worker_url_request_job.cc

@@ -416,14 +416,14 @@ void ServiceWorkerURLRequestJob::DidDispatchFetchEvent(
 void ServiceWorkerURLRequestJob::CreateResponseHeader(
     int status_code,
     const std::string& status_text,
-    const std::map<std::string, std::string>& headers) {
+    const ServiceWorkerHeaderMap& headers) {
   // TODO(kinuko): If the response has an identifier to on-disk cache entry,
   // pull response header from the disk.
   std::string status_line(
       base::StringPrintf("HTTP/1.1 %d %s", status_code, status_text.c_str()));
   status_line.push_back('\0');
   http_response_headers_ = new net::HttpResponseHeaders(status_line);
-  for (std::map<std::string, std::string>::const_iterator it = headers.begin();
+  for (ServiceWorkerHeaderMap::const_iterator it = headers.begin();
        it != headers.end();
        ++it) {
     std::string header;
@@ -444,9 +444,8 @@ void ServiceWorkerURLRequestJob::CommitResponseHeader() {
 void ServiceWorkerURLRequestJob::DeliverErrorResponse() {
   // TODO(falken): Print an error to the console of the ServiceWorker and of
   // the requesting page.
-  CreateResponseHeader(500,
-                       "Service Worker Response Error",
-                       std::map<std::string, std::string>());
+  CreateResponseHeader(
+      500, "Service Worker Response Error", ServiceWorkerHeaderMap());
   CommitResponseHeader();
 }
 

content/browser/service_worker/service_worker_url_request_job.h

@@ -126,7 +126,7 @@ class CONTENT_EXPORT ServiceWorkerURLRequestJob
   // Populates |http_response_headers_|.
   void CreateResponseHeader(int status_code,
                             const std::string& status_text,
-                            const std::map<std::string, std::string>& headers);
+                            const ServiceWorkerHeaderMap& headers);
 
   // Creates |http_response_info_| using |http_response_headers_| and calls
   // NotifyHeadersComplete.

content/browser/service_worker/service_worker_url_request_job_unittest.cc

@@ -199,11 +199,8 @@ class BlobResponder : public EmbeddedWorkerTestHelper {
         embedded_worker_id,
         request_id,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
-        ServiceWorkerResponse(GURL(""),
-                              200,
-                              "OK",
-                              std::map<std::string, std::string>(),
-                              blob_uuid_)));
+        ServiceWorkerResponse(
+            GURL(""), 200, "OK", ServiceWorkerHeaderMap(), blob_uuid_)));
   }
 
   std::string blob_uuid_;

content/common/service_worker/service_worker_types.cc

@@ -13,7 +13,7 @@ ServiceWorkerFetchRequest::ServiceWorkerFetchRequest()
 ServiceWorkerFetchRequest::ServiceWorkerFetchRequest(
     const GURL& url,
     const std::string& method,
-    const std::map<std::string, std::string>& headers,
+    const ServiceWorkerHeaderMap& headers,
     const GURL& referrer,
     bool is_reload)
     : url(url),
@@ -32,7 +32,7 @@ ServiceWorkerResponse::ServiceWorkerResponse(
     const GURL& url,
     int status_code,
     const std::string& status_text,
-    const std::map<std::string, std::string>& headers,
+    const ServiceWorkerHeaderMap& headers,
     const std::string& blob_uuid)
     : url(url),
       status_code(status_code),

content/common/service_worker/service_worker_types.h

@@ -9,6 +9,7 @@
 #include <string>
 
 #include "base/basictypes.h"
+#include "base/strings/string_util.h"
 #include "content/common/content_export.h"
 #include "third_party/WebKit/public/platform/WebServiceWorkerState.h"
 #include "url/gurl.h"
@@ -42,19 +43,28 @@ enum ServiceWorkerFetchEventResult {
   SERVICE_WORKER_FETCH_EVENT_LAST = SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE
 };
 
+struct ServiceWorkerCaseInsensitiveCompare {
+  bool operator()(const std::string& lhs, const std::string& rhs) const {
+    return base::strcasecmp(lhs.c_str(), rhs.c_str()) < 0;
+  }
+};
+
+typedef std::map<std::string, std::string, ServiceWorkerCaseInsensitiveCompare>
+    ServiceWorkerHeaderMap;
+
 // To dispatch fetch request from browser to child process.
 struct CONTENT_EXPORT ServiceWorkerFetchRequest {
   ServiceWorkerFetchRequest();
   ServiceWorkerFetchRequest(const GURL& url,
                             const std::string& method,
-                            const std::map<std::string, std::string>& headers,
+                            const ServiceWorkerHeaderMap& headers,
                             const GURL& referrer,
                             bool is_reload);
   ~ServiceWorkerFetchRequest();
 
   GURL url;
   std::string method;
-  std::map<std::string, std::string> headers;
+  ServiceWorkerHeaderMap headers;
   std::string blob_uuid;
   uint64 blob_size;
   GURL referrer;
@@ -67,14 +77,14 @@ struct CONTENT_EXPORT ServiceWorkerResponse {
   ServiceWorkerResponse(const GURL& url,
                         int status_code,
                         const std::string& status_text,
-                        const std::map<std::string, std::string>& headers,
+                        const ServiceWorkerHeaderMap& headers,
                         const std::string& blob_uuid);
   ~ServiceWorkerResponse();
 
   GURL url;
   int status_code;
   std::string status_text;
-  std::map<std::string, std::string> headers;
+  ServiceWorkerHeaderMap headers;
   std::string blob_uuid;
 };
 

content/renderer/service_worker/embedded_worker_context_client.cc

@@ -279,7 +279,7 @@ void EmbeddedWorkerContextClient::didHandleFetchEvent(
     int request_id,
     const blink::WebServiceWorkerResponse& web_response) {
   DCHECK(script_context_);
-  std::map<std::string, std::string> headers;
+  ServiceWorkerHeaderMap headers;
   const blink::WebVector<blink::WebString>& header_keys =
       web_response.getHeaderKeys();
   for (size_t i = 0; i < header_keys.size(); ++i) {

content/renderer/service_worker/service_worker_script_context.cc

@@ -149,8 +149,7 @@ void ServiceWorkerScriptContext::OnFetchEvent(
                "ServiceWorkerScriptContext::OnFetchEvent");
   webRequest.setURL(blink::WebURL(request.url));
   webRequest.setMethod(blink::WebString::fromUTF8(request.method));
-  for (std::map<std::string, std::string>::const_iterator it =
-           request.headers.begin();
+  for (ServiceWorkerHeaderMap::const_iterator it = request.headers.begin();
        it != request.headers.end();
        ++it) {
     webRequest.setHeader(blink::WebString::fromUTF8(it->first),

ipc/ipc_message_utils.h

@@ -364,9 +364,9 @@ struct ParamTraits<std::set<P> > {
   }
 };
 
-template <class K, class V>
-struct ParamTraits<std::map<K, V> > {
-  typedef std::map<K, V> param_type;
+template <class K, class V, class C, class A>
+struct ParamTraits<std::map<K, V, C, A> > {
+  typedef std::map<K, V, C, A> param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, static_cast<int>(p.size()));
     typename param_type::const_iterator iter;