Make ServiceWorkerFetchRequest and ServiceWorkerResponse header maps case insensitive

content/browser/service_worker/service_worker_cache.cc

 // Copyright 2014 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 "content/browser/service_worker/service_worker_cache.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/guid.h"
@@ skipping 230 matching lines @@
   }
 
   DCHECK(entryptr);
   disk_cache::ScopedEntryPtr entry(*entryptr);
 
   ServiceWorkerRequestResponseHeaders headers;
   headers.set_method(request->method);
 
   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 =
         headers.add_request_headers();
     header_map->set_name(it->first);
     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 =
         headers.add_response_headers();
     header_map->set_name(it->first);
     header_map->set_value(it->second);
   }
 
   scoped_ptr<std::string> serialized(new std::string());
   if (!headers.SerializeToString(serialized.get())) {
@@ skipping 110 matching lines @@
     callback.Run(ServiceWorkerCache::ErrorTypeStorage,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   scoped_ptr<ServiceWorkerResponse> response(
       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) {
     const ServiceWorkerRequestResponseHeaders::HeaderMap header =
         headers->response_headers(i);
     response->headers.insert(std::make_pair(header.name(), header.value()));
   }
 
   // TODO(jkarlin): Insert vary validation here.
 
@@ skipping 493 matching lines @@
 void ServiceWorkerCache::KeysDidReadHeaders(
     scoped_ptr<KeysContext> keys_context,
     const Entries::iterator& iter,
     scoped_ptr<ServiceWorkerRequestResponseHeaders> headers) {
   disk_cache::Entry* entry = *iter;
 
   if (headers) {
     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) {
       const ServiceWorkerRequestResponseHeaders::HeaderMap header =
           headers->request_headers(i);
       req_headers.insert(std::make_pair(header.name(), header.value()));
     }
   } else {
     entry->Doom();
   }
@@ skipping 51 matching lines @@
   initialized_ = true;
   for (std::vector<base::Closure>::iterator it = init_callbacks_.begin();
        it != init_callbacks_.end();
        ++it) {
     it->Run();
   }
   init_callbacks_.clear();
 }
 
 }  // namespace content