fune/netwerk/base/nsAsyncRedirectVerifyHelper.cpp

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */

#include "mozilla/Logging.h"
#include "nsAsyncRedirectVerifyHelper.h"
#include "nsThreadUtils.h"
#include "nsNetUtil.h"

#include "nsIOService.h"
#include "nsIChannel.h"
#include "nsIHttpChannelInternal.h"
#include "nsIAsyncVerifyRedirectCallback.h"
#include "nsILoadInfo.h"

namespace mozilla {
namespace net {

static LazyLogModule gRedirectLog("nsRedirect");
#undef LOG
#define LOG(args) MOZ_LOG(gRedirectLog, LogLevel::Debug, args)

NS_IMPL_ISUPPORTS(nsAsyncRedirectVerifyHelper, nsIAsyncVerifyRedirectCallback,
                  nsIRunnable, nsINamed)

class nsAsyncVerifyRedirectCallbackEvent : public Runnable {
 public:
  nsAsyncVerifyRedirectCallbackEvent(nsIAsyncVerifyRedirectCallback* cb,
                                     nsresult result)
      : Runnable("nsAsyncVerifyRedirectCallbackEvent"),
        mCallback(cb),
        mResult(result) {}

  NS_IMETHOD Run() override {
    LOG(
        ("nsAsyncVerifyRedirectCallbackEvent::Run() "
         "callback to %p with result %" PRIx32,
         mCallback.get(), static_cast<uint32_t>(mResult)));
    (void)mCallback->OnRedirectVerifyCallback(mResult);
    return NS_OK;
  }

