/* -*- Mode: C++; tab-width: 2; 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 "nsStreamLoader.h"

#include "nsIInputStream.h"

#include "nsIChannel.h"

#include "nsError.h"

#include "GeckoProfiler.h"

#include <limits>

namespace mozilla {

namespace net {

nsStreamLoader::nsStreamLoader()

  : mData()

{

}

NS_IMETHODIMP

nsStreamLoader::Init(nsIStreamLoaderObserver* aStreamObserver,

                     nsIRequestObserver* aRequestObserver)

{

  NS_ENSURE_ARG_POINTER(aStreamObserver);

  mObserver = aStreamObserver;

  mRequestObserver = aRequestObserver;

  return NS_OK;

}

nsresult

nsStreamLoader::Create(nsISupports *aOuter, REFNSIID aIID, void **aResult)

{

  if (aOuter) return NS_ERROR_NO_AGGREGATION;

  nsStreamLoader* it = new nsStreamLoader();

  if (it == nullptr)

    return NS_ERROR_OUT_OF_MEMORY;

  NS_ADDREF(it);

  nsresult rv = it->QueryInterface(aIID, aResult);

  NS_RELEASE(it);

  return rv;

}

NS_IMPL_ISUPPORTS(nsStreamLoader, nsIStreamLoader,

                  nsIRequestObserver, nsIStreamListener,

                  nsIThreadRetargetableStreamListener)

NS_IMETHODIMP

nsStreamLoader::GetNumBytesRead(uint32_t* aNumBytes)

{

  *aNumBytes = mData.length();

  return NS_OK;

}

NS_IMETHODIMP

nsStreamLoader::GetRequest(nsIRequest **aRequest)

{

  NS_IF_ADDREF(*aRequest = mRequest);

  return NS_OK;

}

NS_IMETHODIMP

nsStreamLoader::OnStartRequest(nsIRequest* request, nsISupports *ctxt)

{

  nsCOMPtr<nsIChannel> chan( do_QueryInterface(request) );

  if (chan) {

    int64_t contentLength = -1;

    chan->GetContentLength(&contentLength);

    if (contentLength >= 0) {

      // On 64bit platforms size of uint64_t coincides with the size of size_t,

      // so we want to compare with the minimum from size_t and int64_t.

      if (static_cast<uint64_t>(contentLength) >

          std::min(std::numeric_limits<size_t>::max(),

                   static_cast<size_t>(std::numeric_limits<int64_t>::max()))) {

        // Too big to fit into size_t, so let's bail.

        return NS_ERROR_OUT_OF_MEMORY;

      }

      // preallocate buffer

      if (!mData.initCapacity(contentLength)) {

        return NS_ERROR_OUT_OF_MEMORY;

      }

    }

  }

  mContext = ctxt;

  if (mRequestObserver) {

    mRequestObserver->OnStartRequest(request, ctxt);

  }

  return NS_OK;

}

NS_IMETHODIMP

nsStreamLoader::OnStopRequest(nsIRequest* request, nsISupports *ctxt,

                              nsresult aStatus)

{

  AUTO_PROFILER_LABEL("nsStreamLoader::OnStopRequest", NETWORK);

  if (mObserver) {

    // provide nsIStreamLoader::request during call to OnStreamComplete

    mRequest = request;

    size_t length = mData.length();

    uint8_t* elems = mData.extractOrCopyRawBuffer();

    nsresult rv = mObserver->OnStreamComplete(this, mContext, aStatus,

                                              length, elems);

    if (rv != NS_SUCCESS_ADOPTED_DATA) {

      // The observer didn't take ownership of the extracted data buffer, so

      // put it back into mData.

      mData.replaceRawBuffer(elems, length);

    }

    // done.. cleanup

    ReleaseData();

    mRequest = nullptr;

    mObserver = nullptr;

    mContext = nullptr;

  }

  if (mRequestObserver) {

    mRequestObserver->OnStopRequest(request, ctxt, aStatus);

    mRequestObserver = nullptr;

  }

  return NS_OK;

}

nsresult

nsStreamLoader::WriteSegmentFun(nsIInputStream *inStr,

                                void *closure,

                                const char *fromSegment,

                                uint32_t toOffset,

                                uint32_t count,

                                uint32_t *writeCount)

{

  nsStreamLoader *self = (nsStreamLoader *) closure;

  if (!self->mData.append(fromSegment, count)) {

    self->mData.clearAndFree();

    return NS_ERROR_OUT_OF_MEMORY;

  }

  *writeCount = count;

  return NS_OK;

}

NS_IMETHODIMP

nsStreamLoader::OnDataAvailable(nsIRequest* request, nsISupports *ctxt,

                                nsIInputStream *inStr,

                                uint64_t sourceOffset, uint32_t count)

{

  uint32_t countRead;

  return inStr->ReadSegments(WriteSegmentFun, this, count, &countRead);

}

void

nsStreamLoader::ReleaseData()

{

  mData.clearAndFree();

}

NS_IMETHODIMP

nsStreamLoader::CheckListenerChain()

{

  return NS_OK;

}

} // namespace net

} // namespace mozilla