Adding upstream version 115.8.0esr.upstream/115.8.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1359 insertions, 0 deletions

diff --git a/netwerk/protocol/http/nsHttpResponseHead.cpp b/netwerk/protocol/http/nsHttpResponseHead.cpp
new file mode 100644
index 0000000000..1ce51afd93
--- /dev/null
+++ b/netwerk/protocol/http/nsHttpResponseHead.cpp
@@ -0,0 +1,1359 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=4 sw=2 sts=2 et cin: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// HttpLog.h should generally be included first
+#include "HttpLog.h"
+
+#include "mozilla/Unused.h"
+#include "nsHttpResponseHead.h"
+#include "nsIHttpHeaderVisitor.h"
+#include "nsPrintfCString.h"
+#include "prtime.h"
+#include "nsCRT.h"
+#include "nsURLHelper.h"
+#include "CacheControlParser.h"
+#include <algorithm>
+
+namespace mozilla {
+namespace net {
+
+//-----------------------------------------------------------------------------
+// nsHttpResponseHead <public>
+//-----------------------------------------------------------------------------
+
+// Note that the code below MUST be synchronized with the IPC
+// serialization/deserialization in PHttpChannelParams.h.
+nsHttpResponseHead::nsHttpResponseHead(const nsHttpResponseHead& aOther) {
+  nsHttpResponseHead& other = const_cast<nsHttpResponseHead&>(aOther);
+  RecursiveMutexAutoLock monitor(other.mRecursiveMutex);
+
+  mHeaders = other.mHeaders;
+  mVersion = other.mVersion;
+  mStatus = other.mStatus;
+  mStatusText = other.mStatusText;
+  mContentLength = other.mContentLength;
+  mContentType = other.mContentType;
+  mContentCharset = other.mContentCharset;
+  mHasCacheControl = other.mHasCacheControl;
+  mCacheControlPublic = other.mCacheControlPublic;
+  mCacheControlPrivate = other.mCacheControlPrivate;
+  mCacheControlNoStore = other.mCacheControlNoStore;
+  mCacheControlNoCache = other.mCacheControlNoCache;
+  mCacheControlImmutable = other.mCacheControlImmutable;
+  mCacheControlStaleWhileRevalidateSet =
+      other.mCacheControlStaleWhileRevalidateSet;
+  mCacheControlStaleWhileRevalidate = other.mCacheControlStaleWhileRevalidate;
+  mCacheControlMaxAgeSet = other.mCacheControlMaxAgeSet;
+  mCacheControlMaxAge = other.mCacheControlMaxAge;
+  mPragmaNoCache = other.mPragmaNoCache;
+}
+
+nsHttpResponseHead& nsHttpResponseHead::operator=(
+    const nsHttpResponseHead& aOther) {
+  nsHttpResponseHead& other = const_cast<nsHttpResponseHead&>(aOther);
+  RecursiveMutexAutoLock monitorOther(other.mRecursiveMutex);
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+
+  mHeaders = other.mHeaders;
+  mVersion = other.mVersion;
+  mStatus = other.mStatus;
+  mStatusText = other.mStatusText;
+  mContentLength = other.mContentLength;
+  mContentType = other.mContentType;
+  mContentCharset = other.mContentCharset;
+  mHasCacheControl = other.mHasCacheControl;
+  mCacheControlPublic = other.mCacheControlPublic;
+  mCacheControlPrivate = other.mCacheControlPrivate;
+  mCacheControlNoStore = other.mCacheControlNoStore;
+  mCacheControlNoCache = other.mCacheControlNoCache;
+  mCacheControlImmutable = other.mCacheControlImmutable;
+  mCacheControlStaleWhileRevalidateSet =
+      other.mCacheControlStaleWhileRevalidateSet;
+  mCacheControlStaleWhileRevalidate = other.mCacheControlStaleWhileRevalidate;
+  mCacheControlMaxAgeSet = other.mCacheControlMaxAgeSet;
+  mCacheControlMaxAge = other.mCacheControlMaxAge;
+  mPragmaNoCache = other.mPragmaNoCache;
+
+  return *this;
+}
+
+HttpVersion nsHttpResponseHead::Version() {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return mVersion;
+}
+
+uint16_t nsHttpResponseHead::Status() const {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return mStatus;
+}
+
+void nsHttpResponseHead::StatusText(nsACString& aStatusText) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  aStatusText = mStatusText;
+}
+
+int64_t nsHttpResponseHead::ContentLength() {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return mContentLength;
+}
+
+void nsHttpResponseHead::ContentType(nsACString& aContentType) const {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  aContentType = mContentType;
+}
+
+void nsHttpResponseHead::ContentCharset(nsACString& aContentCharset) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  aContentCharset = mContentCharset;
+}
+
+bool nsHttpResponseHead::Public() {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return mCacheControlPublic;
+}
+
+bool nsHttpResponseHead::Private() {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return mCacheControlPrivate;
+}
+
+bool nsHttpResponseHead::NoStore() {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return mCacheControlNoStore;
+}
+
+bool nsHttpResponseHead::NoCache() {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return NoCache_locked();
+}
+
+bool nsHttpResponseHead::Immutable() {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return mCacheControlImmutable;
+}
+
+nsresult nsHttpResponseHead::SetHeader(const nsACString& hdr,
+                                       const nsACString& val, bool merge) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+
+  if (mInVisitHeaders) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsHttpAtom atom = nsHttp::ResolveAtom(hdr);
+  if (!atom) {
+    NS_WARNING("failed to resolve atom");
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return SetHeader_locked(atom, hdr, val, merge);
+}
+
+nsresult nsHttpResponseHead::SetHeader(const nsHttpAtom& hdr,
+                                       const nsACString& val, bool merge) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+
+  if (mInVisitHeaders) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return SetHeader_locked(hdr, ""_ns, val, merge);
+}
+
+nsresult nsHttpResponseHead::SetHeader_locked(const nsHttpAtom& atom,
+                                              const nsACString& hdr,
+                                              const nsACString& val,
+                                              bool merge) {
+  nsresult rv = mHeaders.SetHeader(atom, hdr, val, merge,
+                                   nsHttpHeaderArray::eVarietyResponse);
+  if (NS_FAILED(rv)) return rv;
+
+  // respond to changes in these headers.  we need to reparse the entire
+  // header since the change may have merged in additional values.
+  if (atom == nsHttp::Cache_Control) {
+    ParseCacheControl(mHeaders.PeekHeader(atom));
+  } else if (atom == nsHttp::Pragma) {
+    ParsePragma(mHeaders.PeekHeader(atom));
+  }
+
+  return NS_OK;
+}
+
+nsresult nsHttpResponseHead::GetHeader(const nsHttpAtom& h,
+                                       nsACString& v) const {
+  v.Truncate();
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return mHeaders.GetHeader(h, v);
+}
+
+void nsHttpResponseHead::ClearHeader(const nsHttpAtom& h) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  mHeaders.ClearHeader(h);
+}
+
+void nsHttpResponseHead::ClearHeaders() {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  mHeaders.Clear();
+}
+
+bool nsHttpResponseHead::HasHeaderValue(const nsHttpAtom& h, const char* v) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return mHeaders.HasHeaderValue(h, v);
+}
+
+bool nsHttpResponseHead::HasHeader(const nsHttpAtom& h) const {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return mHeaders.HasHeader(h);
+}
+
+void nsHttpResponseHead::SetContentType(const nsACString& s) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  mContentType = s;
+}
+
+void nsHttpResponseHead::SetContentCharset(const nsACString& s) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  mContentCharset = s;
+}
+
+void nsHttpResponseHead::SetContentLength(int64_t len) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+
+  mContentLength = len;
+  if (len < 0) {
+    mHeaders.ClearHeader(nsHttp::Content_Length);
+  } else {
+    DebugOnly<nsresult> rv = mHeaders.SetHeader(
+        nsHttp::Content_Length, nsPrintfCString("%" PRId64, len), false,
+        nsHttpHeaderArray::eVarietyResponse);
+    MOZ_ASSERT(NS_SUCCEEDED(rv));
+  }
+}
+
+void nsHttpResponseHead::Flatten(nsACString& buf, bool pruneTransients) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  if (mVersion == HttpVersion::v0_9) return;
+
+  buf.AppendLiteral("HTTP/");
+  if (mVersion == HttpVersion::v3_0) {
+    buf.AppendLiteral("3 ");
+  } else if (mVersion == HttpVersion::v2_0) {
+    buf.AppendLiteral("2 ");
+  } else if (mVersion == HttpVersion::v1_1) {
+    buf.AppendLiteral("1.1 ");
+  } else {
+    buf.AppendLiteral("1.0 ");
+  }
+
+  buf.Append(nsPrintfCString("%u", unsigned(mStatus)) + " "_ns + mStatusText +
+             "\r\n"_ns);
+
+  mHeaders.Flatten(buf, false, pruneTransients);
+}
+
+void nsHttpResponseHead::FlattenNetworkOriginalHeaders(nsACString& buf) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  if (mVersion == HttpVersion::v0_9) {
+    return;
+  }
+
+  mHeaders.FlattenOriginalHeader(buf);
+}
+
+nsresult nsHttpResponseHead::ParseCachedHead(const char* block) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  LOG(("nsHttpResponseHead::ParseCachedHead [this=%p]\n", this));
+
+  // this command works on a buffer as prepared by Flatten, as such it is
+  // not very forgiving ;-)
+
+  const char* p = strstr(block, "\r\n");
+  if (!p) return NS_ERROR_UNEXPECTED;
+
+  ParseStatusLine_locked(nsDependentCSubstring(block, p - block));
+
+  do {
+    block = p + 2;
+
+    if (*block == 0) break;
+
+    p = strstr(block, "\r\n");
+    if (!p) return NS_ERROR_UNEXPECTED;
+
+    Unused << ParseHeaderLine_locked(nsDependentCSubstring(block, p - block),
+                                     false);
+
+  } while (true);
+
+  return NS_OK;
+}
+
+nsresult nsHttpResponseHead::ParseCachedOriginalHeaders(char* block) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  LOG(("nsHttpResponseHead::ParseCachedOriginalHeader [this=%p]\n", this));
+
+  // this command works on a buffer as prepared by FlattenOriginalHeader,
+  // as such it is not very forgiving ;-)
+
+  if (!block) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  char* p = block;
+  nsHttpAtom hdr;
+  nsAutoCString headerNameOriginal;
+  nsAutoCString val;
+  nsresult rv;
+
+  do {
+    block = p;
+
+    if (*block == 0) break;
+
+    p = strstr(block, "\r\n");
+    if (!p) return NS_ERROR_UNEXPECTED;
+
+    *p = 0;
+    if (NS_FAILED(nsHttpHeaderArray::ParseHeaderLine(
+            nsDependentCString(block, p - block), &hdr, &headerNameOriginal,
+            &val))) {
+      return NS_OK;
+    }
+
+    rv = mHeaders.SetResponseHeaderFromCache(
+        hdr, headerNameOriginal, val,
+        nsHttpHeaderArray::eVarietyResponseNetOriginal);
+
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+
+    p = p + 2;
+  } while (true);
+
+  return NS_OK;
+}
+
+void nsHttpResponseHead::AssignDefaultStatusText() {
+  LOG(("response status line needs default reason phrase\n"));
+
+  // if a http response doesn't contain a reason phrase, put one in based
+  // on the status code. The reason phrase is totally meaningless so its
+  // ok to have a default catch all here - but this makes debuggers and addons
+  // a little saner to use if we don't map things to "404 OK" or other nonsense.
+  // In particular, HTTP/2 does not use reason phrases at all so they need to
+  // always be injected.
+
+  switch (mStatus) {
+      // start with the most common
+    case 200:
+      mStatusText.AssignLiteral("OK");
+      break;
+    case 404:
+      mStatusText.AssignLiteral("Not Found");
+      break;
+    case 301:
+      mStatusText.AssignLiteral("Moved Permanently");
+      break;
+    case 304:
+      mStatusText.AssignLiteral("Not Modified");
+      break;
+    case 307:
+      mStatusText.AssignLiteral("Temporary Redirect");
+      break;
+    case 500:
+      mStatusText.AssignLiteral("Internal Server Error");
+      break;
+
+      // also well known
+    case 100:
+      mStatusText.AssignLiteral("Continue");
+      break;
+    case 101:
+      mStatusText.AssignLiteral("Switching Protocols");
+      break;
+    case 201:
+      mStatusText.AssignLiteral("Created");
+      break;
+    case 202:
+      mStatusText.AssignLiteral("Accepted");
+      break;
+    case 203:
+      mStatusText.AssignLiteral("Non Authoritative");
+      break;
+    case 204:
+      mStatusText.AssignLiteral("No Content");
+      break;
+    case 205:
+      mStatusText.AssignLiteral("Reset Content");
+      break;
+    case 206:
+      mStatusText.AssignLiteral("Partial Content");
+      break;
+    case 207:
+      mStatusText.AssignLiteral("Multi-Status");
+      break;
+    case 208:
+      mStatusText.AssignLiteral("Already Reported");
+      break;
+    case 300:
+      mStatusText.AssignLiteral("Multiple Choices");
+      break;
+    case 302:
+      mStatusText.AssignLiteral("Found");
+      break;
+    case 303:
+      mStatusText.AssignLiteral("See Other");
+      break;
+    case 305:
+      mStatusText.AssignLiteral("Use Proxy");
+      break;
+    case 308:
+      mStatusText.AssignLiteral("Permanent Redirect");
+      break;
+    case 400:
+      mStatusText.AssignLiteral("Bad Request");
+      break;
+    case 401:
+      mStatusText.AssignLiteral("Unauthorized");
+      break;
+    case 402:
+      mStatusText.AssignLiteral("Payment Required");
+      break;
+    case 403:
+      mStatusText.AssignLiteral("Forbidden");
+      break;
+    case 405:
+      mStatusText.AssignLiteral("Method Not Allowed");
+      break;
+    case 406:
+      mStatusText.AssignLiteral("Not Acceptable");
+      break;
+    case 407:
+      mStatusText.AssignLiteral("Proxy Authentication Required");
+      break;
+    case 408:
+      mStatusText.AssignLiteral("Request Timeout");
+      break;
+    case 409:
+      mStatusText.AssignLiteral("Conflict");
+      break;
+    case 410:
+      mStatusText.AssignLiteral("Gone");
+      break;
+    case 411:
+      mStatusText.AssignLiteral("Length Required");
+      break;
+    case 412:
+      mStatusText.AssignLiteral("Precondition Failed");
+      break;
+    case 413:
+      mStatusText.AssignLiteral("Request Entity Too Large");
+      break;
+    case 414:
+      mStatusText.AssignLiteral("Request URI Too Long");
+      break;
+    case 415:
+      mStatusText.AssignLiteral("Unsupported Media Type");
+      break;
+    case 416:
+      mStatusText.AssignLiteral("Requested Range Not Satisfiable");
+      break;
+    case 417:
+      mStatusText.AssignLiteral("Expectation Failed");
+      break;
+    case 418:
+      mStatusText.AssignLiteral("I'm a teapot");
+      break;
+    case 421:
+      mStatusText.AssignLiteral("Misdirected Request");
+      break;
+    case 422:
+      mStatusText.AssignLiteral("Unprocessable Entity");
+      break;
+    case 423:
+      mStatusText.AssignLiteral("Locked");
+      break;
+    case 424:
+      mStatusText.AssignLiteral("Failed Dependency");
+      break;
+    case 425:
+      mStatusText.AssignLiteral("Too Early");
+      break;
+    case 426:
+      mStatusText.AssignLiteral("Upgrade Required");
+      break;
+    case 428:
+      mStatusText.AssignLiteral("Precondition Required");
+      break;
+    case 429:
+      mStatusText.AssignLiteral("Too Many Requests");
+      break;
+    case 431:
+      mStatusText.AssignLiteral("Request Header Fields Too Large");
+      break;
+    case 451:
+      mStatusText.AssignLiteral("Unavailable For Legal Reasons");
+      break;
+    case 501:
+      mStatusText.AssignLiteral("Not Implemented");
+      break;
+    case 502:
+      mStatusText.AssignLiteral("Bad Gateway");
+      break;
+    case 503:
+      mStatusText.AssignLiteral("Service Unavailable");
+      break;
+    case 504:
+      mStatusText.AssignLiteral("Gateway Timeout");
+      break;
+    case 505:
+      mStatusText.AssignLiteral("HTTP Version Unsupported");
+      break;
+    case 506:
+      mStatusText.AssignLiteral("Variant Also Negotiates");
+      break;
+    case 507:
+      mStatusText.AssignLiteral("Insufficient Storage ");
+      break;
+    case 508:
+      mStatusText.AssignLiteral("Loop Detected");
+      break;
+    case 510:
+      mStatusText.AssignLiteral("Not Extended");
+      break;
+    case 511:
+      mStatusText.AssignLiteral("Network Authentication Required");
+      break;
+    default:
+      mStatusText.AssignLiteral("No Reason Phrase");
+      break;
+  }
+}
+
+void nsHttpResponseHead::ParseStatusLine(const nsACString& line) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  ParseStatusLine_locked(line);
+}
+
+void nsHttpResponseHead::ParseStatusLine_locked(const nsACString& line) {
+  //
+  // Parse Status-Line:: HTTP-Version SP Status-Code SP Reason-Phrase CRLF
+  //
+
+  const char* start = line.BeginReading();
+  const char* end = line.EndReading();
+  const char* p = start;
+
+  // HTTP-Version
+  ParseVersion(start);
+
+  int32_t index = line.FindChar(' ');
+
+  if ((mVersion == HttpVersion::v0_9) || (index == -1)) {
+    mStatus = 200;
+    AssignDefaultStatusText();
+  } else {
+    // Status-Code
+    p += index + 1;
+    mStatus = (uint16_t)atoi(p);
+    if (mStatus == 0) {
+      LOG(("mal-formed response status; assuming status = 200\n"));
+      mStatus = 200;
+    }
+
+    // Reason-Phrase is whatever is remaining of the line
+    index = line.FindChar(' ', p - start);
+    if (index == -1) {
+      AssignDefaultStatusText();
+    } else {
+      p = start + index + 1;
+      mStatusText = nsDependentCSubstring(p, end - p);
+    }
+  }
+
+  LOG1(("Have status line [version=%u status=%u statusText=%s]\n",
+        unsigned(mVersion), unsigned(mStatus), mStatusText.get()));
+}
+
+nsresult nsHttpResponseHead::ParseHeaderLine(const nsACString& line) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return ParseHeaderLine_locked(line, true);
+}
+
+nsresult nsHttpResponseHead::ParseHeaderLine_locked(
+    const nsACString& line, bool originalFromNetHeaders) {
+  nsHttpAtom hdr;
+  nsAutoCString headerNameOriginal;
+  nsAutoCString val;
+
+  if (NS_FAILED(nsHttpHeaderArray::ParseHeaderLine(
+          line, &hdr, &headerNameOriginal, &val))) {
+    return NS_OK;
+  }
+  nsresult rv;
+  if (originalFromNetHeaders) {
+    rv = mHeaders.SetHeaderFromNet(hdr, headerNameOriginal, val, true);
+  } else {
+    rv = mHeaders.SetResponseHeaderFromCache(
+        hdr, headerNameOriginal, val, nsHttpHeaderArray::eVarietyResponse);
+  }
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  // leading and trailing LWS has been removed from |val|
+
+  // handle some special case headers...
+  if (hdr == nsHttp::Content_Length) {
+    rv = ParseResponseContentLength(val);
+    if (rv == NS_ERROR_ILLEGAL_VALUE) {
+      LOG(("illegal content-length! %s\n", val.get()));
+      return rv;
+    }
+
+    if (rv == NS_ERROR_NOT_AVAILABLE) {
+      LOG(("content-length value ignored! %s\n", val.get()));
+    }
+
+  } else if (hdr == nsHttp::Content_Type) {
+    LOG(("ParseContentType [type=%s]\n", val.get()));
+    bool dummy;
+    net_ParseContentType(val, mContentType, mContentCharset, &dummy);
+  } else if (hdr == nsHttp::Cache_Control) {
+    ParseCacheControl(val.get());
+  } else if (hdr == nsHttp::Pragma) {
+    ParsePragma(val.get());
+  }
+  return NS_OK;
+}
+
+// From section 13.2.3 of RFC2616, we compute the current age of a cached
+// response as follows:
+//
+//    currentAge = max(max(0, responseTime - dateValue), ageValue)
+//               + now - requestTime
+//
+//    where responseTime == now
+//
+// This is typically a very small number.
+//
+nsresult nsHttpResponseHead::ComputeCurrentAge(uint32_t now,
+                                               uint32_t requestTime,
+                                               uint32_t* result) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  uint32_t dateValue;
+  uint32_t ageValue;
+
+  *result = 0;
+
+  if (requestTime > now) {
+    // for calculation purposes lets not allow the request to happen in the
+    // future
+    requestTime = now;
+  }
+
+  if (NS_FAILED(GetDateValue_locked(&dateValue))) {
+    LOG(
+        ("nsHttpResponseHead::ComputeCurrentAge [this=%p] "
+         "Date response header not set!\n",
+         this));
+    // Assume we have a fast connection and that our clock
+    // is in sync with the server.
+    dateValue = now;
+  }
+
+  // Compute apparent age
+  if (now > dateValue) *result = now - dateValue;
+
+  // Compute corrected received age
+  if (NS_SUCCEEDED(GetAgeValue_locked(&ageValue))) {
+    *result = std::max(*result, ageValue);
+  }
+
+  // Compute current age
+  *result += (now - requestTime);
+  return NS_OK;
+}
+
+// From section 13.2.4 of RFC2616, we compute the freshness lifetime of a cached
+// response as follows:
+//
+//     freshnessLifetime = max_age_value
+// <or>
+//     freshnessLifetime = expires_value - date_value
+// <or>
+//     freshnessLifetime = min(one-week,
+//                             (date_value - last_modified_value) * 0.10)
+// <or>
+//     freshnessLifetime = 0
+//
+nsresult nsHttpResponseHead::ComputeFreshnessLifetime(uint32_t* result) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  *result = 0;
+
+  // Try HTTP/1.1 style max-age directive...
+  if (NS_SUCCEEDED(GetMaxAgeValue_locked(result))) return NS_OK;
+
+  *result = 0;
+
+  uint32_t date = 0, date2 = 0;
+  if (NS_FAILED(GetDateValue_locked(&date))) {
+    date = NowInSeconds();  // synthesize a date header if none exists
+  }
+
+  // Try HTTP/1.0 style expires header...
+  if (NS_SUCCEEDED(GetExpiresValue_locked(&date2))) {
+    if (date2 > date) *result = date2 - date;
+    // the Expires header can specify a date in the past.
+    return NS_OK;
+  }
+
+  // These responses can be cached indefinitely.
+  if ((mStatus == 300) || (mStatus == 410) ||
+      nsHttp::IsPermanentRedirect(mStatus)) {
+    LOG(
+        ("nsHttpResponseHead::ComputeFreshnessLifetime [this = %p] "
+         "Assign an infinite heuristic lifetime\n",
+         this));
+    *result = uint32_t(-1);
+    return NS_OK;
+  }
+
+  if (mStatus >= 400) {
+    LOG(
+        ("nsHttpResponseHead::ComputeFreshnessLifetime [this = %p] "
+         "Do not calculate heuristic max-age for most responses >= 400\n",
+         this));
+    return NS_OK;
+  }
+
+  // From RFC 7234 Section 4.2.2, heuristics can only be used on responses
+  // without explicit freshness whose status codes are defined as cacheable
+  // by default, and those responses without explicit freshness that have been
+  // marked as explicitly cacheable.
+  // Note that |MustValidate| handled most of non-cacheable status codes.
+  if ((mStatus == 302 || mStatus == 304 || mStatus == 307) &&
+      !mCacheControlPublic && !mCacheControlPrivate) {
+    LOG((
+        "nsHttpResponseHead::ComputeFreshnessLifetime [this = %p] "
+        "Do not calculate heuristic max-age for non-cacheable status code %u\n",
+        this, unsigned(mStatus)));
+    return NS_OK;
+  }
+
+  // Fallback on heuristic using last modified header...
+  if (NS_SUCCEEDED(GetLastModifiedValue_locked(&date2))) {
+    LOG(("using last-modified to determine freshness-lifetime\n"));
+    LOG(("last-modified = %u, date = %u\n", date2, date));
+    if (date2 <= date) {
+      // this only makes sense if last-modified is actually in the past
+      *result = (date - date2) / 10;
+      const uint32_t kOneWeek = 60 * 60 * 24 * 7;
+      *result = std::min(kOneWeek, *result);
+      return NS_OK;
+    }
+  }
+
+  LOG(
+      ("nsHttpResponseHead::ComputeFreshnessLifetime [this = %p] "
+       "Insufficient information to compute a non-zero freshness "
+       "lifetime!\n",
+       this));
+
+  return NS_OK;
+}
+
+bool nsHttpResponseHead::MustValidate() {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  LOG(("nsHttpResponseHead::MustValidate ??\n"));
+
+  // Some response codes are cacheable, but the rest are not. This switch should
+  // stay in sync with the list in nsHttpChannel::ContinueProcessResponse3
+  switch (mStatus) {
+      // Success codes
+    case 200:
+    case 203:
+    case 204:
+    case 206:
+      // Cacheable redirects
+    case 300:
+    case 301:
+    case 302:
+    case 304:
+    case 307:
+    case 308:
+      // Gone forever
+    case 410:
+      break;
+      // Uncacheable redirects
+    case 303:
+    case 305:
+      // Other known errors
+    case 401:
+    case 407:
+    case 412:
+    case 416:
+    case 425:
+    case 429:
+    default:  // revalidate unknown error pages
+      LOG(("Must validate since response is an uncacheable error page\n"));
+      return true;
+  }
+
+  // The no-cache response header indicates that we must validate this
+  // cached response before reusing.
+  if (NoCache_locked()) {
+    LOG(("Must validate since response contains 'no-cache' header\n"));
+    return true;
+  }
+
+  // Likewise, if the response is no-store, then we must validate this
+  // cached response before reusing.  NOTE: it may seem odd that a no-store
+  // response may be cached, but indeed all responses are cached in order
+  // to support File->SaveAs, View->PageSource, and other browser features.
+  if (mCacheControlNoStore) {
+    LOG(("Must validate since response contains 'no-store' header\n"));
+    return true;
+  }
+
+  // Compare the Expires header to the Date header.  If the server sent an
+  // Expires header with a timestamp in the past, then we must validate this
+  // cached response before reusing.
+  if (ExpiresInPast_locked()) {
+    LOG(("Must validate since Expires < Date\n"));
+    return true;
+  }
+
+  LOG(("no mandatory validation requirement\n"));
+  return false;
+}
+
+bool nsHttpResponseHead::MustValidateIfExpired() {
+  // according to RFC2616, section 14.9.4:
+  //
+  //  When the must-revalidate directive is present in a response received by a
+  //  cache, that cache MUST NOT use the entry after it becomes stale to respond
+  //  to a subsequent request without first revalidating it with the origin
+  //  server.
+  //
+  return HasHeaderValue(nsHttp::Cache_Control, "must-revalidate");
+}
+
+bool nsHttpResponseHead::StaleWhileRevalidate(uint32_t now,
+                                              uint32_t expiration) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+
+  if (expiration <= 0 || !mCacheControlStaleWhileRevalidateSet) {
+    return false;
+  }
+
+  // 'expiration' is the expiration time (an absolute unit), the swr window
+  // extends the expiration time.
+  CheckedInt<uint32_t> stallValidUntil = expiration;
+  stallValidUntil += mCacheControlStaleWhileRevalidate;
+  if (!stallValidUntil.isValid()) {
+    // overflow means an indefinite stale window
+    return true;
+  }
+
+  return now <= stallValidUntil.value();
+}
+
+bool nsHttpResponseHead::IsResumable() {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  // even though some HTTP/1.0 servers may support byte range requests, we're
+  // not going to bother with them, since those servers wouldn't understand
+  // If-Range. Also, while in theory it may be possible to resume when the
+  // status code is not 200, it is unlikely to be worth the trouble, especially
+  // for non-2xx responses.
+  return mStatus == 200 && mVersion >= HttpVersion::v1_1 &&
+         mHeaders.PeekHeader(nsHttp::Content_Length) &&
+         (mHeaders.PeekHeader(nsHttp::ETag) ||
+          mHeaders.PeekHeader(nsHttp::Last_Modified)) &&
+         mHeaders.HasHeaderValue(nsHttp::Accept_Ranges, "bytes");
+}
+
+bool nsHttpResponseHead::ExpiresInPast() {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return ExpiresInPast_locked();
+}
+
+bool nsHttpResponseHead::ExpiresInPast_locked() const {
+  uint32_t maxAgeVal, expiresVal, dateVal;
+
+  // Bug #203271. Ensure max-age directive takes precedence over Expires
+  if (NS_SUCCEEDED(GetMaxAgeValue_locked(&maxAgeVal))) {
+    return false;
+  }
+
+  return NS_SUCCEEDED(GetExpiresValue_locked(&expiresVal)) &&
+         NS_SUCCEEDED(GetDateValue_locked(&dateVal)) && expiresVal < dateVal;
+}
+
+void nsHttpResponseHead::UpdateHeaders(nsHttpResponseHead* aOther) {
+  LOG(("nsHttpResponseHead::UpdateHeaders [this=%p]\n", this));
+
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  RecursiveMutexAutoLock monitorOther(aOther->mRecursiveMutex);
+
+  uint32_t i, count = aOther->mHeaders.Count();
+  for (i = 0; i < count; ++i) {
+    nsHttpAtom header;
+    nsAutoCString headerNameOriginal;
+
+    if (!aOther->mHeaders.PeekHeaderAt(i, header, headerNameOriginal)) {
+      continue;
+    }
+
+    nsAutoCString val;
+    if (NS_FAILED(aOther->GetHeader(header, val))) {
+      continue;
+    }
+
+    // Ignore any hop-by-hop headers...
+    if (header == nsHttp::Connection || header == nsHttp::Proxy_Connection ||
+        header == nsHttp::Keep_Alive || header == nsHttp::Proxy_Authenticate ||
+        header == nsHttp::Proxy_Authorization ||  // not a response header!
+        header == nsHttp::TE || header == nsHttp::Trailer ||
+        header == nsHttp::Transfer_Encoding || header == nsHttp::Upgrade ||
+        // Ignore any non-modifiable headers...
+        header == nsHttp::Content_Location || header == nsHttp::Content_MD5 ||
+        header == nsHttp::ETag ||
+        // Assume Cache-Control: "no-transform"
+        header == nsHttp::Content_Encoding || header == nsHttp::Content_Range ||
+        header == nsHttp::Content_Type ||
+        // Ignore wacky headers too...
+        // this one is for MS servers that send "Content-Length: 0"
+        // on 304 responses
+        header == nsHttp::Content_Length) {
+      LOG(("ignoring response header [%s: %s]\n", header.get(), val.get()));
+    } else {
+      LOG(("new response header [%s: %s]\n", header.get(), val.get()));
+
+      // overwrite the current header value with the new value...
+      DebugOnly<nsresult> rv =
+          SetHeader_locked(header, headerNameOriginal, val);
+      MOZ_ASSERT(NS_SUCCEEDED(rv));
+    }
+  }
+}
+
+void nsHttpResponseHead::Reset() {
+  LOG(("nsHttpResponseHead::Reset\n"));
+
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+
+  mHeaders.Clear();
+
+  mVersion = HttpVersion::v1_1;
+  mStatus = 200;
+  mContentLength = -1;
+  mHasCacheControl = false;
+  mCacheControlPublic = false;
+  mCacheControlPrivate = false;
+  mCacheControlNoStore = false;
+  mCacheControlNoCache = false;
+  mCacheControlImmutable = false;
+  mCacheControlStaleWhileRevalidateSet = false;
+  mCacheControlStaleWhileRevalidate = 0;
+  mCacheControlMaxAgeSet = false;
+  mCacheControlMaxAge = 0;
+  mPragmaNoCache = false;
+  mStatusText.Truncate();
+  mContentType.Truncate();
+  mContentCharset.Truncate();
+}
+
+nsresult nsHttpResponseHead::ParseDateHeader(const nsHttpAtom& header,
+                                             uint32_t* result) const {
+  const char* val = mHeaders.PeekHeader(header);
+  if (!val) return NS_ERROR_NOT_AVAILABLE;
+
+  PRTime time;
+  PRStatus st = PR_ParseTimeString(val, true, &time);
+  if (st != PR_SUCCESS) return NS_ERROR_NOT_AVAILABLE;
+
+  *result = PRTimeToSeconds(time);
+  return NS_OK;
+}
+
+nsresult nsHttpResponseHead::GetAgeValue(uint32_t* result) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return GetAgeValue_locked(result);
+}
+
+nsresult nsHttpResponseHead::GetAgeValue_locked(uint32_t* result) const {
+  const char* val = mHeaders.PeekHeader(nsHttp::Age);
+  if (!val) return NS_ERROR_NOT_AVAILABLE;
+
+  *result = (uint32_t)atoi(val);
+  return NS_OK;
+}
+
+// Return the value of the (HTTP 1.1) max-age directive, which itself is a
+// component of the Cache-Control response header
+nsresult nsHttpResponseHead::GetMaxAgeValue(uint32_t* result) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return GetMaxAgeValue_locked(result);
+}
+
+nsresult nsHttpResponseHead::GetMaxAgeValue_locked(uint32_t* result) const {
+  if (!mCacheControlMaxAgeSet) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  *result = mCacheControlMaxAge;
+  return NS_OK;
+}
+
+nsresult nsHttpResponseHead::GetDateValue(uint32_t* result) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return GetDateValue_locked(result);
+}
+
+nsresult nsHttpResponseHead::GetExpiresValue(uint32_t* result) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return GetExpiresValue_locked(result);
+}
+
+nsresult nsHttpResponseHead::GetExpiresValue_locked(uint32_t* result) const {
+  const char* val = mHeaders.PeekHeader(nsHttp::Expires);
+  if (!val) return NS_ERROR_NOT_AVAILABLE;
+
+  PRTime time;
+  PRStatus st = PR_ParseTimeString(val, true, &time);
+  if (st != PR_SUCCESS) {
+    // parsing failed... RFC 2616 section 14.21 says we should treat this
+    // as an expiration time in the past.
+    *result = 0;
+    return NS_OK;
+  }
+
+  if (time < 0) {
+    *result = 0;
+  } else {
+    *result = PRTimeToSeconds(time);
+  }
+  return NS_OK;
+}
+
+nsresult nsHttpResponseHead::GetLastModifiedValue(uint32_t* result) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return ParseDateHeader(nsHttp::Last_Modified, result);
+}
+
+bool nsHttpResponseHead::operator==(const nsHttpResponseHead& aOther) const
+    MOZ_NO_THREAD_SAFETY_ANALYSIS {
+  nsHttpResponseHead& curr = const_cast<nsHttpResponseHead&>(*this);
+  nsHttpResponseHead& other = const_cast<nsHttpResponseHead&>(aOther);
+  RecursiveMutexAutoLock monitorOther(other.mRecursiveMutex);
+  RecursiveMutexAutoLock monitor(curr.mRecursiveMutex);
+
+  return mHeaders == aOther.mHeaders && mVersion == aOther.mVersion &&
+         mStatus == aOther.mStatus && mStatusText == aOther.mStatusText &&
+         mContentLength == aOther.mContentLength &&
+         mContentType == aOther.mContentType &&
+         mContentCharset == aOther.mContentCharset &&
+         mHasCacheControl == aOther.mHasCacheControl &&
+         mCacheControlPublic == aOther.mCacheControlPublic &&
+         mCacheControlPrivate == aOther.mCacheControlPrivate &&
+         mCacheControlNoCache == aOther.mCacheControlNoCache &&
+         mCacheControlNoStore == aOther.mCacheControlNoStore &&
+         mCacheControlImmutable == aOther.mCacheControlImmutable &&
+         mCacheControlStaleWhileRevalidateSet ==
+             aOther.mCacheControlStaleWhileRevalidateSet &&
+         mCacheControlStaleWhileRevalidate ==
+             aOther.mCacheControlStaleWhileRevalidate &&
+         mCacheControlMaxAgeSet == aOther.mCacheControlMaxAgeSet &&
+         mCacheControlMaxAge == aOther.mCacheControlMaxAge &&
+         mPragmaNoCache == aOther.mPragmaNoCache;
+}
+
+int64_t nsHttpResponseHead::TotalEntitySize() {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  const char* contentRange = mHeaders.PeekHeader(nsHttp::Content_Range);
+  if (!contentRange) return mContentLength;
+
+  // Total length is after a slash
+  const char* slash = strrchr(contentRange, '/');
+  if (!slash) return -1;  // No idea what the length is
+
+  slash++;
+  if (*slash == '*') {  // Server doesn't know the length
+    return -1;
+  }
+
+  int64_t size;
+  if (!nsHttp::ParseInt64(slash, &size)) size = UINT64_MAX;
+  return size;
+}
+
+//-----------------------------------------------------------------------------
+// nsHttpResponseHead <private>
+//-----------------------------------------------------------------------------
+
+void nsHttpResponseHead::ParseVersion(const char* str) {
+  // Parse HTTP-Version:: "HTTP" "/" 1*DIGIT "." 1*DIGIT
+
+  LOG(("nsHttpResponseHead::ParseVersion [version=%s]\n", str));
+
+  Tokenizer t(str, nullptr, "");
+  // make sure we have HTTP at the beginning
+  if (!t.CheckWord("HTTP")) {
+    if (nsCRT::strncasecmp(str, "ICY ", 4) == 0) {
+      // ShoutCast ICY is HTTP/1.0-like. Assume it is HTTP/1.0.
+      LOG(("Treating ICY as HTTP 1.0\n"));
+      mVersion = HttpVersion::v1_0;
+      return;
+    }
+    LOG(("looks like a HTTP/0.9 response\n"));
+    mVersion = HttpVersion::v0_9;
+    return;
+  }
+
+  if (!t.CheckChar('/')) {
+    LOG(("server did not send a version number; assuming HTTP/1.0\n"));
+    // NCSA/1.5.2 has a bug in which it fails to send a version number
+    // if the request version is HTTP/1.1, so we fall back on HTTP/1.0
+    mVersion = HttpVersion::v1_0;
+    return;
+  }
+
+  uint32_t major;
+  if (!t.ReadInteger(&major)) {
+    LOG(("server did not send a correct version number; assuming HTTP/1.0"));
+    mVersion = HttpVersion::v1_0;
+    return;
+  }
+
+  if (major == 3) {
+    mVersion = HttpVersion::v3_0;
+    return;
+  }
+
+  if (major == 2) {
+    mVersion = HttpVersion::v2_0;
+    return;
+  }
+
+  if (major != 1) {
+    LOG(("server did not send a correct version number; assuming HTTP/1.0"));
+    mVersion = HttpVersion::v1_0;
+    return;
+  }
+
+  if (!t.CheckChar('.')) {
+    LOG(("mal-formed server version; assuming HTTP/1.0\n"));
+    mVersion = HttpVersion::v1_0;
+    return;
+  }
+
+  uint32_t minor;
+  if (!t.ReadInteger(&minor)) {
+    LOG(("server did not send a correct version number; assuming HTTP/1.0"));
+    mVersion = HttpVersion::v1_0;
+    return;
+  }
+
+  if (minor >= 1) {
+    // at least HTTP/1.1
+    mVersion = HttpVersion::v1_1;
+  } else {
+    // treat anything else as version 1.0
+    mVersion = HttpVersion::v1_0;
+  }
+}
+
+void nsHttpResponseHead::ParseCacheControl(const char* val) {
+  if (!(val && *val)) {
+    // clear flags
+    mHasCacheControl = false;
+    mCacheControlPublic = false;
+    mCacheControlPrivate = false;
+    mCacheControlNoCache = false;
+    mCacheControlNoStore = false;
+    mCacheControlImmutable = false;
+    mCacheControlStaleWhileRevalidateSet = false;
+    mCacheControlStaleWhileRevalidate = 0;
+    mCacheControlMaxAgeSet = false;
+    mCacheControlMaxAge = 0;
+    return;
+  }
+
+  nsDependentCString cacheControlRequestHeader(val);
+  CacheControlParser cacheControlRequest(cacheControlRequestHeader);
+
+  mHasCacheControl = true;
+  mCacheControlPublic = cacheControlRequest.Public();
+  mCacheControlPrivate = cacheControlRequest.Private();
+  mCacheControlNoCache = cacheControlRequest.NoCache();
+  mCacheControlNoStore = cacheControlRequest.NoStore();
+  mCacheControlImmutable = cacheControlRequest.Immutable();
+  mCacheControlStaleWhileRevalidateSet =
+      cacheControlRequest.StaleWhileRevalidate(
+          &mCacheControlStaleWhileRevalidate);
+  mCacheControlMaxAgeSet = cacheControlRequest.MaxAge(&mCacheControlMaxAge);
+}
+
+void nsHttpResponseHead::ParsePragma(const char* val) {
+  LOG(("nsHttpResponseHead::ParsePragma [val=%s]\n", val));
+
+  if (!(val && *val)) {
+    // clear no-cache flag
+    mPragmaNoCache = false;
+    return;
+  }
+
+  // Although 'Pragma: no-cache' is not a standard HTTP response header (it's a
+  // request header), caching is inhibited when this header is present so as to
+  // match existing Navigator behavior.
+  mPragmaNoCache = nsHttp::FindToken(val, "no-cache", HTTP_HEADER_VALUE_SEPS);
+}
+
+nsresult nsHttpResponseHead::ParseResponseContentLength(
+    const nsACString& aHeaderStr) {
+  int64_t contentLength = 0;
+  // Ref: https://fetch.spec.whatwg.org/#content-length-header
+  // Step 1. Let values be the result of getting, decoding, and splitting
+  // `Content - Length` from headers.
+  //  Step 1 is done by the caller
+  //  Step 2. If values is null, then return null.
+  if (aHeaderStr.IsEmpty()) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  // Step 3 Let candidateValue be null.
+  Maybe<nsAutoCString> candidateValue;
+  // Step 4 For each value of values
+  for (const nsACString& token :
+       nsCCharSeparatedTokenizerTemplate<
+           NS_IsAsciiWhitespace, nsTokenizerFlags::IncludeEmptyTokenAtEnd>(
+           aHeaderStr, ',')
+           .ToRange()) {
+    // Step 4.1 If candidateValue is null, then set candidateValue to value.
+    if (candidateValue.isNothing()) {
+      candidateValue.emplace(token);
+    }
+    // Step 4.2 Otherwise, if value is not candidateValue, return failure.
+    if (candidateValue.value() != token) {
+      return NS_ERROR_ILLEGAL_VALUE;
+    }
+  }
+  // Step 5 If candidateValue is the empty string or has a code point that is
+  // not an ASCII digit, then return null.
+  if (candidateValue.isNothing()) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  // Step 6 Return candidateValue, interpreted as decimal number contentLength
+  const char* end = nullptr;
+  if (!net::nsHttp::ParseInt64(candidateValue->get(), &end, &contentLength)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  if (*end != '\0') {
+    // a number was parsed by ParseInt64 but candidateValue contains non-numeric
+    // characters
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  mContentLength = contentLength;
+  return NS_OK;
+}
+
+nsresult nsHttpResponseHead::VisitHeaders(
+    nsIHttpHeaderVisitor* visitor, nsHttpHeaderArray::VisitorFilter filter) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  mInVisitHeaders = true;
+  nsresult rv = mHeaders.VisitHeaders(visitor, filter);
+  mInVisitHeaders = false;
+  return rv;
+}
+
+namespace {
+class ContentTypeOptionsVisitor final : public nsIHttpHeaderVisitor {
+ public:
+  NS_DECL_ISUPPORTS
+
+  ContentTypeOptionsVisitor() = default;
+
+  NS_IMETHOD
+  VisitHeader(const nsACString& aHeader, const nsACString& aValue) override {
+    if (!mHeaderPresent) {
+      mHeaderPresent = true;
+    } else {
+      // multiple XCTO headers in response, merge them
+      mContentTypeOptionsHeader.Append(", "_ns);
+    }
+    mContentTypeOptionsHeader.Append(aValue);
+    return NS_OK;
+  }
+
+  void GetMergedHeader(nsACString& aValue) {
+    aValue = mContentTypeOptionsHeader;
+  }
+
+ private:
+  ~ContentTypeOptionsVisitor() = default;
+  bool mHeaderPresent{false};
+  nsAutoCString mContentTypeOptionsHeader;
+};
+
+NS_IMPL_ISUPPORTS(ContentTypeOptionsVisitor, nsIHttpHeaderVisitor)
+}  // namespace
+
+nsresult nsHttpResponseHead::GetOriginalHeader(const nsHttpAtom& aHeader,
+                                               nsIHttpHeaderVisitor* aVisitor) {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  mInVisitHeaders = true;
+  nsresult rv = mHeaders.GetOriginalHeader(aHeader, aVisitor);
+  mInVisitHeaders = false;
+  return rv;
+}
+
+bool nsHttpResponseHead::HasContentType() const {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return !mContentType.IsEmpty();
+}
+
+bool nsHttpResponseHead::HasContentCharset() {
+  RecursiveMutexAutoLock monitor(mRecursiveMutex);
+  return !mContentCharset.IsEmpty();
+}
+
+bool nsHttpResponseHead::GetContentTypeOptionsHeader(nsACString& aOutput) {
+  aOutput.Truncate();
+
+  nsAutoCString contentTypeOptionsHeader;
+  // We need to fetch original headers and manually merge them because empty
+  // header values are not retrieved with GetHeader. Ref - Bug 1819642
+  RefPtr<ContentTypeOptionsVisitor> visitor = new ContentTypeOptionsVisitor();
+  Unused << GetOriginalHeader(nsHttp::X_Content_Type_Options, visitor);
+  visitor->GetMergedHeader(contentTypeOptionsHeader);
+  if (contentTypeOptionsHeader.IsEmpty()) {
+    // if there is no XCTO header, then there is nothing to do.
+    return false;
+  }
+
+  // XCTO header might contain multiple values which are comma separated, so:
+  // a) let's skip all subsequent values
+  //     e.g. "   NoSniFF   , foo " will be "   NoSniFF   "
+  int32_t idx = contentTypeOptionsHeader.Find(",");
+  if (idx >= 0) {
+    contentTypeOptionsHeader = Substring(contentTypeOptionsHeader, 0, idx);
+  }
+  // b) let's trim all surrounding whitespace
+  //    e.g. "   NoSniFF   " -> "NoSniFF"
+  nsHttp::TrimHTTPWhitespace(contentTypeOptionsHeader,
+                             contentTypeOptionsHeader);
+
+  aOutput.Assign(contentTypeOptionsHeader);
+  return true;
+}
+
+}  // namespace net
+}  // namespace mozilla