--- a/netwerk/base/nsIRequest.idl
+++ b/netwerk/base/nsIRequest.idl
@@ -175,17 +175,17 @@ interface nsIRequest : nsISupports
     const unsigned long LOAD_FROM_CACHE   = 1 << 10;
 
     /**
      * The following flags control the frequency of cached content validation
      * when neither LOAD_BYPASS_CACHE or LOAD_FROM_CACHE are set.  By default,
      * cached content is automatically validated if necessary before reuse.
      * 
      * VALIDATE_ALWAYS forces validation of any cached content independent of
-     * its expiration time.
+     * its expiration time (unless it is https with Cache-Control: immutable)
      * 
      * VALIDATE_NEVER disables validation of cached content, unless it arrived
      * with the "Cache: no-store" header, or arrived via HTTPS with the
      * "Cache: no-cache" header.
      *
      * VALIDATE_ONCE_PER_SESSION disables validation of expired content, 
      * provided it has already been validated (at least once) since the start 
      * of this session.

--- a/netwerk/protocol/http/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/nsHttpChannel.cpp
@@ -3402,16 +3402,23 @@ nsHttpChannel::OnCacheEntryCheck(nsICach
     NS_ENSURE_SUCCESS(rv,rv);
 
     bool doValidation = false;
     bool canAddImsHeader = true;
 
     bool isForcedValid = false;
     entry->GetIsForcedValid(&isForcedValid);
 
+    nsXPIDLCString framedBuf;
+    rv = entry->GetMetaDataElement("strongly-framed", getter_Copies(framedBuf));
+    // describe this in terms of explicitly weakly framed so as to be backwards
+    // compatible with old cache contents which dont have strongly-framed makers
+    bool weaklyFramed = NS_SUCCEEDED(rv) && framedBuf.EqualsLiteral("0");
+    bool isImmutable = !weaklyFramed && isHttps && mCachedResponseHead->Immutable();
+
     // Cached entry is not the entity we request (see bug #633743)
     if (ResponseWouldVary(entry)) {
         LOG(("Validating based on Vary headers returning TRUE\n"));
         canAddImsHeader = false;
         doValidation = true;
     }
     // Check isForcedValid to see if it is possible to skip validation.
     // Don't skip validation if we have serious reason to believe that this
@@ -3427,17 +3434,17 @@ nsHttpChannel::OnCacheEntryCheck(nsICach
     }
     // If the LOAD_FROM_CACHE flag is set, any cached data can simply be used
     else if (mLoadFlags & nsIRequest::LOAD_FROM_CACHE || mAllowStaleCacheContent) {
         LOG(("NOT validating based on LOAD_FROM_CACHE load flag\n"));
         doValidation = false;
     }
     // If the VALIDATE_ALWAYS flag is set, any cached data won't be used until
     // it's revalidated with the server.
-    else if (mLoadFlags & nsIRequest::VALIDATE_ALWAYS) {
+    else if ((mLoadFlags & nsIRequest::VALIDATE_ALWAYS) && !isImmutable) {
         LOG(("Validating based on VALIDATE_ALWAYS load flag\n"));
         doValidation = true;
     }
     // Even if the VALIDATE_NEVER flag is set, there are still some cases in
     // which we must validate the cached response with the server.
     else if (mLoadFlags & nsIRequest::VALIDATE_NEVER) {
         LOG(("VALIDATE_NEVER set\n"));
         // if no-store validate cached response (see bug 112564)
@@ -3554,39 +3561,33 @@ nsHttpChannel::OnCacheEntryCheck(nsICach
 
     if (doValidation && mInterceptCache == INTERCEPTED) {
         doValidation = false;
     }
 
     mCachedContentIsValid = !doValidation;
 
     if (doValidation) {
-        nsXPIDLCString buf;
-        rv = entry->GetMetaDataElement("strongly-framed", getter_Copies(buf));
-        // describe this in terms of explicitly weakly framed so as to be backwards
-        // compatible with old cache contents which dont have strongly-framed makers
-        bool weaklyFramed = NS_SUCCEEDED(rv) && buf.EqualsLiteral("0");
-
         //
         // now, we are definitely going to issue a HTTP request to the server.
         // make it conditional if possible.
         //
         // do not attempt to validate no-store content, since servers will not
         // expect it to be cached.  (we only keep it in our cache for the
         // purposes of back/forward, etc.)
         //
         // the request method MUST be either GET or HEAD (see bug 175641) and
         // the cached response code must be < 400
         //
-        // the cached content must not be weakly framed
+        // the cached content must not be weakly framed or marked immutable
         //
         // do not override conditional headers when consumer has defined its own
         if (!mCachedResponseHead->NoStore() &&
             (mRequestHead.IsGet() || mRequestHead.IsHead()) &&
-            !mCustomConditionalRequest && !weaklyFramed &&
+            !mCustomConditionalRequest && !weaklyFramed && !isImmutable &&
             (mCachedResponseHead->Status() < 400)) {
 
             if (mConcurentCacheAccess) {
                 // In case of concurrent read and also validation request we
                 // must wait for the current writer to close the output stream
                 // first.  Otherwise, when the writer's job would have been interrupted
                 // before all the data were downloaded, we'd have to do a range request
                 // which would be a second request in line during this channel's

--- a/netwerk/protocol/http/nsHttpResponseHead.cpp
+++ b/netwerk/protocol/http/nsHttpResponseHead.cpp
@@ -638,16 +638,17 @@ nsHttpResponseHead::Reset()
     ClearHeaders();
 
     mVersion = NS_HTTP_VERSION_1_1;
     mStatus = 200;
     mContentLength = -1;
     mCacheControlPrivate = false;
     mCacheControlNoStore = false;
     mCacheControlNoCache = false;
+    mCacheControlImmutable = false;
     mPragmaNoCache = false;
     mStatusText.Truncate();
     mContentType.Truncate();
     mContentCharset.Truncate();
 }
 
 nsresult
 nsHttpResponseHead::ParseDateHeader(nsHttpAtom header, uint32_t *result) const
@@ -807,31 +808,37 @@ nsHttpResponseHead::ParseVersion(const c
 void
 nsHttpResponseHead::ParseCacheControl(const char *val)
 {
     if (!(val && *val)) {
         // clear flags
         mCacheControlPrivate = false;
         mCacheControlNoCache = false;
         mCacheControlNoStore = false;
+        mCacheControlImmutable = false;
         return;
     }
 
     // search header value for occurrence of "private"
     if (nsHttp::FindToken(val, "private", HTTP_HEADER_VALUE_SEPS))
         mCacheControlPrivate = true;
 
     // search header value for occurrence(s) of "no-cache" but ignore
     // occurrence(s) of "no-cache=blah"
     if (nsHttp::FindToken(val, "no-cache", HTTP_HEADER_VALUE_SEPS))
         mCacheControlNoCache = true;
 
     // search header value for occurrence of "no-store"
     if (nsHttp::FindToken(val, "no-store", HTTP_HEADER_VALUE_SEPS))
         mCacheControlNoStore = true;
+
+    // search header value for occurrence of "immutable"
+    if (nsHttp::FindToken(val, "immutable", HTTP_HEADER_VALUE_SEPS)) {
+        mCacheControlImmutable = true;
+    }
 }
 
 void
 nsHttpResponseHead::ParsePragma(const char *val)
 {
     LOG(("nsHttpResponseHead::ParsePragma [val=%s]\n", val));
 
     if (!(val && *val)) {

--- a/netwerk/protocol/http/nsHttpResponseHead.h
+++ b/netwerk/protocol/http/nsHttpResponseHead.h
@@ -27,31 +27,33 @@ class nsHttpResponseHead
 {
 public:
     nsHttpResponseHead() : mVersion(NS_HTTP_VERSION_1_1)
                          , mStatus(200)
                          , mContentLength(-1)
                          , mCacheControlPrivate(false)
                          , mCacheControlNoStore(false)
                          , mCacheControlNoCache(false)
+                         , mCacheControlImmutable(false)
                          , mPragmaNoCache(false) {}
 
     const nsHttpHeaderArray & Headers()   const { return mHeaders; }
     nsHttpHeaderArray    &Headers()             { return mHeaders; }
     nsHttpVersion         Version()       const { return mVersion; }
 // X11's Xlib.h #defines 'Status' to 'int' on some systems!
 #undef Status
     uint16_t              Status()        const { return mStatus; }
     const nsAFlatCString &StatusText()    const { return mStatusText; }
     int64_t               ContentLength() const { return mContentLength; }
     const nsAFlatCString &ContentType()   const { return mContentType; }
     const nsAFlatCString &ContentCharset() const { return mContentCharset; }
     bool                  Private() const { return mCacheControlPrivate; }
     bool                  NoStore() const { return mCacheControlNoStore; }
     bool                  NoCache() const { return (mCacheControlNoCache || mPragmaNoCache); }
+    bool                  Immutable() const { return mCacheControlImmutable; }
     /**
      * Full length of the entity. For byte-range requests, this may be larger
      * than ContentLength(), which will only represent the requested part of the
      * entity.
      */
     int64_t               TotalEntitySize() const;
 
     const char *PeekHeader(nsHttpAtom h) const      { return mHeaders.PeekHeader(h); }
