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

webkit/media/buffered_resource_loader.cc

Index: webkit/media/buffered_resource_loader.cc
diff --git a/webkit/media/buffered_resource_loader.cc b/webkit/media/buffered_resource_loader.cc
index 14ca0a12625058e61d70919b3de945f23cb05cbc..b1b7541a90e2ece1bf6d0555be47daccc6957c04 100644
--- a/webkit/media/buffered_resource_loader.cc
+++ b/webkit/media/buffered_resource_loader.cc
@@ -6,11 +6,13 @@
 
 #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 "webkit/media/cache_util.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"
@@ -111,6 +113,7 @@ BufferedResourceLoader::BufferedResourceLoader(
     : 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),
@@ -368,6 +371,15 @@ void BufferedResourceLoader::didReceiveResponse(
   if (start_cb_.is_null())
     return;
 
+  std::vector<UncacheableReason> reasons =
+      GetReasonsForUncacheability(response);
+  might_be_reused_from_cache_in_future_ = reasons.empty();
+  UMA_HISTOGRAM_BOOLEAN("Media.CacheUseful", reasons.empty());
+  for (size_t i = 0; i < reasons.size(); ++i) {
+    UMA_HISTOGRAM_ENUMERATION(
+        "Media.UncacheableReason", reasons[i], kMaxReason);

[scherkus (not reviewing), 2012/05/23 01:16:03]

one nit: we would increment counts every time we recreated a connection for a
single media source as opposed to the element (think about an ogg file doing a
binary search when seeking! that's like ~8 HTTP connections!)

I'd prefer to drop this code into the initial connection callback code inside
BDS but I suspect that may have to wait until we break down BRL into two pieces
(a piece that handles sending request + receiving response, and piece that
handles the sliding window reading + buffering)

[Ami GONE FROM CHROMIUM, 2012/05/23 01:27:28]

But the whole idea is to classify reusability of individual responses!

[scherkus (not reviewing), 2012/05/23 01:34:19]

I suppose so but how could we answer that out of N people who set the src to
"http://foo.com/bar.wav" they got something cacheable?

Can we solve this with more histograms!? (first response vs all responses!?)

[Ami GONE FROM CHROMIUM, 2012/05/23 01:38:25]

UMA is by its nature not per-site (aggregated along different dimension).
Could do.  

What I'm actually after is characterizing the useful-vs-unuseful as a first cut
(l.377).  l.380 is more about digging into the unuseful, if that turns out to be
a sizeable population.  I suspect we'll want to refine if that's the case, but
this seems like a useful first cut to me.

[scherkus (not reviewing), 2012/05/23 01:43:01]

I'm not interested in the domain but setting the src attribute has a 1:1 mapping
to creating a media engine + loading a URL, which makes for easier to comprehend
numbers (at least for me!)
Agreed. I'm more interested in collecting some data over no data and refining
later along w/ subsequent code shuffling, but taking this opportunity to
mini-brainstorm about said possible refinements!

+  }
+
   // Expected content length can be |kPositionNotSpecified|, in that case
   // |content_length_| is not specified and this is a streaming response.
   content_length_ = response.expectedContentLength();
@@ -540,6 +552,8 @@ bool BufferedResourceLoader::HasSingleOrigin() const {
 }
 
 void BufferedResourceLoader::UpdateDeferStrategy(DeferStrategy strategy) {
+  if (!might_be_reused_from_cache_in_future_ && strategy == kNeverDefer)
+    strategy = kThresholdDefer;
   defer_strategy_ = strategy;
   UpdateDeferBehavior();
 }