Not allow compression when requesting multimedia

because ffmpeg does not expect compressed files.
(It does not make sense to compress audio/video anyways...)

http://codereview.chromium.org/7044092

BUG=47381
TEST=http://www.deafmac.org/html5/grinchsample.mp4 (Please clear browser cache, otherwise it can contain original GZIP-ed file requested by old browser)

Review URL: http://codereview.chromium.org/7044092

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@89532 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 125 insertions, 53 deletions

diff --git a/media/filters/ffmpeg_demuxer.cc b/media/filters/ffmpeg_demuxer.cc
index 5bf47a7..dd2d96b 100644
--- a/media/filters/ffmpeg_demuxer.cc
+++ b/media/filters/ffmpeg_demuxer.cc
@@ -421,9 +421,10 @@ bool FFmpegDemuxer::SetPosition(int64 position) {
   DCHECK(data_source_);
 
   int64 file_size;
-  if (!data_source_->GetSize(&file_size) || position >= file_size ||
-      position < 0)
+  if ((data_source_->GetSize(&file_size) && position >= file_size) ||
+      position < 0) {
     return false;
+  }
 
   read_position_ = position;
   return true;
diff --git a/net/url_request/url_request_http_job.cc b/net/url_request/url_request_http_job.cc
index 4872792..c63aa0e 100644
--- a/net/url_request/url_request_http_job.cc
+++ b/net/url_request/url_request_http_job.cc
@@ -398,56 +398,66 @@ void URLRequestHttpJob::StartTransaction() {
 }
 
 void URLRequestHttpJob::AddExtraHeaders() {
-  // TODO(jar): Consider optimizing away SDCH advertising bytes when the URL is
-  // probably an img or such (and SDCH encoding is not likely).
-  bool advertise_sdch = SdchManager::Global() &&
-      SdchManager::Global()->IsInSupportedDomain(request_->url());
-  std::string avail_dictionaries;
-  if (advertise_sdch) {
-    SdchManager::Global()->GetAvailDictionaryList(request_->url(),
-                                                  &avail_dictionaries);
-
-    // The AllowLatencyExperiment() is only true if we've successfully done a
-    // full SDCH compression recently in this browser session for this host.
-    // Note that for this path, there might be no applicable dictionaries, and
-    // hence we can't participate in the experiment.
-    if (!avail_dictionaries.empty() &&
-        SdchManager::Global()->AllowLatencyExperiment(request_->url())) {
-      // We are participating in the test (or control), and hence we'll
-      // eventually record statistics via either SDCH_EXPERIMENT_DECODE or
-      // SDCH_EXPERIMENT_HOLDBACK, and we'll need some packet timing data.
-      packet_timing_enabled_ = true;
-      if (base::RandDouble() < .01) {
-        sdch_test_control_ = true;  // 1% probability.
-        advertise_sdch = false;
-      } else {
-        sdch_test_activated_ = true;
+  // Supply Accept-Encoding field only if it is not already provided.
+  // It should be provided IF the content is known to have restrictions on
+  // potential encoding, such as streaming multi-media.
+  // For details see bug 47381.
+  // TODO(jar, enal): jpeg files etc. should set up a request header if
+  // possible. Right now it is done only by buffered_resource_loader and
+  // simple_data_source.
+  if (!request_info_.extra_headers.HasHeader(
+      HttpRequestHeaders::kAcceptEncoding)) {
+    bool advertise_sdch = SdchManager::Global() &&
+        SdchManager::Global()->IsInSupportedDomain(request_->url());
+    std::string avail_dictionaries;
+    if (advertise_sdch) {
+      SdchManager::Global()->GetAvailDictionaryList(request_->url(),
+                                                    &avail_dictionaries);
+
+      // The AllowLatencyExperiment() is only true if we've successfully done a
+      // full SDCH compression recently in this browser session for this host.
+      // Note that for this path, there might be no applicable dictionaries,
+      // and hence we can't participate in the experiment.
+      if (!avail_dictionaries.empty() &&
+          SdchManager::Global()->AllowLatencyExperiment(request_->url())) {
+        // We are participating in the test (or control), and hence we'll
+        // eventually record statistics via either SDCH_EXPERIMENT_DECODE or
+        // SDCH_EXPERIMENT_HOLDBACK, and we'll need some packet timing data.
+        packet_timing_enabled_ = true;
+        if (base::RandDouble() < .01) {
+          sdch_test_control_ = true;  // 1% probability.
+          advertise_sdch = false;
+        } else {
+          sdch_test_activated_ = true;
+        }
       }
     }
-  }
 
-  // Supply Accept-Encoding headers first so that it is more likely that they
-  // will be in the first transmitted packet.  This can sometimes make it easier
-  // to filter and analyze the streams to assure that a proxy has not damaged
-  // these headers.  Some proxies deliberately corrupt Accept-Encoding headers.
-  if (!advertise_sdch) {
-    // Tell the server what compression formats we support (other than SDCH).
-    request_info_.extra_headers.SetHeader(
-        HttpRequestHeaders::kAcceptEncoding, "gzip,deflate");
-  } else {
-    // Include SDCH in acceptable list.
-    request_info_.extra_headers.SetHeader(
-        HttpRequestHeaders::kAcceptEncoding, "gzip,deflate,sdch");
-    if (!avail_dictionaries.empty()) {
+    // Supply Accept-Encoding headers first so that it is more likely that they
+    // will be in the first transmitted packet.  This can sometimes make it
+    // easier to filter and analyze the streams to assure that a proxy has not
+    // damaged these headers.  Some proxies deliberately corrupt Accept-Encoding
+    // headers.
+    if (!advertise_sdch) {
+      // Tell the server what compression formats we support (other than SDCH).
       request_info_.extra_headers.SetHeader(
-          kAvailDictionaryHeader,
-          avail_dictionaries);
-      sdch_dictionary_advertised_ = true;
-      // Since we're tagging this transaction as advertising a dictionary, we'll
-      // definitely employ an SDCH filter (or tentative sdch filter) when we get
-      // a response.  When done, we'll record histograms via SDCH_DECODE or
-      // SDCH_PASSTHROUGH.  Hence we need to record packet arrival times.
-      packet_timing_enabled_ = true;
+          HttpRequestHeaders::kAcceptEncoding, "gzip,deflate");
+    } else {
+      // Include SDCH in acceptable list.
+      request_info_.extra_headers.SetHeader(
+          HttpRequestHeaders::kAcceptEncoding, "gzip,deflate,sdch");
+      if (!avail_dictionaries.empty()) {
+        request_info_.extra_headers.SetHeader(
+            kAvailDictionaryHeader,
+            avail_dictionaries);
+        sdch_dictionary_advertised_ = true;
+        // Since we're tagging this transaction as advertising a dictionary,
+        // we'll definitely employ an SDCH filter (or tentative sdch filter)
+        // when we get a response.  When done, we'll record histograms via
+        // SDCH_DECODE or SDCH_PASSTHROUGH.  Hence we need to record packet
+        // arrival times.
+        packet_timing_enabled_ = true;
+      }
     }
   }
 
diff --git a/net/url_request/url_request_unittest.cc b/net/url_request/url_request_unittest.cc
index 97ceb08..ffc1b41 100644
--- a/net/url_request/url_request_unittest.cc
+++ b/net/url_request/url_request_unittest.cc
@@ -2845,6 +2845,39 @@ TEST_F(URLRequestTestHTTP, OverrideAcceptLanguage) {
   EXPECT_EQ(std::string("ru"), d.data_received());
 }
 
+// Check that default A-E header is sent.
+TEST_F(URLRequestTestHTTP, DefaultAcceptEncoding) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  TestURLRequest
+      req(test_server_.GetURL("echoheader?Accept-Encoding"), &d);
+  req.set_context(new TestURLRequestContext());
+  HttpRequestHeaders headers;
+  req.SetExtraRequestHeaders(headers);
+  req.Start();
+  MessageLoop::current()->Run();
+  EXPECT_TRUE(ContainsString(d.data_received(), "gzip"));
+}
+
+// Check that if request overrides the A-E header, the default is not appended.
+// See http://crbug.com/47381
+TEST_F(URLRequestTestHTTP, OverrideAcceptEncoding) {
+  ASSERT_TRUE(test_server_.Start());
+
+  TestDelegate d;
+  TestURLRequest
+      req(test_server_.GetURL("echoheader?Accept-Encoding"), &d);
+  req.set_context(new TestURLRequestContext());
+  HttpRequestHeaders headers;
+  headers.SetHeader(HttpRequestHeaders::kAcceptEncoding, "identity");
+  req.SetExtraRequestHeaders(headers);
+  req.Start();
+  MessageLoop::current()->Run();
+  EXPECT_FALSE(ContainsString(d.data_received(), "gzip"));
+  EXPECT_TRUE(ContainsString(d.data_received(), "identity"));
+}
+
 // Check that default A-C header is sent.
 TEST_F(URLRequestTestHTTP, DefaultAcceptCharset) {
   ASSERT_TRUE(test_server_.Start());
diff --git a/webkit/glue/media/buffered_resource_loader.cc b/webkit/glue/media/buffered_resource_loader.cc
index eb14351..7829448 100644
--- a/webkit/glue/media/buffered_resource_loader.cc
+++ b/webkit/glue/media/buffered_resource_loader.cc
@@ -8,6 +8,7 @@
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
+#include "net/http/http_request_headers.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKitClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
@@ -106,13 +107,18 @@ void BufferedResourceLoader::Start(net::CompletionCallback* start_callback,
 
   if (IsRangeRequest()) {
     range_requested_ = true;
-    request.setHTTPHeaderField(WebString::fromUTF8("Range"),
-                               WebString::fromUTF8(GenerateHeaders(
-                                   first_byte_position_,
-                                   last_byte_position_)));
+    request.setHTTPHeaderField(
+        WebString::fromUTF8(net::HttpRequestHeaders::kRange),
+        WebString::fromUTF8(GenerateHeaders(first_byte_position_,
+                                            last_byte_position_)));
   }
   frame->setReferrerForRequest(request, WebKit::WebURL());
 
+  // Disable compression, compression for audio/video doesn't make sense...
+  request.setHTTPHeaderField(
+      WebString::fromUTF8(net::HttpRequestHeaders::kAcceptEncoding),
+      WebString::fromUTF8("identity;q=1, *;q=0"));
+
   // This flag is for unittests as we don't want to reset |url_loader|
   if (!keep_test_loader_)
     url_loader_.reset(frame->createAssociatedURLLoader());
diff --git a/webkit/glue/media/buffered_resource_loader_unittest.cc b/webkit/glue/media/buffered_resource_loader_unittest.cc
index f23bd89..df44c48 100644
--- a/webkit/glue/media/buffered_resource_loader_unittest.cc
+++ b/webkit/glue/media/buffered_resource_loader_unittest.cc
@@ -3,14 +3,17 @@
 // found in the LICENSE file.
 
 #include <algorithm>
+#include <string>
 
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "net/base/net_errors.h"
+#include "net/http/http_request_headers.h"
 #include "net/http/http_util.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLError.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLResponse.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/glue/media/buffered_resource_loader.h"
@@ -30,6 +33,7 @@ using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::SetArgumentPointee;
 using ::testing::StrictMock;
+using ::testing::Truly;
 using ::testing::NiceMock;
 using ::testing::WithArgs;
 
@@ -65,6 +69,14 @@ ACTION_P(RequestCanceled, loader) {
   loader->didFail(NULL, error);
 }
 
+// Predicate that tests that request disallows compressed data.
+static bool CorrectAcceptEncoding(const WebKit::WebURLRequest &request) {
+  std::string value = request.httpHeaderField(
+      WebString::fromUTF8(net::HttpRequestHeaders::kAcceptEncoding)).utf8();
+  return (value.find("identity;q=1") != std::string::npos) &&
+         (value.find("*;q=0") != std::string::npos);
+}
+
 class BufferedResourceLoaderTest : public testing::Test {
  public:
   BufferedResourceLoaderTest()
@@ -98,7 +110,8 @@ class BufferedResourceLoaderTest : public testing::Test {
 
   void Start() {
     InSequence s;
-    EXPECT_CALL(*url_loader_, loadAsynchronously(_, loader_.get()));
+    EXPECT_CALL(*url_loader_, loadAsynchronously(Truly(CorrectAcceptEncoding),
+                                                 loader_.get()));
     loader_->Start(
         NewCallback(this, &BufferedResourceLoaderTest::StartCallback),
         NewCallback(this, &BufferedResourceLoaderTest::NetworkCallback),
diff --git a/webkit/glue/media/simple_data_source.cc b/webkit/glue/media/simple_data_source.cc
index 6647e52..57c51ad 100644
--- a/webkit/glue/media/simple_data_source.cc
+++ b/webkit/glue/media/simple_data_source.cc
@@ -9,12 +9,16 @@
 #include "media/base/filter_host.h"
 #include "net/base/data_url.h"
 #include "net/base/load_flags.h"
+#include "net/http/http_request_headers.h"
 #include "net/url_request/url_request_status.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKitClient.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "webkit/glue/media/web_data_source_factory.h"
 #include "webkit/glue/webkit_glue.h"
 
+using WebKit::WebString;
+
 namespace webkit_glue {
 
 static const char kDataScheme[] = "data";
@@ -300,6 +304,11 @@ void SimpleDataSource::StartTask() {
 
       frame_->setReferrerForRequest(request, WebKit::WebURL());
 
+      // Disable compression, compression for audio/video doesn't make sense...
+      request.setHTTPHeaderField(
+          WebString::fromUTF8(net::HttpRequestHeaders::kAcceptEncoding),
+          WebString::fromUTF8("identity;q=1, *;q=0"));
+
       // This flag is for unittests as we don't want to reset |url_loader|
       if (!keep_test_loader_)
         url_loader_.reset(frame_->createAssociatedURLLoader());