Attachment #8932304 for bug #1222008

Attachment #8932304: Bug 1222008 - P6a: Implement the quirk response for bug #1222008

View | Details | Raw Unified | Return to bug 1222008
Collapse All | Expand All





  } else {
    aIPCResponse->body() = void_t();
  }

  aIPCResponse->bodySize() = bodySize;
}

already_AddRefed<InternalResponse>
InternalResponse::Clone(CloneType aCloneType, const bool aQuirkResponse)
{
  RefPtr<InternalResponse> clone;
  if (aQuirkResponse) {
      auto createQuirkResponse = [&]() -> already_AddRefed<InternalResponse> {
      RefPtr<InternalResponse> copy =
        new InternalResponse(mStatus, mStatusText);
      // XXXtt: not sure about this.
      copy->mType = mType;

      return copy.forget();
    };

    clone = createQuirkResponse();
  } else {
    clone =  CreateIncompleteCopy();
  }

  clone->mHeaders = new InternalHeaders(*mHeaders);

  // Make sure the clone response will have the same padding size.
  clone->mPaddingInfo = mPaddingInfo;
  clone->mPaddingSize = mPaddingSize;

  if (mWrappedResponse) {
    clone->mWrappedResponse = mWrappedResponse->Clone(aCloneType,
                                                      aQuirkResponse);
    MOZ_ASSERT(!mBody);
    return clone.forget();
  }

  if (!mBody || aCloneType == eDontCloneInputStream) {
    return clone.forget();
  }






        UniquePtr<mozilla::ipc::AutoIPCStream>& aAutoStream);

  enum CloneType
  {
    eCloneInputStream,
    eDontCloneInputStream,
  };

  already_AddRefed<InternalResponse> Clone(CloneType eCloneType,
                                           const bool aQuirkResponse = false);

  static already_AddRefed<InternalResponse>
  NetworkError(nsresult aRv)
  {
    MOZ_DIAGNOSTIC_ASSERT(NS_FAILED(aRv));
    RefPtr<InternalResponse> response = new InternalResponse(0, EmptyCString());
    ErrorResult result;
    response->Headers()->SetGuard(HeadersGuardEnum::Immutable, result);





    }
  }

  r->SetMimeType();
  return r.forget();
}

already_AddRefed<Response>
Response::QuirkResponse(JSContext* aCx, nsresult& aRv)
{
  MOZ_DIAGNOSTIC_ASSERT(aCx);
  MOZ_DIAGNOSTIC_ASSERT(!BodyUsed());

  ErrorResult result;
  RefPtr<FetchStreamReader> streamReader;
  nsCOMPtr<nsIInputStream> inputStream;

  JS::Rooted<JSObject*> body(aCx);
  MaybeTeeReadableStreamBody(aCx, &body, getter_AddRefs(streamReader),
                             getter_AddRefs(inputStream), result);
  if (NS_WARN_IF(result.Failed())) {
    return nullptr;
  }

  MOZ_ASSERT_IF(body, streamReader);
  MOZ_ASSERT_IF(body, inputStream);

  RefPtr<InternalResponse> ir =
    mInternalResponse->Clone(body ? InternalResponse::eDontCloneInputStream
                                  : InternalResponse::eCloneInputStream,
                             true /* quirkResponse */);

  RefPtr<Response> response = new Response(mOwner, ir, mSignal);

  if (body) {
    // Maybe we have a body, but we receive null from MaybeTeeReadableStreamBody
    // if this body is a native stream.   In this case the InternalResponse will
    // have a clone of the native body and the ReadableStream will be created
    // lazily if needed.
    response->SetReadableStreamBody(aCx, body);
    response->mFetchStreamReader = streamReader;
    ir->SetBody(inputStream, InternalResponse::UNKNOWN_BODY_SIZE);
  }

  return response.forget();
}

already_AddRefed<Response>
Response::Clone(JSContext* aCx, ErrorResult& aRv)
{
  if (BodyUsed()) {
    aRv.ThrowTypeError<MSG_FETCH_BODY_CONSUMED_ERROR>();
    return nullptr;
  }

  RefPtr<FetchStreamReader> streamReader;





  }

  already_AddRefed<Response>
  Clone(JSContext* aCx, ErrorResult& aRv);

  already_AddRefed<Response>
  CloneUnfiltered(JSContext* aCx, ErrorResult& aRv);

  already_AddRefed<Response>
  QuirkResponse(JSContext* aCx, nsresult& rv);

  void
  SetBody(nsIInputStream* aBody, int64_t aBodySize);

  already_AddRefed<InternalResponse>
  GetInternalResponse() const;

  AbortSignal*
  GetSignal() const override





  }

  Telemetry::ScalarAdd(Telemetry::ScalarID::SW_SYNTHESIZED_RES_COUNT, 1);

  if (mRequestMode == RequestMode::Same_origin &&
      response->Type() == ResponseType::Cors) {
    Telemetry::ScalarAdd(Telemetry::ScalarID::SW_CORS_RES_FOR_SO_REQ_COUNT, 1);

    response = response->QuirkResponse(aCx, rv);
    if (NS_WARN_IF(NS_FAILED(rv) || !response)) {
      return;
    }

    ir = response->GetInternalResponse();
  }

  // Propagate the URL to the content if the request mode is not "navigate".
  // Note that, we only reflect the final URL if the response.redirected is
  // false. We propagate all the URLs if the response.redirected is true.
  nsCString responseURL;
  if (mRequestMode != RequestMode::Navigate) {
    responseURL = ir->GetUnfilteredURL();

Return to bug 1222008