[net] Remove logic for fixing up Gzip encoding type for downloads.

net/filter/filter.cc

 // Copyright 2014 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.
 
 // The basic usage of the Filter interface is described in the comment at
 // the beginning of filter.h. If Filter::Factory is passed a vector of
 // size greater than 1, that interface is implemented by a series of filters
 // connected in a chain. In such a case the first filter
 // in the chain proxies calls to ReadData() so that its return values
 // apply to the entire chain.
 //
 // In a filter chain, the data flows from first filter (held by the
 // caller) down the chain. When ReadData() is called on any filter
 // except for the last filter, it proxies the call down the chain,
 // filling in the input buffers of subsequent filters if needed (==
 // that filter's last_status() value is FILTER_NEED_MORE_DATA) and
 // available (== the current filter has data it can output). The last
 // Filter will then output data if possible, and return
 // FILTER_NEED_MORE_DATA if not. Because the indirection pushes
 // data along the filter chain at each level if it's available and the
 // next filter needs it, a return value of FILTER_NEED_MORE_DATA from the
 // final filter will apply to the entire chain.
 
 #include "net/filter/filter.h"
 
 #include "base/files/file_path.h"
-#include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
-#include "net/base/filename_util_unsafe.h"
 #include "net/base/io_buffer.h"
-#include "net/base/mime_util.h"
 #include "net/base/sdch_net_log_params.h"
 #include "net/filter/gzip_filter.h"
 #include "net/filter/sdch_filter.h"
 #include "net/url_request/url_request_context.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
 // Filter types (using canonical lower case only):
 const char kDeflate[]      = "deflate";
 const char kGZip[]         = "gzip";
 const char kXGZip[]        = "x-gzip";
 const char kSdch[]         = "sdch";
 // compress and x-compress are currently not supported. If we decide to support
 // them, we'll need the same mime type compatibility hack we have for gzip. For
 // more information, see Firefox's nsHttpChannel::ProcessNormal.
 
 // Mime types:
-const char kApplicationXGzip[]     = "application/x-gzip";
-const char kApplicationGzip[]      = "application/gzip";
-const char kApplicationXGunzip[]   = "application/x-gunzip";
 const char kTextHtml[]             = "text/html";
 
 // Buffer size allocated when de-compressing data.
 const int kFilterBufSize = 32 * 1024;
 
 void LogSdchProblem(const FilterContext& filter_context,
                     SdchProblemCode problem) {
   SdchManager::SdchErrorRecovery(problem);
   filter_context.GetNetLog().AddEvent(
       NetLog::TYPE_SDCH_DECODING_ERROR,
@@ skipping 132 matching lines @@
   } else if (LowerCaseEqualsASCII(filter_type, kSdch)) {
     type_id = FILTER_TYPE_SDCH;
   } else {
     // Note we also consider "identity" and "uncompressed" UNSUPPORTED as
     // filter should be disabled in such cases.
     type_id = FILTER_TYPE_UNSUPPORTED;
   }
   return type_id;
 }
 
