Store, use and send etags.

media/blink/url_index.cc

 // Copyright 2015 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 <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 149 matching lines @@
       base::TimeDelta::FromSeconds(kUrlMappingTimeoutSeconds))
     return true;
   return false;
 }
 
 void UrlData::set_last_modified(base::Time last_modified) {
   DCHECK(thread_checker_.CalledOnValidThread());
   last_modified_ = last_modified;
 }
 
+void UrlData::set_etag(const std::string& etag) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  etag_ = etag;
+}
+
 void UrlData::set_range_supported() {
   DCHECK(thread_checker_.CalledOnValidThread());
   range_supported_ = true;
 }
 
 ResourceMultiBuffer* UrlData::multibuffer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return &multibuffer_;
 }
 
@@ skipping 28 matching lines @@
     return i->second;
   }
   return NewUrlData(gurl, cors_mode);
 }
 
 scoped_refptr<UrlData> UrlIndex::NewUrlData(const GURL& url,
                                             UrlData::CORSMode cors_mode) {
   return new UrlData(url, cors_mode, weak_factory_.GetWeakPtr());
 }
 
+namespace {
+bool IsStrongEtag(const std::string& etag) {
+  return etag.size() > 2 && etag[0] == '"';
+}
+
+bool IsNewDataForSameResource(const scoped_refptr<UrlData>& new_entry,
+                              const scoped_refptr<UrlData>& old_entry) {
+  if (IsStrongEtag(new_entry->etag()) && IsStrongEtag(old_entry->etag())) {
+    if (new_entry->etag() != old_entry->etag())
+      return true;
+  }
+  if (!new_entry->last_modified().is_null()) {
+    if (new_entry->last_modified() != old_entry->last_modified())
+      return true;
+  }
+  return false;

[Tom Bergan, 2016/09/16 19:30:21]

Missed this on the first read ... What if the response doesn't have any
validator headers (neither Etag nor Last-Modified)? This happens frequently. In
this case, I believe the code currently assumes the content hasn't changed, and
I think we should continue making that assumption.

Basically, to scope this change as narrowly as possible:

- If the response has a strong etag, then combine only if the etag matches the
buffered version
- Otherwise, do the same thing as before this change

[hubbe, 2016/09/16 19:33:41]

That is exactly what this code does.
(Unless I wrote it wrong somehow?)

[Tom Bergan, 2016/09/16 19:45:36]

It is, I misread the meaning of "false" in this context (for some reason I
thought this should return "true" if the response had no validators). Sorry!

+}
+};
+
 scoped_refptr<UrlData> UrlIndex::TryInsert(
     const scoped_refptr<UrlData>& url_data) {
   scoped_refptr<UrlData>* by_url_slot;
   bool urldata_valid = url_data->Valid();
   if (urldata_valid) {
     by_url_slot = &by_url_.insert(std::make_pair(url_data->key(), url_data))
                        .first->second;
   } else {
     std::map<UrlData::KeyType, scoped_refptr<UrlData>>::iterator iter;
     iter = by_url_.find(url_data->key());
     if (iter == by_url_.end())
       return url_data;
     by_url_slot = &iter->second;
   }
   if (*by_url_slot == url_data)
     return url_data;
 
-  // TODO(hubbe): Support etag validation.
-  if (!url_data->last_modified().is_null()) {
-    if ((*by_url_slot)->last_modified() != url_data->last_modified()) {
-      if (urldata_valid)
-        *by_url_slot = url_data;
-      return url_data;
-    }
+  if (IsNewDataForSameResource(url_data, *by_url_slot)) {
+    if (urldata_valid)
+      *by_url_slot = url_data;
+    return url_data;
   }
+
   // Check if we should replace the in-cache url data with our url data.
   if (urldata_valid) {
     if ((!(*by_url_slot)->Valid() ||
          url_data->CachedSize() > (*by_url_slot)->CachedSize())) {
       *by_url_slot = url_data;
     } else {
       (*by_url_slot)->MergeFrom(url_data);
     }
   }
   return *by_url_slot;
 }
 
 }  // namespace media