dom/fetch/InternalResponse.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_InternalResponse_h
   8 #define mozilla_dom_InternalResponse_h
   9
  10 #include "mozilla/dom/FetchTypes.h"
  11 #include "nsIInputStream.h"
  12 #include "nsICacheInfoChannel.h"
  13 #include "nsISupportsImpl.h"
  14 #include "nsProxyRelease.h"
  15
  16 #include "mozilla/dom/InternalHeaders.h"
  17 #include "mozilla/dom/RequestBinding.h"
  18 #include "mozilla/dom/ResponseBinding.h"
  19 #include "mozilla/dom/ChannelInfo.h"
  20 #include "mozilla/dom/SafeRefPtr.h"
  21 #include "mozilla/NotNull.h"
  22 #include "mozilla/UniquePtr.h"
  23
  24 namespace mozilla {
  25 namespace ipc {
  26 class PBackgroundChild;
  27 class PBackgroundParent;
  28 class PrincipalInfo;
  29 }  // namespace ipc
  30
  31 namespace dom {
  32
  33 class ChildToParentInternalResponse;
  34 class InternalHeaders;
  35 class ParentToChildInternalResponse;
  36 class ParentToParentInternalResponse;
  37
  38 class InternalResponse final : public AtomicSafeRefCounted<InternalResponse> {
  39   friend class FetchDriver;
  40
  41  public:
  42   MOZ_DECLARE_REFCOUNTED_TYPENAME(InternalResponse)
  43
  44   InternalResponse(
  45       uint16_t aStatus, const nsACString& aStatusText,
  46       RequestCredentials aCredentialsMode = RequestCredentials::Omit);
  47
  48   static SafeRefPtr<InternalResponse> FromIPC(
  49       const ParentToChildInternalResponse& aIPCResponse);
  50
  51   static SafeRefPtr<InternalResponse> FromIPC(
  52       const ParentToParentInternalResponse& aIPCResponse);
  53
  54   void ToChildToParentInternalResponse(
  55       ChildToParentInternalResponse* aIPCResponse,
  56       mozilla::ipc::PBackgroundChild* aManager);
  57
  58   ParentToParentInternalResponse ToParentToParentInternalResponse();
  59
  60   enum CloneType {
  61     eCloneInputStream,
  62     eDontCloneInputStream,
  63   };
  64
  65   SafeRefPtr<InternalResponse> Clone(CloneType aCloneType);
  66
  67   static SafeRefPtr<InternalResponse> NetworkError(nsresult aRv) {
  68     MOZ_DIAGNOSTIC_ASSERT(NS_FAILED(aRv));
  69     SafeRefPtr<InternalResponse> response =
  70         MakeSafeRefPtr<InternalResponse>(0, ""_ns);
  71     ErrorResult result;
  72     response->Headers()->SetGuard(HeadersGuardEnum::Immutable, result);
  73     MOZ_ASSERT(!result.Failed());
  74     response->mType = ResponseType::Error;
  75     response->mErrorCode = aRv;
  76     return response;
  77   }
  78
  79   SafeRefPtr<InternalResponse> OpaqueResponse();
  80
  81   SafeRefPtr<InternalResponse> OpaqueRedirectResponse();
  82
  83   SafeRefPtr<InternalResponse> BasicResponse();
  84
  85   SafeRefPtr<InternalResponse> CORSResponse();
  86
  87   ResponseType Type() const {
  88     MOZ_ASSERT_IF(mType == ResponseType::Error, !mWrappedResponse);
  89     MOZ_ASSERT_IF(mType == ResponseType::Default, !mWrappedResponse);
  90     MOZ_ASSERT_IF(mType == ResponseType::Basic, mWrappedResponse);
  91     MOZ_ASSERT_IF(mType == ResponseType::Cors, mWrappedResponse);
  92     MOZ_ASSERT_IF(mType == ResponseType::Opaque, mWrappedResponse);
  93     MOZ_ASSERT_IF(mType == ResponseType::Opaqueredirect, mWrappedResponse);
  94     return mType;
  95   }
  96
  97   bool IsError() const { return Type() == ResponseType::Error; }
  98   // GetUrl should return last fetch URL in response's url list and null if
  99   // response's url list is the empty list.
 100   const nsCString& GetURL() const {
 101     // Empty urlList when response is a synthetic response.
 102     if (mURLList.IsEmpty()) {
 103       return EmptyCString();
 104     }
 105     return mURLList.LastElement();
 106   }
 107   void GetURLList(nsTArray<nsCString>& aURLList) const {
 108     aURLList.Assign(mURLList);
 109   }
 110   const nsCString& GetUnfilteredURL() const {
 111     if (mWrappedResponse) {
 112       return mWrappedResponse->GetURL();
 113     }
 114     return GetURL();
 115   }
 116   void GetUnfilteredURLList(nsTArray<nsCString>& aURLList) const {
 117     if (mWrappedResponse) {
 118       return mWrappedResponse->GetURLList(aURLList);
 119     }
 120
 121     return GetURLList(aURLList);
 122   }
 123
 124   nsTArray<nsCString> GetUnfilteredURLList() const {
 125     nsTArray<nsCString> list;
 126     GetUnfilteredURLList(list);
 127     return list;
 128   }
 129
 130   void SetURLList(const nsTArray<nsCString>& aURLList) {
 131     mURLList.Assign(aURLList);
 132
 133 #ifdef DEBUG
 134     for (uint32_t i = 0; i < mURLList.Length(); ++i) {
 135       MOZ_ASSERT(mURLList[i].Find("#"_ns) == kNotFound);
 136     }
 137 #endif
 138   }
 139
 140   uint16_t GetStatus() const { return mStatus; }
 141
 142   uint16_t GetUnfilteredStatus() const {
 143     if (mWrappedResponse) {
 144       return mWrappedResponse->GetStatus();
 145     }
 146
 147     return GetStatus();
 148   }
 149
 150   const nsCString& GetStatusText() const { return mStatusText; }
 151
 152   const nsCString& GetUnfilteredStatusText() const {
 153     if (mWrappedResponse) {
 154       return mWrappedResponse->GetStatusText();
 155     }
 156
 157     return GetStatusText();
 158   }
 159
 160   InternalHeaders* Headers() { return mHeaders; }
 161
 162   InternalHeaders* UnfilteredHeaders() {
 163     if (mWrappedResponse) {
 164       return mWrappedResponse->Headers();
 165     };
 166
 167     return Headers();
 168   }
 169
 170   void GetUnfilteredBody(nsIInputStream** aStream,
 171                          int64_t* aBodySize = nullptr) {
 172     if (mWrappedResponse) {
 173       MOZ_ASSERT(!mBody);
 174       return mWrappedResponse->GetBody(aStream, aBodySize);
 175     }
 176     nsCOMPtr<nsIInputStream> stream = mBody;
 177     stream.forget(aStream);
 178     if (aBodySize) {
 179       *aBodySize = mBodySize;
 180     }
 181   }
 182
 183   void GetBody(nsIInputStream** aStream, int64_t* aBodySize = nullptr) {
 184     if (Type() == ResponseType::Opaque ||
 185         Type() == ResponseType::Opaqueredirect) {
 186       *aStream = nullptr;
 187       if (aBodySize) {
 188         *aBodySize = UNKNOWN_BODY_SIZE;
 189       }
 190       return;
 191     }
 192
 193     GetUnfilteredBody(aStream, aBodySize);
 194   }
 195
 196   void SetBodyBlobURISpec(nsACString& aBlobURISpec) {
 197     mBodyBlobURISpec = aBlobURISpec;
 198   }
 199
 200   const nsACString& BodyBlobURISpec() const {
 201     if (mWrappedResponse) {
 202       return mWrappedResponse->BodyBlobURISpec();
 203     }
 204     return mBodyBlobURISpec;
 205   }
 206
 207   void SetBodyLocalPath(nsAString& aLocalPath) { mBodyLocalPath = aLocalPath; }
 208
 209   const nsAString& BodyLocalPath() const {
 210     if (mWrappedResponse) {
 211       return mWrappedResponse->BodyLocalPath();
 212     }
 213     return mBodyLocalPath;
 214   }
 215
 216   void SetBody(nsIInputStream* aBody, int64_t aBodySize) {
 217     if (mWrappedResponse) {
 218       return mWrappedResponse->SetBody(aBody, aBodySize);
 219     }
 220     // A request's body may not be reset once set.
 221     MOZ_ASSERT(!mBody);
 222     MOZ_ASSERT(mBodySize == UNKNOWN_BODY_SIZE);
 223     // Check arguments.
 224     MOZ_ASSERT(aBodySize == UNKNOWN_BODY_SIZE || aBodySize >= 0);
 225     // If body is not given, then size must be unknown.
 226     MOZ_ASSERT_IF(!aBody, aBodySize == UNKNOWN_BODY_SIZE);
 227
 228     mBody = aBody;
 229     mBodySize = aBodySize;
 230   }
 231
 232   uint32_t GetPaddingInfo();
 233
 234   nsresult GeneratePaddingInfo();
 235
 236   int64_t GetPaddingSize();
 237
 238   void SetPaddingSize(int64_t aPaddingSize);
 239
 240   void SetAlternativeDataType(const nsACString& aAltDataType) {
 241     if (mWrappedResponse) {
 242       return mWrappedResponse->SetAlternativeDataType(aAltDataType);
 243     }
 244
 245     MOZ_DIAGNOSTIC_ASSERT(mAlternativeDataType.IsEmpty());
 246
 247     mAlternativeDataType.Assign(aAltDataType);
 248   }
 249
 250   const nsCString& GetAlternativeDataType() {
 251     if (mWrappedResponse) {
 252       return mWrappedResponse->GetAlternativeDataType();
 253     }
 254
 255     return mAlternativeDataType;
 256   }
 257
 258   void SetAlternativeBody(nsIInputStream* aAlternativeBody) {
 259     if (mWrappedResponse) {
 260       return mWrappedResponse->SetAlternativeBody(aAlternativeBody);
 261     }
 262     // A request's body may not be reset once set.
 263     MOZ_DIAGNOSTIC_ASSERT(!mAlternativeBody);
 264
 265     mAlternativeBody = aAlternativeBody;
 266   }
 267
 268   already_AddRefed<nsIInputStream> TakeAlternativeBody() {
 269     if (mWrappedResponse) {
 270       return mWrappedResponse->TakeAlternativeBody();
 271     }
 272
 273     if (!mAlternativeBody) {
 274       return nullptr;
 275     }
 276
 277     // cleanup the non-alternative body here.
 278     // Once alternative data is used, the real body is no need anymore.
 279     mBody = nullptr;
 280     mBodySize = UNKNOWN_BODY_SIZE;
 281     return mAlternativeBody.forget();
 282   }
 283
 284   void SetCacheInfoChannel(
 285       const nsMainThreadPtrHandle<nsICacheInfoChannel>& aCacheInfoChannel) {
 286     if (mWrappedResponse) {
 287       return mWrappedResponse->SetCacheInfoChannel(aCacheInfoChannel);
 288     }
 289     MOZ_ASSERT(!mCacheInfoChannel);
 290     mCacheInfoChannel = aCacheInfoChannel;
 291   }
 292
 293   nsMainThreadPtrHandle<nsICacheInfoChannel> TakeCacheInfoChannel() {
 294     if (mWrappedResponse) {
 295       return mWrappedResponse->TakeCacheInfoChannel();
 296     }
 297     nsMainThreadPtrHandle<nsICacheInfoChannel> rtn = mCacheInfoChannel;
 298     mCacheInfoChannel = nullptr;
 299     return rtn;
 300   }
 301
 302   bool HasCacheInfoChannel() const {
 303     if (mWrappedResponse) {
 304       return !!mWrappedResponse->HasCacheInfoChannel();
 305     }
 306     return !!mCacheInfoChannel;
 307   }
 308
 309   bool HasBeenCloned() const { return mCloned; }
 310
 311   void InitChannelInfo(nsIChannel* aChannel) {
 312     mChannelInfo.InitFromChannel(aChannel);
 313   }
 314
 315   void InitChannelInfo(const mozilla::ipc::IPCChannelInfo& aChannelInfo) {
 316     mChannelInfo.InitFromIPCChannelInfo(aChannelInfo);
 317   }
 318
 319   void InitChannelInfo(const ChannelInfo& aChannelInfo) {
 320     mChannelInfo = aChannelInfo;
 321   }
 322
 323   const ChannelInfo& GetChannelInfo() const { return mChannelInfo; }
 324
 325   const UniquePtr<mozilla::ipc::PrincipalInfo>& GetPrincipalInfo() const {
 326     return mPrincipalInfo;
 327   }
 328
 329   bool IsRedirected() const { return mURLList.Length() > 1; }
 330
 331   nsresult GetErrorCode() const { return mErrorCode; }
 332
 333   // Takes ownership of the principal info.
 334   void SetPrincipalInfo(UniquePtr<mozilla::ipc::PrincipalInfo> aPrincipalInfo);
 335
 336   LoadTainting GetTainting() const;
 337
 338   SafeRefPtr<InternalResponse> Unfiltered();
 339
 340   ~InternalResponse();
 341
 342  private:
 343   explicit InternalResponse(const InternalResponse& aOther) = delete;
 344   InternalResponse& operator=(const InternalResponse&) = delete;
 345
 346   // Returns an instance of InternalResponse which is a copy of this
 347   // InternalResponse, except headers, body and wrapped response (if any) which
 348   // are left uninitialized. Used for cloning and filtering.
 349   SafeRefPtr<InternalResponse> CreateIncompleteCopy();
 350
 351   template <typename T>
 352   static SafeRefPtr<InternalResponse> FromIPCTemplate(const T& aIPCResponse);
 353
 354   InternalResponseMetadata GetMetadata();
 355
 356   ResponseType mType;
 357   // A response has an associated url list (a list of zero or more fetch URLs).
 358   // Unless stated otherwise, it is the empty list. The current url is the last
 359   // element in mURLlist
 360   nsTArray<nsCString> mURLList;
 361   const uint16_t mStatus;
 362   const nsCString mStatusText;
 363   RefPtr<InternalHeaders> mHeaders;
 364   nsCOMPtr<nsIInputStream> mBody;
 365   nsCString mBodyBlobURISpec;
 366   nsString mBodyLocalPath;
 367   int64_t mBodySize;
 368   // It's used to passed to the CacheResponse to generate padding size. Once, we
 369   // generate the padding size for resposne, we don't need it anymore.
 370   Maybe<uint32_t> mPaddingInfo;
 371   int64_t mPaddingSize;
 372   nsresult mErrorCode;
 373   RequestCredentials mCredentialsMode;
 374
 375   // For alternative data such as JS Bytecode cached in the HTTP cache.
 376   nsCString mAlternativeDataType;
 377   nsCOMPtr<nsIInputStream> mAlternativeBody;
 378   nsMainThreadPtrHandle<nsICacheInfoChannel> mCacheInfoChannel;
 379   bool mCloned;
 380
 381  public:
 382   static constexpr int64_t UNKNOWN_BODY_SIZE = -1;
 383   static constexpr int64_t UNKNOWN_PADDING_SIZE = -1;
 384
 385  private:
 386   ChannelInfo mChannelInfo;
 387   UniquePtr<mozilla::ipc::PrincipalInfo> mPrincipalInfo;
 388
 389   // For filtered responses.
 390   // Cache, and SW interception should always serialize/access the underlying
 391   // unfiltered headers and when deserializing, create an InternalResponse
 392   // with the unfiltered headers followed by wrapping it.
 393   SafeRefPtr<InternalResponse> mWrappedResponse;
 394 };
 395
 396 ParentToChildInternalResponse ToParentToChild(
 397     const ParentToParentInternalResponse& aResponse,
 398     NotNull<mozilla::ipc::PBackgroundParent*> aBackgroundParent);
 399
 400 }  // namespace dom
 401 }  // namespace mozilla
 402
 403 #endif  // mozilla_dom_InternalResponse_h