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 HasStrongEtag(const scoped_refptr<UrlData>& entry) {

[DaleCurtis, 2016/09/13 23:31:52]

Don't pass scoped_refptr by const& anymore. I'd just pass a const& directly to
the etag here.

[hubbe, 2016/09/14 00:23:06]

Done.

+  if (entry->etag().size() < 2)
+    return false;
+  if (entry->etag()[0] == 'W' && entry->etag()[1] == '/')
+    return false;
+  return true;
+}
+
+bool IsNewDataForSameResource(const scoped_refptr<UrlData>& new_entry,
+                              const scoped_refptr<UrlData>& old_entry) {
+  if (HasStrongEtag(new_entry) && HasStrongEtag(old_entry)) {
+    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;
+}
+};
+
 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