Suppress pause-and-buffer behavior when the HTTP response won't satisfy future requests via cache.

webkit/media/buffered_resource_loader.cc

 // Copyright (c) 2012 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 "webkit/media/buffered_resource_loader.h"
 
+#include <math.h>
+
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
+#include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "media/base/media_log.h"
 #include "net/http/http_request_headers.h"
+#include "net/http/http_util.h"
+#include "net/http/http_version.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLLoaderOptions.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebKitPlatformSupport.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLError.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLResponse.h"
 
+using base::Time;
+using base::TimeDelta;
 using WebKit::WebFrame;
 using WebKit::WebString;
 using WebKit::WebURLError;
 using WebKit::WebURLLoader;
 using WebKit::WebURLLoaderOptions;
 using WebKit::WebURLRequest;
 using WebKit::WebURLResponse;
 
 namespace webkit_media {
 
@@ skipping 73 matching lines @@
     const GURL& url,
     int64 first_byte_position,
     int64 last_byte_position,
     DeferStrategy strategy,
     int bitrate,
     float playback_rate,
     media::MediaLog* media_log)
     : buffer_(kMinBufferCapacity, kMinBufferCapacity),
       loader_failed_(false),
       defer_strategy_(strategy),
+      might_be_reused_from_cache_in_future_(true),
       range_supported_(false),
       saved_forward_capacity_(0),
       url_(url),
       first_byte_position_(first_byte_position),
       last_byte_position_(last_byte_position),
       single_origin_(true),
       offset_(0),
       content_length_(kPositionNotSpecified),
       instance_size_(kPositionNotSpecified),
       read_position_(0),
@@ skipping 221 matching lines @@
   url_ = newRequest.url();
 }
 
 void BufferedResourceLoader::didSendData(
     WebURLLoader* loader,
     unsigned long long bytes_sent,
     unsigned long long total_bytes_to_be_sent) {
   NOTIMPLEMENTED();
 }
 
