gecko-dev/netwerk/base/nsStreamLoader.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

139 строки
4.1 KiB
C++
Исходник Обычный вид История

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2012-05-21 15:12:37 +04:00
/* 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;
RefPtr<nsStreamLoader> it = new nsStreamLoader();
return it->QueryInterface(aIID, aResult);
}
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) {
nsCOMPtr<nsIRequest> req = mRequest;
req.forget(aRequest);
return NS_OK;
}
NS_IMETHODIMP
nsStreamLoader::OnStartRequest(nsIRequest* request) {
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;
}
}
}
if (mRequestObserver) {
mRequestObserver->OnStartRequest(request);
}
return NS_OK;
}
NS_IMETHODIMP
nsStreamLoader::OnStopRequest(nsIRequest* request, nsresult aStatus) {
Bug 1375392 - Tweak the PROFILER_LABEL* macros. r=mstange. This patch makes the following changes to the macros. - Removes PROFILER_LABEL_FUNC. It's only suitable for use in functions outside classes, due to PROFILER_FUNCTION_NAME not getting class names, and it was mostly misused. - Removes PROFILER_FUNCTION_NAME. It's no longer used, and __func__ is universally available now anyway. - Combines the first two string literal arguments of PROFILER_LABEL and PROFILER_LABEL_DYNAMIC into a single argument. There was no good reason for them to be separate, and it forced a '::' in the label, which isn't always appropriate. Also, the meaning of the "name_space" argument was interpreted in an interesting variety of ways. - Adds an "AUTO_" prefix to PROFILER_LABEL and PROFILER_LABEL_DYNAMIC, to make it clearer they construct RAII objects rather than just being function calls. (I myself have screwed up the scoping because of this in the past.) - Fills in the 'js::ProfileEntry::Category::' qualifier within the macro, so the caller doesn't need to. This makes a *lot* more of the uses fit onto a single line. The patch also makes the following changes to the macro uses (beyond those required by the changes described above). - Fixes a bunch of labels that had gotten out of sync with the name of the class and/or function that encloses them. - Removes a useless PROFILER_LABEL use within a trivial scope in EventStateManager::DispatchMouseOrPointerEvent(). It clearly wasn't serving any useful purpose. It also serves as extra evidence that the AUTO_ prefix is a good idea. - Tweaks DecodePool::SyncRunIf{Preferred,Possible} so that the labelling is done within them, instead of at their callsites, because that's a more standard way of doing things. --HG-- extra : rebase_source : 318d1bc6fc1425a94aacbf489dd46e4f83211de4
2017-06-22 10:08:53 +03:00
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;
}
if (mRequestObserver) {
mRequestObserver->OnStopRequest(request, 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, 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