 private:
  nsCOMPtr<nsIAsyncVerifyRedirectCallback> mCallback;
  nsresult mResult;
};

nsAsyncRedirectVerifyHelper::nsAsyncRedirectVerifyHelper()
    : mFlags(0),
      mWaitingForRedirectCallback(false),
      mCallbackInitiated(false),
      mExpectedCallbacks(0),
      mResult(NS_OK) {}

nsAsyncRedirectVerifyHelper::~nsAsyncRedirectVerifyHelper() {
  NS_ASSERTION(NS_FAILED(mResult) || mExpectedCallbacks == 0,
               "Did not receive all required callbacks!");
}

nsresult nsAsyncRedirectVerifyHelper::Init(
    nsIChannel* oldChan, nsIChannel* newChan, uint32_t flags,
    nsIEventTarget* mainThreadEventTarget, bool synchronize) {
  LOG(
      ("nsAsyncRedirectVerifyHelper::Init() "
       "oldChan=%p newChan=%p",
       oldChan, newChan));
  mOldChan = oldChan;
  mNewChan = newChan;
  mFlags = flags;
  mCallbackEventTarget = NS_IsMainThread() && mainThreadEventTarget
                             ? mainThreadEventTarget
                             : GetCurrentThreadEventTarget();

  if (!(flags & (nsIChannelEventSink::REDIRECT_INTERNAL |
                 nsIChannelEventSink::REDIRECT_STS_UPGRADE))) {
    nsCOMPtr<nsILoadInfo> loadInfo = oldChan->LoadInfo();
    if (loadInfo->GetDontFollowRedirects()) {
      ExplicitCallback(NS_BINDING_ABORTED);
      return NS_OK;
    }
  }

  if (synchronize) mWaitingForRedirectCallback = true;

  nsCOMPtr<nsIRunnable> runnable = this;
  nsresult rv;
  rv = mainThreadEventTarget
           ? mainThreadEventTarget->Dispatch(runnable.forget())
           : GetMainThreadEventTarget()->Dispatch(runnable.forget());
  NS_ENSURE_SUCCESS(rv, rv);

  if (synchronize) {
    if (!SpinEventLoopUntil([&]() { return !mWaitingForRedirectCallback; })) {
      return NS_ERROR_UNEXPECTED;
    }
  }

  return NS_OK;
}

NS_IMETHODIMP
nsAsyncRedirectVerifyHelper::OnRedirectVerifyCallback(nsresult result) {
  LOG(
      ("nsAsyncRedirectVerifyHelper::OnRedirectVerifyCallback() "
       "result=%" PRIx32 " expectedCBs=%u mResult=%" PRIx32,
       static_cast<uint32_t>(result), mExpectedCallbacks,
       static_cast<uint32_t>(mResult)));

  MOZ_DIAGNOSTIC_ASSERT(
      mExpectedCallbacks > 0,
      "OnRedirectVerifyCallback called more times than expected");
  if (mExpectedCallbacks <= 0) {
    return NS_ERROR_UNEXPECTED;
  }

  --mExpectedCallbacks;

  // If response indicates failure we may call back immediately
  if (NS_FAILED(result)) {
    // We chose to store the first failure-value (as opposed to the last)
    if (NS_SUCCEEDED(mResult)) mResult = result;

    // If InitCallback() has been called, just invoke the callback and
    // return. Otherwise it will be invoked from InitCallback()
    if (mCallbackInitiated) {
      ExplicitCallback(mResult);
      return NS_OK;
    }
  }

  // If the expected-counter is in balance and InitCallback() was called, all
  // sinks have agreed that the redirect is ok and we can invoke our callback
  if (mCallbackInitiated && mExpectedCallbacks == 0) {
    ExplicitCallback(mResult);
  }

  return NS_OK;
}

nsresult nsAsyncRedirectVerifyHelper::DelegateOnChannelRedirect(
    nsIChannelEventSink* sink, nsIChannel* oldChannel, nsIChannel* newChannel,
    uint32_t flags) {
  LOG(
      ("nsAsyncRedirectVerifyHelper::DelegateOnChannelRedirect() "
       "sink=%p expectedCBs=%u mResult=%" PRIx32,
       sink, mExpectedCallbacks, static_cast<uint32_t>(mResult)));

  ++mExpectedCallbacks;

  if (IsOldChannelCanceled()) {
    LOG(
        ("  old channel has been canceled, cancel the redirect by "
         "emulating OnRedirectVerifyCallback..."));
    (void)OnRedirectVerifyCallback(NS_BINDING_ABORTED);
    return NS_BINDING_ABORTED;
  }

  nsresult rv =
      sink->AsyncOnChannelRedirect(oldChannel, newChannel, flags, this);

  LOG(("  result=%" PRIx32 " expectedCBs=%u", static_cast<uint32_t>(rv),
       mExpectedCallbacks));

  // If the sink returns failure from this call the redirect is vetoed. We
  // emulate a callback from the sink in this case in order to perform all
  // the necessary logic.
  if (NS_FAILED(rv)) {
    LOG(("  emulating OnRedirectVerifyCallback..."));
    (void)OnRedirectVerifyCallback(rv);
  }

  return rv;  // Return the actual status since our caller may need it
}

void nsAsyncRedirectVerifyHelper::ExplicitCallback(nsresult result) {
  LOG(
      ("nsAsyncRedirectVerifyHelper::ExplicitCallback() "
       "result=%" PRIx32
       " expectedCBs=%u mCallbackInitiated=%u mResult=%" PRIx32,
       static_cast<uint32_t>(result), mExpectedCallbacks, mCallbackInitiated,
       static_cast<uint32_t>(mResult)));

  nsCOMPtr<nsIAsyncVerifyRedirectCallback> callback(
      do_QueryInterface(mOldChan));

  if (!callback || !mCallbackEventTarget) {
    LOG(
        ("nsAsyncRedirectVerifyHelper::ExplicitCallback() "
         "callback=%p mCallbackEventTarget=%p",
         callback.get(), mCallbackEventTarget.get()));
    return;
  }

  mCallbackInitiated = false;  // reset to ensure only one callback
  mWaitingForRedirectCallback = false;

  // Now, dispatch the callback on the event-target which called Init()
  nsCOMPtr<nsIRunnable> event =
      new nsAsyncVerifyRedirectCallbackEvent(callback, result);
  if (!event) {
    NS_WARNING(
        "nsAsyncRedirectVerifyHelper::ExplicitCallback() "
        "failed creating callback event!");
    return;
  }
  nsresult rv = mCallbackEventTarget->Dispatch(event, NS_DISPATCH_NORMAL);
  if (NS_FAILED(rv)) {
    NS_WARNING(
        "nsAsyncRedirectVerifyHelper::ExplicitCallback() "
        "failed dispatching callback event!");
  } else {
    LOG(
        ("nsAsyncRedirectVerifyHelper::ExplicitCallback() "
         "dispatched callback event=%p",
         event.get()));
  }
}

void nsAsyncRedirectVerifyHelper::InitCallback() {
  LOG(
      ("nsAsyncRedirectVerifyHelper::InitCallback() "
       "expectedCBs=%d mResult=%" PRIx32,
       mExpectedCallbacks, static_cast<uint32_t>(mResult)));

  mCallbackInitiated = true;

  // Invoke the callback if we are done
  if (mExpectedCallbacks == 0) ExplicitCallback(mResult);
}

NS_IMETHODIMP
nsAsyncRedirectVerifyHelper::GetName(nsACString& aName) {
  aName.AssignLiteral("nsAsyncRedirectVerifyHelper");
  return NS_OK;
}

NS_IMETHODIMP
nsAsyncRedirectVerifyHelper::Run() {
  /* If the channel got canceled after it fired AsyncOnChannelRedirect
   * and before we got here, mostly because docloader load has been canceled,
   * we must completely ignore this notification and prevent any further
   * notification.
   */
  if (IsOldChannelCanceled()) {
    ExplicitCallback(NS_BINDING_ABORTED);
    return NS_OK;
  }

  // First, the global observer
  NS_ASSERTION(gIOService, "Must have an IO service at this point");
  LOG(("nsAsyncRedirectVerifyHelper::Run() calling gIOService..."));
  nsresult rv =
      gIOService->AsyncOnChannelRedirect(mOldChan, mNewChan, mFlags, this);
  if (NS_FAILED(rv)) {
    ExplicitCallback(rv);
    return NS_OK;
  }

  // Now, the per-channel observers
  nsCOMPtr<nsIChannelEventSink> sink;
  NS_QueryNotificationCallbacks(mOldChan, sink);
  if (sink) {
    LOG(("nsAsyncRedirectVerifyHelper::Run() calling sink..."));
    rv = DelegateOnChannelRedirect(sink, mOldChan, mNewChan, mFlags);
  }

  // All invocations to AsyncOnChannelRedirect has been done - call
  // InitCallback() to flag this
  InitCallback();
  return NS_OK;
}

bool nsAsyncRedirectVerifyHelper::IsOldChannelCanceled() {
  if (!mOldChan) {
    return false;
  }
  bool canceled;
  nsresult rv = mOldChan->GetCanceled(&canceled);
  return NS_SUCCEEDED(rv) && canceled;
}

}  // namespace net
}  // namespace mozilla