Clear the gzip filter to file names with gz/tgz extensions only when the mime type is unsupported. We have cases where supported mime types like javascript/html urls end in .gz. These files should go through the gzip filter.

I manually tested the behavior with Firefox and a fake web server, and wrote unit tests based on them.

BUG=16430
TEST=see bug
Review URL: http://codereview.chromium.org/165035

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

2 files changed, 168 insertions, 12 deletions

diff --git a/net/base/filter.cc b/net/base/filter.cc
index 275d398..74a8b11 100644
--- a/net/base/filter.cc
+++ b/net/base/filter.cc
@@ -9,6 +9,7 @@
 #include "net/base/gzip_filter.h"
 #include "net/base/bzip2_filter.h"
 #include "net/base/io_buffer.h"
+#include "net/base/mime_util.h"
 #include "net/base/sdch_filter.h"
 
 namespace {
@@ -102,18 +103,27 @@ void Filter::FixupEncodingTypes(
     FilePath filename = FilePath().AppendASCII(url.ExtractFileName());
     FilePath::StringType extension = filename.Extension();
 
-    // Firefox does not apply the filter to the following extensions.
-    // See Firefox's nsHttpChannel::nsContentEncodings::GetNext() and
-    // nonDecodableExtensions in nsExternalHelperAppService.cpp
-    // For the case of svgz files, we use the extension to distinguish
-    // between svgz files and svg files compressed with gzip by the server.
-    // When viewing a .svgz file, we need to uncompress it, but we don't
-    // want to do that when downloading.
-    if (0 == extension.compare(FILE_PATH_LITERAL(".gz")) ||
-        0 == extension.compare(FILE_PATH_LITERAL(".tgz")) ||
-        (0 == extension.compare(FILE_PATH_LITERAL(".svgz")) &&
-        filter_context.IsDownload())) {
-      encoding_types->clear();
+    if (filter_context.IsDownload()) {
+      // We don't want to decompress gzipped files when the user explicitly
+      // asks to download them.
+      // For the case of svgz files, we use the extension to distinguish
+      // between svgz files and svg files compressed with gzip by the server.
+      // When viewing a .svgz file, we need to uncompress it, but we don't
+      // want to do that when downloading.
+      // See Firefox's nonDecodableExtensions in nsExternalHelperAppService.cpp
+      if (FILE_PATH_LITERAL(".gz" == extension) ||
+          FILE_PATH_LITERAL(".tgz" == extension) ||
+          FILE_PATH_LITERAL(".svgz") == extension)
+        encoding_types->clear();
+    } else {
+      // When the user does not explicitly ask to download a file, if we get a
+      // supported mime type, then we attempt to decompress in order to view it.
+      // However, if it's not a supported mime type, then we will attempt to
+      // download it, and in that case, don't decompress .gz/.tgz files.
+      if ((FILE_PATH_LITERAL(".gz" == extension) ||
+           FILE_PATH_LITERAL(".tgz") == extension) &&
+          !net::IsSupportedMimeType(mime_type))
+        encoding_types->clear();
     }
   }
 
diff --git a/net/base/filter_unittest.cc b/net/base/filter_unittest.cc
index 7a29867..55db5e7 100644
--- a/net/base/filter_unittest.cc
+++ b/net/base/filter_unittest.cc
@@ -212,3 +212,149 @@ TEST(FilterTest, Svgz) {
   ASSERT_EQ(1U, encoding_types.size());
   EXPECT_EQ(Filter::FILTER_TYPE_GZIP, encoding_types.front());
 }
+
+TEST(FilterTest, UnsupportedMimeGzip) {
+  // From issue 8170 - handling files with Content-Encoding: x-gzip
+  const int kInputBufferSize(100);
+  MockFilterContext filter_context(kInputBufferSize);
+  std::vector<Filter::FilterType> encoding_types;
+  const std::string kTarMime("application/x-tar");
+  const std::string kCpioMime("application/x-cpio");
+  const std::string kTarUrl("http://ignore.com/foo.tar");
+  const std::string kTargzUrl("http://ignore.com/foo.tar.gz");
+  const std::string kTgzUrl("http://ignore.com/foo.tgz");
+  const std::string kBadTgzUrl("http://ignore.com/foo.targz");
+  const std::string kUrl("http://ignore.com/foo");
+
+  // Firefox 3 does not decompress when we have unsupported mime types for
+  // certain filenames.
+  encoding_types.clear();
+  encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
+  filter_context.SetDownload(false);
+  filter_context.SetMimeType(kTarMime);
+  filter_context.SetURL(GURL(kTargzUrl));
+  Filter::FixupEncodingTypes(filter_context, &encoding_types);
+  EXPECT_TRUE(encoding_types.empty());
+
+  encoding_types.clear();
+  encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
+  filter_context.SetDownload(false);
+  filter_context.SetMimeType(kTarMime);
+  filter_context.SetURL(GURL(kTgzUrl));
+  Filter::FixupEncodingTypes(filter_context, &encoding_types);
+  EXPECT_TRUE(encoding_types.empty());
+
+  encoding_types.clear();
+  encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
+  filter_context.SetDownload(false);
+  filter_context.SetMimeType(kCpioMime);
+  filter_context.SetURL(GURL(kTgzUrl));
+  Filter::FixupEncodingTypes(filter_context, &encoding_types);
+  EXPECT_TRUE(encoding_types.empty());
+
+  // Same behavior for downloads.
+  encoding_types.clear();
+  encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
+  filter_context.SetDownload(true);
+  filter_context.SetMimeType(kCpioMime);
+  filter_context.SetURL(GURL(kTgzUrl));
+  Filter::FixupEncodingTypes(filter_context, &encoding_types);
+  EXPECT_TRUE(encoding_types.empty());
+
+  // Unsupported mime type with wrong file name, decompressed.
+  encoding_types.clear();
+  encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
+  filter_context.SetDownload(false);
+  filter_context.SetMimeType(kTarMime);
+  filter_context.SetURL(GURL(kUrl));
+  Filter::FixupEncodingTypes(filter_context, &encoding_types);
+  ASSERT_EQ(1U, encoding_types.size());
+  EXPECT_EQ(Filter::FILTER_TYPE_GZIP, encoding_types.front());
+
+  encoding_types.clear();
+  encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
+  filter_context.SetDownload(false);
+  filter_context.SetMimeType(kTarMime);
+  filter_context.SetURL(GURL(kTarUrl));
+  Filter::FixupEncodingTypes(filter_context, &encoding_types);
+  ASSERT_EQ(1U, encoding_types.size());
+  EXPECT_EQ(Filter::FILTER_TYPE_GZIP, encoding_types.front());
+
+  encoding_types.clear();
+  encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
+  filter_context.SetDownload(false);
+  filter_context.SetMimeType(kTarMime);
+  filter_context.SetURL(GURL(kBadTgzUrl));
+  Filter::FixupEncodingTypes(filter_context, &encoding_types);
+  ASSERT_EQ(1U, encoding_types.size());
+  EXPECT_EQ(Filter::FILTER_TYPE_GZIP, encoding_types.front());
+
+  // Same behavior for downloads.
+  encoding_types.clear();
+  encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
+  filter_context.SetDownload(true);
+  filter_context.SetMimeType(kTarMime);
+  filter_context.SetURL(GURL(kBadTgzUrl));
+  Filter::FixupEncodingTypes(filter_context, &encoding_types);
+  ASSERT_EQ(1U, encoding_types.size());
+  EXPECT_EQ(Filter::FILTER_TYPE_GZIP, encoding_types.front());
+}
+
+TEST(FilterTest, SupportedMimeGzip) {
+  // From issue 16430 - Files with supported mime types should be decompressed,
+  // even though these files end in .gz/.tgz.
+  const int kInputBufferSize(100);
+  MockFilterContext filter_context(kInputBufferSize);
+  std::vector<Filter::FilterType> encoding_types;
+  const std::string kGzUrl("http://ignore.com/foo.gz");
+  const std::string kUrl("http://ignore.com/foo");
+  const std::string kHtmlMime("text/html");
+  const std::string kJavascriptMime("text/javascript");
+
+  // For files that does not end in .gz/.tgz, we always decompress.
+  encoding_types.clear();
+  encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
+  filter_context.SetDownload(false);
+  filter_context.SetMimeType(kHtmlMime);
+  filter_context.SetURL(GURL(kUrl));
+  Filter::FixupEncodingTypes(filter_context, &encoding_types);
+  ASSERT_EQ(1U, encoding_types.size());
+  EXPECT_EQ(Filter::FILTER_TYPE_GZIP, encoding_types.front());
+
+  encoding_types.clear();
+  encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
+  filter_context.SetDownload(true);
+  filter_context.SetMimeType(kHtmlMime);
+  filter_context.SetURL(GURL(kUrl));
+  Filter::FixupEncodingTypes(filter_context, &encoding_types);
+  ASSERT_EQ(1U, encoding_types.size());
+  EXPECT_EQ(Filter::FILTER_TYPE_GZIP, encoding_types.front());
+
+  // And also decompress files that end in .gz/.tgz.
+  encoding_types.clear();
+  encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
+  filter_context.SetDownload(false);
+  filter_context.SetMimeType(kHtmlMime);
+  filter_context.SetURL(GURL(kGzUrl));
+  Filter::FixupEncodingTypes(filter_context, &encoding_types);
+  ASSERT_EQ(1U, encoding_types.size());
+  EXPECT_EQ(Filter::FILTER_TYPE_GZIP, encoding_types.front());
+
+  encoding_types.clear();
+  encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
+  filter_context.SetDownload(false);
+  filter_context.SetMimeType(kJavascriptMime);
+  filter_context.SetURL(GURL(kGzUrl));
+  Filter::FixupEncodingTypes(filter_context, &encoding_types);
+  ASSERT_EQ(1U, encoding_types.size());
+  EXPECT_EQ(Filter::FILTER_TYPE_GZIP, encoding_types.front());
+
+  // Except on downloads, where they just get saved.
+  encoding_types.clear();
+  encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
+  filter_context.SetDownload(true);
+  filter_context.SetMimeType(kHtmlMime);
+  filter_context.SetURL(GURL(kGzUrl));
+  Filter::FixupEncodingTypes(filter_context, &encoding_types);
+  EXPECT_TRUE(encoding_types.empty());
+}