+// Reasons that a cached WebURLResponse will *not* prevent a future request to
+// the server.
+enum UncacheableReason {
+  kNoData = 1,  // Not 200 or 206.
+  kPre11PartialResponse = 2,  // 206 but HTTP version < 1.1.
+  kNoStrongValidatorOnPartialResponse = 3,  // 206, no strong validator.
+  kNoValidatorOnFullResponse = 4,  // 200, no strong or weak validator.
+  kShortMaxAge = 5,  // Max age less than 1h (arbitrary value).
+  kExpiresTooSoon = 6,  // Expires in less than 1h (arbitrary value).
+  kHasMustRevalidate = 7,  // Response asks for revalidation.
+  kNoCache = 8,  // Response included a no-cache header.
+  kNoStore = 9,  // Response included a no-store header.
+  kMaxReason  // Needs to be one more than max legitimate reason.
+};
+
+// Return true if "response" might be used for a future request (using the disk
+// cache).  This is basically a laundry list of reasons we *know* the response
+// won't be useful in the future.
+static bool MightBeReusedFromCacheInFuture(const WebURLResponse& response) {

[darin (slow to review), 2012/05/22 05:30:59]

style nit: usually best not to interrupt the definition of class member
functions with the definition of a static function.  better to put static
functions at the top of the file.  that helps the reader not get as lost, and it
encourages others to do the same.  you might also consider moving this function
to a helper file and then add a unit test.  we might also consider adding a
function like this to net/http/.

+  std::vector<UncacheableReason> reasons;

[darin (slow to review), 2012/05/22 05:30:59]

what's the point of building up this vector?  why don't you just return early at
each push_back?  is there some future version of this code that will care about
the reasons?

+  const int code = response.httpStatusCode();
+  const int version = response.httpVersion();
+  const net::HttpVersion http_version =
+      version == WebURLResponse::HTTP_1_1 ? net::HttpVersion(1, 1) :
+      version == WebURLResponse::HTTP_1_0 ? net::HttpVersion(1, 0) :
+      version == WebURLResponse::HTTP_0_9 ? net::HttpVersion(0, 9) :
+      net::HttpVersion();
+  if (code != kHttpOK && code != kHttpPartialContent)
+    reasons.push_back(kNoData);
+  if (http_version < net::HttpVersion(1, 1) && code == kHttpPartialContent)
+    reasons.push_back(kPre11PartialResponse);
+  if (!net::HttpUtil::HasStrongValidators(
+          http_version,
+          response.httpHeaderField("etag").utf8(),
+          response.httpHeaderField("Last-Modified").utf8(),
+          response.httpHeaderField("Date").utf8())) {
+    if (code == kHttpPartialContent)
+      reasons.push_back(kNoStrongValidatorOnPartialResponse);
+    else if (code == kHttpOK)
+      reasons.push_back(kNoValidatorOnFullResponse);
+  }
+
+  std::string cache_control_header =
+      response.httpHeaderField("cache-control").utf8();
+  StringToLowerASCII(&cache_control_header);
+  if (cache_control_header.find("no-cache") != std::string::npos)
+    reasons.push_back(kNoCache);
+  if (cache_control_header.find("no-store") != std::string::npos)
+    reasons.push_back(kNoStore);
+  if (cache_control_header.find("must-revalidate") != std::string::npos)
+    reasons.push_back(kHasMustRevalidate);
+
+  const TimeDelta kMinimumAgeForUsefulness =
+      TimeDelta::FromSeconds(3600);  // Arbitrary value.
+
+  const char kMaxAgePrefix[] = "max-age=";
+  const size_t kMaxAgePrefixLen = arraysize(kMaxAgePrefix) - 1;
+  if (LowerCaseEqualsASCII(
+          cache_control_header.begin(),
+          cache_control_header.begin() + kMaxAgePrefixLen,
+          kMaxAgePrefix)) {
+    int64 max_age_seconds;
+    base::StringToInt64(
+        base::StringPiece(
+            cache_control_header.begin() + kMaxAgePrefixLen,
+            cache_control_header.end()),
+        &max_age_seconds);
+    if (TimeDelta::FromSeconds(max_age_seconds) < kMinimumAgeForUsefulness)
+      reasons.push_back(kShortMaxAge);
+  }
+
+  Time date;
+  Time expires;
+  if (Time::FromString(response.httpHeaderField("Date").utf8().data(), &date) &&
+      Time::FromString(
+          response.httpHeaderField("Expires").utf8().data(), &expires) &&
+      date > Time() && expires > Time() &&
+      (expires - date) < kMinimumAgeForUsefulness) {
+    reasons.push_back(kExpiresTooSoon);
+  }
+
+  UMA_HISTOGRAM_BOOLEAN("Media.CacheUseful", reasons.empty());
+  for (size_t i = 0; i < reasons.size(); ++i) {
+    UMA_HISTOGRAM_ENUMERATION(
+        "Media.UncacheableReason", reasons[i], kMaxReason);
+  }
+
+  return reasons.empty();
+}
+
 void BufferedResourceLoader::didReceiveResponse(
     WebURLLoader* loader,
     const WebURLResponse& response) {
   DVLOG(1) << "didReceiveResponse: HTTP/"
            << (response.httpVersion() == WebURLResponse::HTTP_0_9 ? "0.9" :
                response.httpVersion() == WebURLResponse::HTTP_1_0 ? "1.0" :
                response.httpVersion() == WebURLResponse::HTTP_1_1 ? "1.1" :
                "Unknown")
            << " " << response.httpStatusCode();
   DCHECK(active_loader_.get());
 
   // The loader may have been stopped and |start_cb| is destroyed.
   // In this case we shouldn't do anything.
   if (start_cb_.is_null())
     return;
 
+  might_be_reused_from_cache_in_future_ =
+      MightBeReusedFromCacheInFuture(response);
+
   // Expected content length can be |kPositionNotSpecified|, in that case
   // |content_length_| is not specified and this is a streaming response.
   content_length_ = response.expectedContentLength();
 
   // We make a strong assumption that when we reach here we have either
   // received a response from HTTP/HTTPS protocol or the request was
   // successful (in particular range request). So we only verify the partial
   // response for HTTP and HTTPS protocol.
   if (url_.SchemeIs(kHttpScheme) || url_.SchemeIs(kHttpsScheme)) {
     bool partial_response = (response.httpStatusCode() == kHttpPartialContent);
@@ skipping 152 matching lines @@
   }
 }
 
 bool BufferedResourceLoader::HasSingleOrigin() const {
   DCHECK(start_cb_.is_null())
       << "Start() must complete before calling HasSingleOrigin()";
   return single_origin_;
 }
 
 void BufferedResourceLoader::UpdateDeferStrategy(DeferStrategy strategy) {
+  if (!might_be_reused_from_cache_in_future_ && strategy == kNeverDefer)
+    strategy = kThresholdDefer;
   defer_strategy_ = strategy;
   UpdateDeferBehavior();
 }
 
 void BufferedResourceLoader::SetPlaybackRate(float playback_rate) {
   playback_rate_ = playback_rate;
 
   // This is a pause so don't bother updating the buffer window as we'll likely
   // get unpaused in the future.
   if (playback_rate_ == 0.0)
@@ skipping 260 matching lines @@
 
 void BufferedResourceLoader::Log() {
   media_log_->AddEvent(
       media_log_->CreateBufferedExtentsChangedEvent(
           offset_ - buffer_.backward_bytes(),
           offset_,
           offset_ + buffer_.forward_bytes()));
 }
 
 }  // namespace webkit_media