-namespace {
-
-// Result of running FixupEncodingTypes with a Content-Encoding of gzip. This
-// enum is used for UMA and is available in histograms.xml as
-// GzipEncodingFixupResult.
-enum GzipEncodingFixupResult {
-  GZIP_ENCODING_LEFT_AS_IS = 0,
-
-  // Cleared because a resource with a GZIP MIME type was being transferred with
-  // a Content-Encoding of gzip.
-  GZIP_ENCODING_CLEARED_DUE_TO_GZIP_MIME_TYPE = 1,
-
-  // Cleared because the resource is known to be a download and the resulting
-  // file had a filename that indicating that the contents are GZIP.
-  GZIP_ENCODING_CLEARED_DUE_TO_DOWNLOAD_OF_GZIP_FILE = 2,
-
-  // Cleared because the resource is not a handled MIME type (and hence will be
-  // downloaded), and the predicted filename is one that indicates the contents
-  // to be GZIP.
-  GZIP_ENCODING_CLEARED_DUE_TO_UNHANDLED_GZIP_NAME = 3,
-
-  GZIP_ENCODING_FIXUP_RESULT_MAX_ENTRIES
-};
-
-}  // namespace
-
 // static
 void Filter::FixupEncodingTypes(
     const FilterContext& filter_context,
     std::vector<FilterType>* encoding_types) {
   std::string mime_type;
   bool success = filter_context.GetMimeType(&mime_type);
   DCHECK(success || mime_type.empty());
 
-  if ((1 == encoding_types->size()) &&
-      (FILTER_TYPE_GZIP == encoding_types->front())) {
-    GzipEncodingFixupResult fixup_result = GZIP_ENCODING_LEFT_AS_IS;
-    if (LowerCaseEqualsASCII(mime_type, kApplicationXGzip) ||
-        LowerCaseEqualsASCII(mime_type, kApplicationGzip) ||
-        LowerCaseEqualsASCII(mime_type, kApplicationXGunzip)) {
-      // The server has told us that it sent us gziped content with a gzip
-      // content encoding. Sadly, Apache mistakenly sets these headers for all
-      // .gz files. We match Firefox's nsHttpChannel::ProcessNormal and ignore
-      // the Content-Encoding here.
-      encoding_types->clear();
-      fixup_result = GZIP_ENCODING_CLEARED_DUE_TO_GZIP_MIME_TYPE;
-    }
-
-    GURL url;
-    std::string disposition;
-    success = filter_context.GetURL(&url);
-    DCHECK(success);
-    filter_context.GetContentDisposition(&disposition);
-    // Don't supply a MIME type here, since that may cause disk IO.
-    base::FilePath::StringType extension =
-        GenerateFileExtensionUnsafe(url, disposition, "UTF-8", "", "", "");
-
-    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 (EndsWith(extension, FILE_PATH_LITERAL(".gz"), false) ||
-          LowerCaseEqualsASCII(extension, ".tgz") ||
-          LowerCaseEqualsASCII(extension, ".svgz")) {
-        encoding_types->clear();
-        fixup_result = GZIP_ENCODING_CLEARED_DUE_TO_DOWNLOAD_OF_GZIP_FILE;
-      }
-    } 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 ((EndsWith(extension, FILE_PATH_LITERAL(".gz"), false) ||
-           LowerCaseEqualsASCII(extension, ".tgz")) &&
-          !IsSupportedMimeType(mime_type)) {
-        encoding_types->clear();
-        fixup_result = GZIP_ENCODING_CLEARED_DUE_TO_UNHANDLED_GZIP_NAME;
-      }
-    }
-
-    UMA_HISTOGRAM_ENUMERATION("Net.GzipEncodingFixupResult", fixup_result,
-                              GZIP_ENCODING_FIXUP_RESULT_MAX_ENTRIES);
-  }
+  // Historical note: Once upon a time this method used to clear the encoding
+  // types list if it only contained FILTER_TYPE_GZIP and the response was
+  // likely to be downloaded as a file with gzipped contents. In this case, the
+  // Content-Encoding is incorrect since there was no intention for the content
+  // to be decompressed. UMA indicated that the number of servers that exhibit
+  // this behavior is small, and hence we no longer ignore Content-Encoding for
+  // downloads.

[Ryan Sleevi, 2015/03/19 02:55:06]

I'm inclined to suggest nuking this whole bit.

I don't think there's ever been a time where I've looked through the code and
wanted to know what the "once upon a time" was; for that, there's source control
history.

[Randy Smith (Not in Mondays), 2015/03/19 15:01:06]

+1 :-}.

[asanka, 2015/03/19 20:27:52]

Cool. I removed the comment.

I thought I'd add the tombstone to document why we aren't doing this since it's
sometimes difficult to determine whether the absence of code is intentional or
not. It wasn't meant to document revision history.

Relatedly, I recently discovered 'git log -L'. E.g.

  git log -L /FixupEncodingTypes\(/,/^}/:net/filter/filter.cc

will give a nice trace through history of how this function evolved. Pretty neat
and useful for this sort of code archaeology.

 
   // If the request was for SDCH content, then we might need additional fixups.
   if (!filter_context.SdchDictionariesAdvertised()) {
     // It was not an SDCH request, so we'll just record stats.
     if (1 < encoding_types->size()) {
       // Multiple filters were intended to only be used for SDCH (thus far!)
       LogSdchProblem(filter_context, SDCH_MULTIENCODING_FOR_NON_SDCH_REQUEST);
     }
     if ((1 == encoding_types->size()) &&
         (FILTER_TYPE_SDCH == encoding_types->front())) {
@@ skipping 185 matching lines @@
 
 void Filter::PushDataIntoNextFilter() {
   IOBuffer* next_buffer = next_filter_->stream_buffer();
   int next_size = next_filter_->stream_buffer_size();
   last_status_ = ReadFilteredData(next_buffer->data(), &next_size);
   if (FILTER_ERROR != last_status_)
     next_filter_->FlushStreamBuffer(next_size);
 }
 
 }  // namespace net