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"
 
 namespace content {
 
 namespace {
 
 typedef scoped_ptr<disk_cache::Backend> ScopedBackendPtr;
 typedef base::Callback<void(bool)> BoolCallback;
 typedef base::Callback<void(disk_cache::ScopedEntryPtr, bool)>
     EntryBoolCallback;
 typedef base::Callback<void(scoped_ptr<ServiceWorkerRequestResponseHeaders>)>
     HeadersCallback;
+typedef std::map<std::string, std::string> HeaderMap;
 
 enum EntryIndex { INDEX_HEADERS = 0, INDEX_RESPONSE_BODY };
 
 // The maximum size of an individual cache. Ultimately cache size is controlled
 // per-origin.
 const int kMaxCacheBytes = 512 * 1024 * 1024;
 
 // Buffer size for cache and blob reading/writing.
 const int kBufferSize = 1024 * 512;
 
@@ skipping 324 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 HeaderMap& request,
+                 const HeaderMap& cached_request,
+                 const HeaderMap& response) {
+  // The headers are assumed to have lower-case keys. This is enforced by
+  // ASSERTS in WebServiceWorkerRequest and WebServiceWorkerResponse.

[jkarlin, 2014/09/17 18:48:10]

The ASSERTS this comment speaks of are in review:

https://codereview.chromium.org/564773004/ and
https://codereview.chromium.org/578763003/

+  HeaderMap::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) {
+    std::string trimmed;
+    base::TrimWhitespaceASCII(vary_keys[i], base::TRIM_ALL, &trimmed);
+    if (trimmed == "*")
+      return false;
+
+    HeaderMap::const_iterator request_iter = request.find(trimmed);
+    HeaderMap::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(),
                                 std::map<std::string, std::string>(),
                                 ""));
 
   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.
+  HeaderMap 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(
+        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