@@ -128,16 +130,17 @@ public:
                mStatus == aOther.mStatus &&
                mStatusText == aOther.mStatusText &&
                mContentLength == aOther.mContentLength &&
                mContentType == aOther.mContentType &&
                mContentCharset == aOther.mContentCharset &&
                mCacheControlPrivate == aOther.mCacheControlPrivate &&
                mCacheControlNoCache == aOther.mCacheControlNoCache &&
                mCacheControlNoStore == aOther.mCacheControlNoStore &&
+               mCacheControlImmutable == aOther.mCacheControlImmutable &&
                mPragmaNoCache == aOther.mPragmaNoCache;
     }
 
 private:
     void     AssignDefaultStatusText();
     void     ParseVersion(const char *);
     void     ParseCacheControl(const char *);
     void     ParsePragma(const char *);
@@ -149,16 +152,17 @@ private:
     uint16_t          mStatus;
     nsCString         mStatusText;
     int64_t           mContentLength;
     nsCString         mContentType;
     nsCString         mContentCharset;
     bool              mCacheControlPrivate;
     bool              mCacheControlNoStore;
     bool              mCacheControlNoCache;
+    bool              mCacheControlImmutable;
     bool              mPragmaNoCache;
 
     friend struct IPC::ParamTraits<nsHttpResponseHead>;
 };
 
 } // namespace net
 } // namespace mozilla