Reject unadvertised encodings

net/url_request/url_request_http_job.cc

 // Copyright (c) 2012 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.
 
 #include "net/url_request/url_request_http_job.h"
 
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
@@ skipping 58 matching lines @@
 #include "url/origin.h"
 
 #if defined(OS_ANDROID)
 #include "net/android/network_library.h"
 #endif
 
 static const char kAvailDictionaryHeader[] = "Avail-Dictionary";
 
 namespace {
 
-const char kDeflate[] = "deflate";
-const char kGZip[] = "gzip";
-const char kSdch[] = "sdch";
-const char kXGZip[] = "x-gzip";
-const char kBrotli[] = "br";
-
 // True if the request method is "safe" (per section 4.2.1 of RFC 7231).
 bool IsMethodSafe(const std::string& method) {
   return method == "GET" || method == "HEAD" || method == "OPTIONS" ||
          method == "TRACE";
 }
 
 // Logs whether the CookieStore used for this request matches the
 // ChannelIDService used when establishing the connection that this request is
 // sent over. This logging is only done for requests to accounts.google.com, and
 // only for requests where Channel ID was sent when establishing the connection.
@@ skipping 962 matching lines @@
   DCHECK(transaction_.get());
   if (!response_info_)
     return nullptr;
 
   std::unique_ptr<SourceStream> upstream = URLRequestJob::SetUpSourceStream();
   HttpResponseHeaders* headers = GetResponseHeaders();
   std::string type;
   std::vector<SourceStream::SourceType> types;
   size_t iter = 0;
   while (headers->EnumerateHeader(&iter, "Content-Encoding", &type)) {
-    if (base::LowerCaseEqualsASCII(type, kBrotli)) {
-      types.push_back(SourceStream::TYPE_BROTLI);
-    } else if (base::LowerCaseEqualsASCII(type, kDeflate)) {
-      types.push_back(SourceStream::TYPE_DEFLATE);
-    } else if (base::LowerCaseEqualsASCII(type, kGZip) ||
-               base::LowerCaseEqualsASCII(type, kXGZip)) {
-      types.push_back(SourceStream::TYPE_GZIP);
-    } else if (base::LowerCaseEqualsASCII(type, kSdch)) {
+    SourceStream::SourceType source_type =
+        FilterSourceStream::ParseEncodingType(type);
+    if (source_type == SourceStream::TYPE_SDCH &&
+        !request()->context()->sdch_manager()) {
       // If SDCH support is not configured, pass through raw response.
-      if (!request()->context()->sdch_manager())
+      return upstream;
+    }
+    switch (source_type) {
+      case SourceStream::TYPE_BROTLI:
+      case SourceStream::TYPE_DEFLATE:
+      case SourceStream::TYPE_GZIP:
+      case SourceStream::TYPE_SDCH:
+        types.push_back(source_type);
+        break;
+      case SourceStream::TYPE_NONE:
+        // Identity encoding type. Pass through raw response body.
         return upstream;
-      types.push_back(SourceStream::TYPE_SDCH);
-    } else {
-      // Unknown encoding type. Pass through raw response body.
-      return upstream;
+      default:
+        // Unknown encoding type. Pass through raw response body.
+        // Despite of reporting to UMA, request will not be canceled; though
+        // it is expected that user will see malformed / garbage response.
+        FilterSourceStream::ReportContentDecodingFailed(
+            FilterSourceStream::TYPE_UNKNOWN);
+        return upstream;
     }
   }
 
   // Sdch specific hacks:
   std::string mime_type;
   bool success = GetMimeType(&mime_type);
   DCHECK(success || mime_type.empty());
   SdchPolicyDelegate::FixUpSdchContentEncodings(
       request()->net_log(), mime_type, dictionaries_advertised_.get(), &types);
 
@@ skipping 20 matching lines @@
         }
         break;
       }
       case SourceStream::TYPE_GZIP:
       case SourceStream::TYPE_DEFLATE:
       case SourceStream::TYPE_GZIP_FALLBACK:
         downstream = GzipSourceStream::Create(std::move(upstream), type);
         break;
       case SourceStream::TYPE_NONE:
       case SourceStream::TYPE_INVALID:
+      case SourceStream::TYPE_REJECTED:
+      case SourceStream::TYPE_UNKNOWN:
       case SourceStream::TYPE_MAX:
         NOTREACHED();
         return nullptr;
     }
     if (downstream == nullptr)
       return nullptr;
     upstream = std::move(downstream);
   }
 
   return upstream;
@@ skipping 419 matching lines @@
   awaiting_callback_ = false;
 
   // Notify NetworkQualityEstimator.
   NetworkQualityEstimator* network_quality_estimator =
       request()->context()->network_quality_estimator();
   if (network_quality_estimator)
     network_quality_estimator->NotifyURLRequestDestroyed(*request());
 }
 
 }  // namespace net