Add Vary support for ServiceWorkerCache::Match.

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"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/strings/string_util.h"
 #include "content/browser/service_worker/service_worker_cache.pb.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/url_request/url_request_context.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
 
@@ skipping 342 matching lines @@
 
   HeadersCallback headers_callback = base::Bind(MatchDidReadHeaderData,
                                                 base::Passed(request.Pass()),
                                                 callback,
                                                 blob_storage,
                                                 base::Passed(entry.Pass()));
 
   ReadHeaders(tmp_entry_ptr, headers_callback);
 }
 
+bool VaryMatches(const ServiceWorkerHeaderMap& request,
+                 const ServiceWorkerHeaderMap& cached_request,
+                 const ServiceWorkerHeaderMap& response) {

[jsbell, 2014/09/22 19:17:32]

(I'm assuming we lowercase all the header names somewhere...)

[jsbell, 2014/09/22 19:18:18]

... and that'd be https://codereview.chromium.org/576973004/ which I was going
to look at next. :)

[jkarlin, 2014/09/23 11:42:51]

Acknowledged.

+  ServiceWorkerHeaderMap::const_iterator vary_iter = response.find("vary");
+  if (vary_iter == response.end())
+    return true;
+
+  std::vector<std::string> vary_keys;
+  Tokenize(vary_iter->second, ",", &vary_keys);
+  for (size_t i = 0, max = vary_keys.size(); i < max; ++i) {

[jsbell, 2014/09/22 19:17:32]

Why is this an index/size loop instead of an iterator?

[jkarlin, 2014/09/23 11:42:51]

Done.

+    std::string trimmed;
+    base::TrimWhitespaceASCII(vary_keys[i], base::TRIM_ALL, &trimmed);
+    if (trimmed == "*")
+      return false;
+
+    ServiceWorkerHeaderMap::const_iterator request_iter = request.find(trimmed);
+    ServiceWorkerHeaderMap::const_iterator cached_request_iter =
+        cached_request.find(trimmed);
+
+    // If the header exists in one but not the other, no match.
+    if ((request_iter == request.end()) !=
+        (cached_request_iter == cached_request.end()))
+      return false;
+
+    // If the header exists in one, it exists in both. Verify that the values
+    // are equal.
+    if (request_iter != request.end() &&
+        request_iter->second != cached_request_iter->second)
+      return false;
+  }
+
+  return true;
+}
+
 void MatchDidReadHeaderData(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
     scoped_ptr<ServiceWorkerRequestResponseHeaders> headers) {
   if (!headers) {
     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(),
                                 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.
+  ServiceWorkerHeaderMap cached_request_headers;
+  for (int i = 0; i < headers->request_headers_size(); ++i) {
+    const ServiceWorkerRequestResponseHeaders::HeaderMap header =
+        headers->request_headers(i);
+    cached_request_headers.insert(

[jsbell, 2014/09/22 19:17:32]

Shorter to write: cached_request_headers[header.name()] = header.value();

[jkarlin, 2014/09/23 11:42:51]

Done.

+        std::make_pair(header.name(), header.value()));
+  }
+
+  if (!VaryMatches(
+          request->headers, cached_request_headers, response->headers)) {
+    callback.Run(ServiceWorkerCache::ErrorTypeNotFound,
+                 scoped_ptr<ServiceWorkerResponse>(),
+                 scoped_ptr<storage::BlobDataHandle>());
+    return;
+  }
 
   if (entry->GetDataSize(INDEX_RESPONSE_BODY) == 0) {
     callback.Run(ServiceWorkerCache::ErrorTypeOK,
                  response.Pass(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   // Stream the response body into a blob.
   if (!blob_storage) {
@@ skipping 560 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