[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);
-  }
-
   // 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())) {
       LogSdchProblem(filter_context,
@@ skipping 184 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