explicit InputStreamShim(SpdyConnectTransaction *aTrans)
: mCallback(nullptr)
, mStatus(NS_OK)
{
mWeakTrans = do_GetWeakReference(aTrans);
}
nsresult
nsTypeAheadFind::FindItNow(nsIPresShell *aPresShell, bool aIsLinksOnly,
bool aIsFirstVisiblePreferred, bool aFindPrev,
uint16_t* aResult)
{
*aResult = FIND_NOTFOUND;
mFoundLink = nullptr;
mFoundEditable = nullptr;
mFoundRange = nullptr;
mCurrentWindow = nullptr;
nsCOMPtr<nsIPresShell> startingPresShell (GetPresShell());
if (!startingPresShell) {
nsCOMPtr<nsIDocShell> ds = do_QueryReferent(mDocShell);
NS_ENSURE_TRUE(ds, NS_ERROR_FAILURE);
startingPresShell = ds->GetPresShell();
mPresShell = do_GetWeakReference(startingPresShell);
}
nsCOMPtr<nsIPresShell> presShell(aPresShell);
if (!presShell) {
presShell = startingPresShell; // this is the current document
if (!presShell)
return NS_ERROR_FAILURE;
}
RefPtr<nsPresContext> presContext = presShell->GetPresContext();
if (!presContext)
return NS_ERROR_FAILURE;
nsCOMPtr<nsISelection> selection;
nsCOMPtr<nsISelectionController> selectionController =
do_QueryReferent(mSelectionController);
if (!selectionController) {
GetSelection(presShell, getter_AddRefs(selectionController),
getter_AddRefs(selection)); // cache for reuse
mSelectionController = do_GetWeakReference(selectionController);
} else {
selectionController->GetSelection(
nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));
}
nsCOMPtr<nsIDocShell> startingDocShell(presContext->GetDocShell());
NS_ASSERTION(startingDocShell, "Bug 175321 Crashes with Type Ahead Find [@ nsTypeAheadFind::FindItNow]");
if (!startingDocShell)
return NS_ERROR_FAILURE;
nsCOMPtr<nsIDocShellTreeItem> rootContentTreeItem;
nsCOMPtr<nsIDocShell> currentDocShell;
startingDocShell->GetSameTypeRootTreeItem(getter_AddRefs(rootContentTreeItem));
nsCOMPtr<nsIDocShell> rootContentDocShell =
do_QueryInterface(rootContentTreeItem);
if (!rootContentDocShell)
return NS_ERROR_FAILURE;
nsCOMPtr<nsISimpleEnumerator> docShellEnumerator;
rootContentDocShell->GetDocShellEnumerator(nsIDocShellTreeItem::typeContent,
nsIDocShell::ENUMERATE_FORWARDS,
getter_AddRefs(docShellEnumerator));
// Default: can start at the current document
nsCOMPtr<nsISupports> currentContainer =
do_QueryInterface(rootContentDocShell);
// Iterate up to current shell, if there's more than 1 that we're
// dealing with
bool hasMoreDocShells;
while (NS_SUCCEEDED(docShellEnumerator->HasMoreElements(&hasMoreDocShells)) && hasMoreDocShells) {
docShellEnumerator->GetNext(getter_AddRefs(currentContainer));
currentDocShell = do_QueryInterface(currentContainer);
if (!currentDocShell || currentDocShell == startingDocShell || aIsFirstVisiblePreferred)
break;
}
// ------------ Get ranges ready ----------------
nsCOMPtr<nsIDOMRange> returnRange;
nsCOMPtr<nsIPresShell> focusedPS;
if (NS_FAILED(GetSearchContainers(currentContainer,
(!aIsFirstVisiblePreferred ||
mStartFindRange) ?
selectionController.get() : nullptr,
aIsFirstVisiblePreferred, aFindPrev,
getter_AddRefs(presShell),
getter_AddRefs(presContext)))) {
return NS_ERROR_FAILURE;
}
int16_t rangeCompareResult = 0;
if (!mStartPointRange) {
mStartPointRange = new nsRange(presShell->GetDocument());
}
mStartPointRange->CompareBoundaryPoints(nsIDOMRange::START_TO_START, mSearchRange, &rangeCompareResult);
// No need to wrap find in doc if starting at beginning
bool hasWrapped = (rangeCompareResult < 0);
if (mTypeAheadBuffer.IsEmpty() || !EnsureFind())
return NS_ERROR_FAILURE;
mFind->SetFindBackwards(aFindPrev);
while (true) { // ----- Outer while loop: go through all docs -----
while (true) { // === Inner while loop: go through a single doc ===
mFind->Find(mTypeAheadBuffer.get(), mSearchRange, mStartPointRange,
mEndPointRange, getter_AddRefs(returnRange));
if (!returnRange)
break; // Nothing found in this doc, go to outer loop (try next doc)
// ------- Test resulting found range for success conditions ------
bool isInsideLink = false, isStartingLink = false;
if (aIsLinksOnly) {
// Don't check if inside link when searching all text
RangeStartsInsideLink(returnRange, presShell, &isInsideLink,
&isStartingLink);
}
bool usesIndependentSelection;
if (!IsRangeVisible(presShell, presContext, returnRange,
aIsFirstVisiblePreferred, false,
getter_AddRefs(mStartPointRange),
&usesIndependentSelection) ||
(aIsLinksOnly && !isInsideLink) ||
(mStartLinksOnlyPref && aIsLinksOnly && !isStartingLink)) {
// ------ Failure ------
// At this point mStartPointRange got updated to the first
// visible range in the viewport. We _may_ be able to just
// start there, if it's not taking us in the wrong direction.
if (aFindPrev) {
// We can continue at the end of mStartPointRange if its end is before
// the start of returnRange or coincides with it. Otherwise, we need
// to continue at the start of returnRange.
int16_t compareResult;
nsresult rv =
mStartPointRange->CompareBoundaryPoints(nsIDOMRange::START_TO_END,
returnRange, &compareResult);
if (NS_SUCCEEDED(rv) && compareResult <= 0) {
// OK to start at the end of mStartPointRange
mStartPointRange->Collapse(false);
} else {
// Start at the beginning of returnRange
returnRange->CloneRange(getter_AddRefs(mStartPointRange));
mStartPointRange->Collapse(true);
}
} else {
// We can continue at the start of mStartPointRange if its start is
// after the end of returnRange or coincides with it. Otherwise, we
// need to continue at the end of returnRange.
int16_t compareResult;
nsresult rv =
mStartPointRange->CompareBoundaryPoints(nsIDOMRange::END_TO_START,
returnRange, &compareResult);
if (NS_SUCCEEDED(rv) && compareResult >= 0) {
// OK to start at the start of mStartPointRange
mStartPointRange->Collapse(true);
} else {
// Start at the end of returnRange
returnRange->CloneRange(getter_AddRefs(mStartPointRange));
mStartPointRange->Collapse(false);
}
}
continue;
}
mFoundRange = returnRange;
// ------ Success! -------
// Hide old selection (new one may be on a different controller)
if (selection) {
selection->CollapseToStart();
SetSelectionModeAndRepaint(nsISelectionController::SELECTION_ON);
}
// Make sure new document is selected
if (presShell != startingPresShell) {
// We are in a new document (because of frames/iframes)
mPresShell = do_GetWeakReference(presShell);
}
nsCOMPtr<nsIDocument> document =
do_QueryInterface(presShell->GetDocument());
NS_ASSERTION(document, "Wow, presShell doesn't have document!");
if (!document)
return NS_ERROR_UNEXPECTED;
nsCOMPtr<nsPIDOMWindowInner> window = document->GetInnerWindow();
NS_ASSERTION(window, "document has no window");
if (!window)
return NS_ERROR_UNEXPECTED;
nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID);
if (usesIndependentSelection) {
/* If a search result is found inside an editable element, we'll focus
* the element only if focus is in our content window, i.e.
* |if (focusedWindow.top == ourWindow.top)| */
bool shouldFocusEditableElement = false;
if (fm) {
nsCOMPtr<mozIDOMWindowProxy> focusedWindow;
nsresult rv = fm->GetFocusedWindow(getter_AddRefs(focusedWindow));
if (NS_SUCCEEDED(rv)) {
auto* fwPI = nsPIDOMWindowOuter::From(focusedWindow);
nsCOMPtr<nsIDocShellTreeItem> fwTreeItem
(do_QueryInterface(fwPI->GetDocShell(), &rv));
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsIDocShellTreeItem> fwRootTreeItem;
rv = fwTreeItem->GetSameTypeRootTreeItem(getter_AddRefs(fwRootTreeItem));
if (NS_SUCCEEDED(rv) && fwRootTreeItem == rootContentTreeItem)
shouldFocusEditableElement = true;
}
}
}
// We may be inside an editable element, and therefore the selection
// may be controlled by a different selection controller. Walk up the
// chain of parent nodes to see if we find one.
nsCOMPtr<nsIDOMNode> node;
returnRange->GetStartContainer(getter_AddRefs(node));
while (node) {
nsCOMPtr<nsIDOMNSEditableElement> editable = do_QueryInterface(node);
if (editable) {
// Inside an editable element. Get the correct selection
// controller and selection.
nsCOMPtr<nsIEditor> editor;
editable->GetEditor(getter_AddRefs(editor));
NS_ASSERTION(editor, "Editable element has no editor!");
if (!editor) {
break;
}
editor->GetSelectionController(
getter_AddRefs(selectionController));
if (selectionController) {
selectionController->GetSelection(
nsISelectionController::SELECTION_NORMAL,
getter_AddRefs(selection));
}
mFoundEditable = do_QueryInterface(node);
if (!shouldFocusEditableElement)
break;
// Otherwise move focus/caret to editable element
if (fm)
fm->SetFocus(mFoundEditable, 0);
break;
}
nsIDOMNode* tmp = node;
tmp->GetParentNode(getter_AddRefs(node));
}
// If we reach here without setting mFoundEditable, then something
// besides editable elements can cause us to have an independent
// selection controller. I don't know whether this is possible.
// Currently, we simply fall back to grabbing the document's selection
// controller in this case. Perhaps we should reject this find match
// and search again.
NS_ASSERTION(mFoundEditable, "Independent selection controller on "
"non-editable element!");
}
if (!mFoundEditable) {
// Not using a separate selection controller, so just get the
// document's controller and selection.
GetSelection(presShell, getter_AddRefs(selectionController),
getter_AddRefs(selection));
}
mSelectionController = do_GetWeakReference(selectionController);
// Select the found text
if (selection) {
selection->RemoveAllRanges();
selection->AddRange(returnRange);
}
if (!mFoundEditable && fm) {
fm->MoveFocus(window->GetOuterWindow(),
nullptr, nsIFocusManager::MOVEFOCUS_CARET,
nsIFocusManager::FLAG_NOSCROLL | nsIFocusManager::FLAG_NOSWITCHFRAME,
getter_AddRefs(mFoundLink));
}
// Change selection color to ATTENTION and scroll to it. Careful: we
// must wait until after we goof with focus above before changing to
// ATTENTION, or when we MoveFocus() and the selection is not on a
// link, we'll blur, which will lose the ATTENTION.
if (selectionController) {
// Beware! This may flush notifications via synchronous
// ScrollSelectionIntoView.
SetSelectionModeAndRepaint(nsISelectionController::SELECTION_ATTENTION);
selectionController->ScrollSelectionIntoView(
nsISelectionController::SELECTION_NORMAL,
nsISelectionController::SELECTION_WHOLE_SELECTION,
nsISelectionController::SCROLL_CENTER_VERTICALLY |
nsISelectionController::SCROLL_SYNCHRONOUS);
}
mCurrentWindow = window;
*aResult = hasWrapped ? FIND_WRAPPED : FIND_FOUND;
return NS_OK;
}
// ======= end-inner-while (go through a single document) ==========
// ---------- Nothing found yet, try next document -------------
bool hasTriedFirstDoc = false;
do {
// ==== Second inner loop - get another while ====
if (NS_SUCCEEDED(docShellEnumerator->HasMoreElements(&hasMoreDocShells))
&& hasMoreDocShells) {
docShellEnumerator->GetNext(getter_AddRefs(currentContainer));
NS_ASSERTION(currentContainer, "HasMoreElements lied to us!");
currentDocShell = do_QueryInterface(currentContainer);
if (currentDocShell)
break;
}
else if (hasTriedFirstDoc) // Avoid potential infinite loop
return NS_ERROR_FAILURE; // No content doc shells
// Reached last doc shell, loop around back to first doc shell
rootContentDocShell->GetDocShellEnumerator(nsIDocShellTreeItem::typeContent,
nsIDocShell::ENUMERATE_FORWARDS,
getter_AddRefs(docShellEnumerator));
hasTriedFirstDoc = true;
} while (docShellEnumerator); // ==== end second inner while ===
bool continueLoop = false;
if (currentDocShell != startingDocShell)
continueLoop = true; // Try next document
else if (!hasWrapped || aIsFirstVisiblePreferred) {
// Finished searching through docshells:
// If aFirstVisiblePreferred == true, we may need to go through all
// docshells twice -once to look for visible matches, the second time
// for any match
aIsFirstVisiblePreferred = false;
hasWrapped = true;
continueLoop = true; // Go through all docs again
}
if (continueLoop) {
if (NS_FAILED(GetSearchContainers(currentContainer, nullptr,
aIsFirstVisiblePreferred, aFindPrev,
getter_AddRefs(presShell),
getter_AddRefs(presContext)))) {
continue;
}
if (aFindPrev) {
// Reverse mode: swap start and end points, so that we start
// at end of document and go to beginning
nsCOMPtr<nsIDOMRange> tempRange;
mStartPointRange->CloneRange(getter_AddRefs(tempRange));
if (!mEndPointRange) {
mEndPointRange = new nsRange(presShell->GetDocument());
}
mStartPointRange = mEndPointRange;
mEndPointRange = tempRange;
}
continue;
}
// ------------- Failed --------------
break;
} // end-outer-while: go through all docs
return NS_ERROR_FAILURE;
}
nsresult nsDocShellEnumerator::SetEnumerationRootItem(nsIDocShellTreeItem * aEnumerationRootItem)
{
mRootItem = do_GetWeakReference(aEnumerationRootItem);
ClearState();
return NS_OK;
}
DocumentResizeEventListener::DocumentResizeEventListener(nsIHTMLEditor * aEditor)
{
mEditor = do_GetWeakReference(aEditor);
}
NS_IMETHODIMP
nsLDAPConnection::OnLookupComplete(nsICancelable *aRequest,
nsIDNSRecord *aRecord,
nsresult aStatus)
{
nsresult rv = NS_OK;
if (aRecord) {
// Build mResolvedIP list
//
mResolvedIP.Truncate();
PRInt32 index = 0;
char addrbuf[64];
PRNetAddr addr;
while (NS_SUCCEEDED(aRecord->GetNextAddr(0, &addr))) {
// We can only use v4 addresses
//
PRBool v4mapped = PR_FALSE;
if (addr.raw.family == PR_AF_INET6)
v4mapped = PR_IsNetAddrType(&addr, PR_IpAddrV4Mapped);
if (addr.raw.family == PR_AF_INET || v4mapped) {
// If there are more IPs in the list, we separate them with
// a space, as supported/used by the LDAP C-SDK.
//
if (index++)
mResolvedIP.Append(' ');
// Convert the IPv4 address to a string, and append it to our
// list of IPs. Strip leading '::FFFF:' (the IPv4-mapped-IPv6
// indicator) if present.
//
PR_NetAddrToString(&addr, addrbuf, sizeof(addrbuf));
if ((addrbuf[0] == ':') && (strlen(addrbuf) > 7))
mResolvedIP.Append(addrbuf+7);
else
mResolvedIP.Append(addrbuf);
}
}
}
if (NS_FAILED(aStatus)) {
// The DNS service failed, lets pass something reasonable
// back to the listener.
//
switch (aStatus) {
case NS_ERROR_OUT_OF_MEMORY:
case NS_ERROR_UNKNOWN_HOST:
case NS_ERROR_FAILURE:
case NS_ERROR_OFFLINE:
rv = aStatus;
break;
default:
rv = NS_ERROR_UNEXPECTED;
break;
}
} else if (!mResolvedIP.Length()) {
// We have no host resolved, that is very bad, and should most
// likely have been caught earlier.
//
NS_ERROR("nsLDAPConnection::OnStopLookup(): the resolved IP "
"string is empty.\n");
rv = NS_ERROR_UNKNOWN_HOST;
} else {
// We've got the IP(s) for the hostname, now lets setup the
// LDAP connection using this information. Note that if the
// LDAP server returns a referral, the C-SDK will perform a
// new, synchronous DNS lookup, which might hang (but hopefully
// if we've come this far, DNS is working properly).
//
mConnectionHandle = ldap_init(mResolvedIP.get(),
mPort == -1 ? LDAP_PORT : mPort);
// Check that we got a proper connection, and if so, setup the
// threading functions for this connection.
//
if ( !mConnectionHandle ) {
rv = NS_ERROR_FAILURE; // LDAP C SDK API gives no useful error
} else {
#if defined(DEBUG_dmose) || defined(DEBUG_bienvenu)
const int lDebug = 0;
ldap_set_option(mConnectionHandle, LDAP_OPT_DEBUG_LEVEL, &lDebug);
#endif
// the C SDK currently defaults to v2. if we're to use v3,
// tell it so.
//
int version;
switch (mVersion) {
case 2:
break;
case 3:
version = LDAP_VERSION3;
ldap_set_option(mConnectionHandle, LDAP_OPT_PROTOCOL_VERSION,
&version);
break;
default:
NS_ERROR("nsLDAPConnection::OnLookupComplete(): mVersion"
" invalid");
}
#ifdef MOZ_PSM
// This code sets up the current connection to use PSM for SSL
// functionality. Making this use libssldap instead for
// non-browser user shouldn't be hard.
extern nsresult nsLDAPInstallSSL(LDAP *ld, const char *aHostName);
if (mSSL) {
if (ldap_set_option(mConnectionHandle, LDAP_OPT_SSL,
LDAP_OPT_ON) != LDAP_SUCCESS ) {
NS_ERROR("nsLDAPConnection::OnStopLookup(): Error"
" configuring connection to use SSL");
rv = NS_ERROR_UNEXPECTED;
}
rv = nsLDAPInstallSSL(mConnectionHandle, mDNSHost.get());
if (NS_FAILED(rv)) {
NS_ERROR("nsLDAPConnection::OnStopLookup(): Error"
" installing secure LDAP routines for"
" connection");
}
}
#endif
}
// Create a new runnable object, and increment the refcnt. The
// thread will also hold a strong ref to the runnable, but we need
// to make sure it doesn't get destructed until we are done with
// all locking etc. in nsLDAPConnection::Release().
//
mRunnable = new nsLDAPConnectionLoop();
NS_IF_ADDREF(mRunnable);
if (!mRunnable || NS_FAILED(mRunnable->Init())) {
rv = NS_ERROR_OUT_OF_MEMORY;
} else {
// Here we keep a weak reference in the runnable object to the
// nsLDAPConnection ("this"). This avoids the problem where a
// connection can't get destructed because of the new thread
// keeping a strong reference to it. It also helps us know when
// we need to exit the new thread: when we can't convert the weak
// reference to a strong ref, we know that the nsLDAPConnection
// object is gone, and we need to stop the thread running.
//
nsCOMPtr<nsILDAPConnection> conn =
static_cast<nsILDAPConnection *>(this);
mRunnable->mWeakConn = do_GetWeakReference(conn);
// kick off a thread for result listening and marshalling
//
rv = NS_NewThread(getter_AddRefs(mThread), mRunnable);
if (NS_FAILED(rv)) {
rv = NS_ERROR_NOT_AVAILABLE;
}
// XXX(darin): We need to shutdown this thread at some point.
// Otherwise, it will stick around until shutdown.
}
}
// Drop the DNS request object, we no longer need it, and set the flag
// indicating that DNS has finished.
//
mDNSRequest = 0;
mDNSHost.Truncate();
// Call the listener, and then we can release our reference to it.
//
mInitListener->OnLDAPInit(this, rv);
mInitListener = 0;
return rv;
}
nsresult
nsEditingSession::ReattachToWindow(nsIDOMWindow* aWindow)
{
if (!mDoneSetup)
return NS_OK;
NS_ASSERTION(mStateMaintainer, "mStateMaintainer should exist.");
// Imitate nsEditorDocShell::MakeEditable() to reattach the
// old editor ot the window.
nsresult rv;
mWindowToBeEdited = do_GetWeakReference(aWindow);
// Disable plugins.
if (!mInteractive)
{
rv = DisableJSAndPlugins(aWindow);
NS_ENSURE_SUCCESS(rv, rv);
}
// Tells embedder that startup is in progress.
mEditorStatus = eEditorCreationInProgress;
// Adds back web progress listener.
rv = PrepareForEditing(aWindow);
NS_ENSURE_SUCCESS(rv, rv);
// Setup the command controllers again.
rv = SetupEditorCommandController("@mozilla.org/editor/editorcontroller;1",
aWindow,
static_cast<nsIEditingSession*>(this),
&mBaseCommandControllerId);
NS_ENSURE_SUCCESS(rv, rv);
rv = SetupEditorCommandController("@mozilla.org/editor/editordocstatecontroller;1",
aWindow,
static_cast<nsIEditingSession*>(this),
&mDocStateControllerId);
NS_ENSURE_SUCCESS(rv, rv);
if (mStateMaintainer)
mStateMaintainer->Init(aWindow);
// Get editor
nsCOMPtr<nsIEditor> editor;
rv = GetEditorForWindow(aWindow, getter_AddRefs(editor));
if (!editor)
return NS_ERROR_FAILURE;
if (!mInteractive)
{
// Disable animation of images in this document:
nsCOMPtr<nsIDOMWindowUtils> utils(do_GetInterface(aWindow));
if (!utils) return NS_ERROR_FAILURE;
rv = utils->GetImageAnimationMode(&mImageAnimationMode);
NS_ENSURE_SUCCESS(rv, rv);
utils->SetImageAnimationMode(imgIContainer::kDontAnimMode);
}
// The third controller takes an nsIEditor as the context
rv = SetupEditorCommandController("@mozilla.org/editor/htmleditorcontroller;1",
aWindow, editor,
&mHTMLCommandControllerId);
NS_ENSURE_SUCCESS(rv, rv);
// Set context on all controllers to be the editor
rv = SetEditorOnControllers(aWindow, editor);
NS_ENSURE_SUCCESS(rv, rv);
#ifdef DEBUG
{
PRBool isEditable;
rv = WindowIsEditable(aWindow, &isEditable);
NS_ENSURE_SUCCESS(rv, rv);
NS_ASSERTION(isEditable, "Window is not editable after reattaching editor.");
}
#endif // DEBUG
return NS_OK;
}
nsresult
XPathResult::SetExprResult(txAExprResult* aExprResult, uint16_t aResultType,
nsINode* aContextNode)
{
MOZ_ASSERT(aExprResult);
if ((isSnapshot(aResultType) || isIterator(aResultType) ||
isNode(aResultType)) &&
aExprResult->getResultType() != txAExprResult::NODESET) {
// The DOM spec doesn't really say what should happen when reusing an
// XPathResult and an error is thrown. Let's not touch the XPathResult
// in that case.
return NS_ERROR_DOM_TYPE_ERR;
}
mResultType = aResultType;
mContextNode = do_GetWeakReference(aContextNode);
if (mDocument) {
mDocument->RemoveMutationObserver(this);
mDocument = nullptr;
}
mResultNodes.Clear();
// XXX This will keep the recycler alive, should we clear it?
mResult = aExprResult;
switch (mResultType) {
case BOOLEAN_TYPE:
{
mBooleanResult = mResult->booleanValue();
break;
}
case NUMBER_TYPE:
{
mNumberResult = mResult->numberValue();
break;
}
case STRING_TYPE:
{
mResult->stringValue(mStringResult);
break;
}
default:
{
MOZ_ASSERT(isNode() || isIterator() || isSnapshot());
}
}
if (aExprResult->getResultType() == txAExprResult::NODESET) {
txNodeSet *nodeSet = static_cast<txNodeSet*>(aExprResult);
int32_t i, count = nodeSet->size();
for (i = 0; i < count; ++i) {
nsINode* node = txXPathNativeNode::getNode(nodeSet->get(i));
mResultNodes.AppendObject(node);
}
if (count > 0) {
mResult = nullptr;
}
}
if (!isIterator()) {
return NS_OK;
}
mInvalidIteratorState = false;
if (mResultNodes.Count() > 0) {
// If we support the document() function in DOM-XPath we need to
// observe all documents that we have resultnodes in.
mDocument = mResultNodes[0]->OwnerDoc();
NS_ASSERTION(mDocument, "We need a document!");
if (mDocument) {
mDocument->AddMutationObserver(this);
}
}
return NS_OK;
}
nsLocation::nsLocation(nsIDocShell *aDocShell)
{
mDocShell = do_GetWeakReference(aDocShell);
nsCOMPtr<nsIDOMWindow> outer = do_GetInterface(aDocShell);
mOuter = do_GetWeakReference(outer);
}
nsresult
nsPluginStreamListenerPeer::RequestRead(NPByteRange* rangeList)
{
nsAutoCString rangeString;
int32_t numRequests;
MakeByteRangeString(rangeList, rangeString, &numRequests);
if (numRequests == 0)
return NS_ERROR_FAILURE;
nsresult rv = NS_OK;
nsRefPtr<nsPluginInstanceOwner> owner = mPluginInstance->GetOwner();
nsCOMPtr<nsIDOMElement> element;
nsCOMPtr<nsIDocument> doc;
if (owner) {
rv = owner->GetDOMElement(getter_AddRefs(element));
NS_ENSURE_SUCCESS(rv, rv);
rv = owner->GetDocument(getter_AddRefs(doc));
NS_ENSURE_SUCCESS(rv, rv);
}
nsCOMPtr<nsIInterfaceRequestor> callbacks = do_QueryReferent(mWeakPtrChannelCallbacks);
nsCOMPtr<nsILoadGroup> loadGroup = do_QueryReferent(mWeakPtrChannelLoadGroup);
nsCOMPtr<nsIChannel> channel;
nsCOMPtr<nsINode> requestingNode(do_QueryInterface(element));
if (requestingNode) {
rv = NS_NewChannel(getter_AddRefs(channel),
mURL,
requestingNode,
nsILoadInfo::SEC_NORMAL,
nsIContentPolicy::TYPE_OTHER,
loadGroup,
callbacks);
}
else {
// in this else branch we really don't know where the load is coming
// from and in fact should use something better than just using
// a nullPrincipal as the loadingPrincipal.
nsCOMPtr<nsIPrincipal> principal =
do_CreateInstance("@mozilla.org/nullprincipal;1", &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = NS_NewChannel(getter_AddRefs(channel),
mURL,
principal,
nsILoadInfo::SEC_NORMAL,
nsIContentPolicy::TYPE_OTHER,
loadGroup,
callbacks);
}
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
if (!httpChannel)
return NS_ERROR_FAILURE;
httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("Range"), rangeString, false);
mAbort = true; // instruct old stream listener to cancel
// the request on the next ODA.
nsCOMPtr<nsIStreamListener> converter;
if (numRequests == 1) {
converter = this;
// set current stream offset equal to the first offset in the range list
// it will work for single byte range request
// for multy range we'll reset it in ODA
SetStreamOffset(rangeList->offset);
} else {
nsWeakPtr weakpeer =
do_GetWeakReference(static_cast<nsISupportsWeakReference*>(this));
nsPluginByteRangeStreamListener *brrListener =
new nsPluginByteRangeStreamListener(weakpeer);
if (brrListener)
converter = brrListener;
else
return NS_ERROR_OUT_OF_MEMORY;
}
mPendingRequests += numRequests;
nsCOMPtr<nsISupportsPRUint32> container = do_CreateInstance(NS_SUPPORTS_PRUINT32_CONTRACTID, &rv);
if (NS_FAILED(rv))
return rv;
rv = container->SetData(MAGIC_REQUEST_CONTEXT);
if (NS_FAILED(rv))
return rv;
rv = channel->AsyncOpen(converter, container);
if (NS_SUCCEEDED(rv))
TrackRequest(channel);
return rv;
}
void
APZEventState::ProcessTouchEvent(const WidgetTouchEvent& aEvent,
const ScrollableLayerGuid& aGuid,
uint64_t aInputBlockId,
nsEventStatus aApzResponse,
nsEventStatus aContentResponse)
{
if (aEvent.mMessage == eTouchStart && aEvent.mTouches.Length() > 0) {
mActiveElementManager->SetTargetElement(aEvent.mTouches[0]->GetTarget());
mLastTouchIdentifier = aEvent.mTouches[0]->Identifier();
}
bool isTouchPrevented = aContentResponse == nsEventStatus_eConsumeNoDefault;
bool sentContentResponse = false;
APZES_LOG("Handling event type %d\n", aEvent.mMessage);
switch (aEvent.mMessage) {
case eTouchStart: {
mTouchEndCancelled = false;
mTouchRollup = do_GetWeakReference(widget::nsAutoRollup::GetLastRollup());
sentContentResponse = SendPendingTouchPreventedResponse(false);
// sentContentResponse can be true here if we get two TOUCH_STARTs in a row
// and just responded to the first one.
// We're about to send a response back to APZ, but we should only do it
// for events that went through APZ (which should be all of them).
MOZ_ASSERT(aEvent.mFlags.mHandledByAPZ);
if (isTouchPrevented) {
mContentReceivedInputBlockCallback(aGuid, aInputBlockId, isTouchPrevented);
sentContentResponse = true;
} else {
APZES_LOG("Event not prevented; pending response for %" PRIu64 " %s\n",
aInputBlockId, Stringify(aGuid).c_str());
mPendingTouchPreventedResponse = true;
mPendingTouchPreventedGuid = aGuid;
mPendingTouchPreventedBlockId = aInputBlockId;
}
break;
}
case eTouchEnd:
if (isTouchPrevented) {
mTouchEndCancelled = true;
mEndTouchIsClick = false;
}
MOZ_FALLTHROUGH;
case eTouchCancel:
mActiveElementManager->HandleTouchEndEvent(mEndTouchIsClick);
MOZ_FALLTHROUGH;
case eTouchMove: {
if (mPendingTouchPreventedResponse) {
MOZ_ASSERT(aGuid == mPendingTouchPreventedGuid);
}
sentContentResponse = SendPendingTouchPreventedResponse(isTouchPrevented);
break;
}
default:
MOZ_ASSERT_UNREACHABLE("Unknown touch event type");
break;
}
if (sentContentResponse && !isTouchPrevented &&
aApzResponse == nsEventStatus_eConsumeDoDefault &&
gfxPrefs::PointerEventsEnabled()) {
WidgetTouchEvent cancelEvent(aEvent);
cancelEvent.mMessage = eTouchPointerCancel;
cancelEvent.mFlags.mCancelable = false; // mMessage != eTouchCancel;
for (uint32_t i = 0; i < cancelEvent.mTouches.Length(); ++i) {
if (mozilla::dom::Touch* touch = cancelEvent.mTouches[i]) {
touch->convertToPointer = true;
}
}
nsEventStatus status;
cancelEvent.mWidget->DispatchEvent(&cancelEvent, status);
}
}
nsresult nsWebShellWindow::Initialize(nsIXULWindow* aParent,
nsIAppShell* aShell, nsIURI* aUrl,
PRInt32 aInitialWidth,
PRInt32 aInitialHeight,
PRBool aIsHiddenWindow,
nsWidgetInitData& widgetInitData)
{
nsresult rv;
nsCOMPtr<nsIWidget> parentWidget;
mIsHiddenWindow = aIsHiddenWindow;
// XXX: need to get the default window size from prefs...
// Doesn't come from prefs... will come from CSS/XUL/RDF
nsRect r(0, 0, aInitialWidth, aInitialHeight);
// Create top level window
mWindow = do_CreateInstance(kWindowCID, &rv);
if (NS_OK != rv) {
return rv;
}
/* This next bit is troublesome. We carry two different versions of a pointer
to our parent window. One is the parent window's widget, which is passed
to our own widget. The other is a weak reference we keep here to our
parent WebShellWindow. The former is useful to the widget, and we can't
trust its treatment of the parent reference because they're platform-
specific. The latter is useful to this class.
A better implementation would be one in which the parent keeps strong
references to its children and closes them before it allows itself
to be closed. This would mimic the behaviour of OSes that support
top-level child windows in OSes that do not. Later.
*/
nsCOMPtr<nsIBaseWindow> parentAsWin(do_QueryInterface(aParent));
if (parentAsWin) {
parentAsWin->GetMainWidget(getter_AddRefs(parentWidget));
mParentWindow = do_GetWeakReference(aParent);
}
mWindow->SetClientData(this);
mWindow->Create((nsIWidget *)parentWidget, // Parent nsIWidget
r, // Widget dimensions
nsWebShellWindow::HandleEvent, // Event handler function
nsnull, // Device context
aShell, // Application shell
nsnull, // nsIToolkit
&widgetInitData); // Widget initialization data
mWindow->GetClientBounds(r);
mWindow->SetBackgroundColor(NS_RGB(192,192,192));
// Create web shell
mDocShell = do_CreateInstance("@mozilla.org/webshell;1");
NS_ENSURE_TRUE(mDocShell, NS_ERROR_FAILURE);
// Make sure to set the item type on the docshell _before_ calling
// Create() so it knows what type it is.
nsCOMPtr<nsIDocShellTreeItem> docShellAsItem(do_QueryInterface(mDocShell));
NS_ENSURE_TRUE(docShellAsItem, NS_ERROR_FAILURE);
NS_ENSURE_SUCCESS(EnsureChromeTreeOwner(), NS_ERROR_FAILURE);
docShellAsItem->SetTreeOwner(mChromeTreeOwner);
docShellAsItem->SetItemType(nsIDocShellTreeItem::typeChrome);
r.x = r.y = 0;
nsCOMPtr<nsIBaseWindow> docShellAsWin(do_QueryInterface(mDocShell));
NS_ENSURE_SUCCESS(docShellAsWin->InitWindow(nsnull, mWindow,
r.x, r.y, r.width, r.height), NS_ERROR_FAILURE);
NS_ENSURE_SUCCESS(docShellAsWin->Create(), NS_ERROR_FAILURE);
// Attach a WebProgress listener.during initialization...
nsCOMPtr<nsIWebProgress> webProgress(do_GetInterface(mDocShell, &rv));
if (webProgress) {
webProgress->AddProgressListener(this, nsIWebProgress::NOTIFY_STATE_NETWORK);
}
if (nsnull != aUrl) {
nsCAutoString tmpStr;
rv = aUrl->GetSpec(tmpStr);
if (NS_FAILED(rv)) return rv;
NS_ConvertUTF8toUCS2 urlString(tmpStr);
nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(mDocShell));
NS_ENSURE_TRUE(webNav, NS_ERROR_FAILURE);
rv = webNav->LoadURI(urlString.get(),
nsIWebNavigation::LOAD_FLAGS_NONE,
nsnull,
nsnull,
nsnull);
NS_ENSURE_SUCCESS(rv, rv);
}
return rv;
}
NS_IMETHODIMP nsMsgQuoteListener::SetMsgQuote(nsIMsgQuote * msgQuote)
{
mMsgQuote = do_GetWeakReference(msgQuote);
return NS_OK;
}
LoadInfo::LoadInfo(nsIPrincipal* aLoadingPrincipal,
nsIPrincipal* aTriggeringPrincipal,
nsINode* aLoadingContext,
nsSecurityFlags aSecurityFlags,
nsContentPolicyType aContentPolicyType)
: mLoadingPrincipal(aLoadingContext ?
aLoadingContext->NodePrincipal() : aLoadingPrincipal)
, mTriggeringPrincipal(aTriggeringPrincipal ?
aTriggeringPrincipal : mLoadingPrincipal.get())
, mLoadingContext(do_GetWeakReference(aLoadingContext))
, mSecurityFlags(aSecurityFlags)
, mInternalContentPolicyType(aContentPolicyType)
, mTainting(LoadTainting::Basic)
, mUpgradeInsecureRequests(false)
, mUpgradeInsecurePreloads(false)
, mInnerWindowID(0)
, mOuterWindowID(0)
, mParentOuterWindowID(0)
, mEnforceSecurity(false)
, mInitialSecurityCheckDone(false)
, mIsThirdPartyContext(true)
{
MOZ_ASSERT(mLoadingPrincipal);
MOZ_ASSERT(mTriggeringPrincipal);
// if consumers pass both, aLoadingContext and aLoadingPrincipal
// then the loadingPrincipal must be the same as the node's principal
MOZ_ASSERT(!aLoadingContext || !aLoadingPrincipal ||
aLoadingContext->NodePrincipal() == aLoadingPrincipal);
// if the load is sandboxed, we can not also inherit the principal
if (mSecurityFlags & nsILoadInfo::SEC_SANDBOXED) {
mSecurityFlags ^= nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL;
}
if (aLoadingContext) {
nsCOMPtr<nsPIDOMWindow> outerWindow;
// When the element being loaded is a frame, we choose the frame's window
// for the window ID and the frame element's window as the parent
// window. This is the behavior that Chrome exposes to add-ons.
nsCOMPtr<nsIFrameLoaderOwner> frameLoaderOwner = do_QueryInterface(aLoadingContext);
if (frameLoaderOwner) {
nsCOMPtr<nsIFrameLoader> fl = frameLoaderOwner->GetFrameLoader();
nsCOMPtr<nsIDocShell> docShell;
if (fl && NS_SUCCEEDED(fl->GetDocShell(getter_AddRefs(docShell))) && docShell) {
outerWindow = do_GetInterface(docShell);
}
} else {
outerWindow = aLoadingContext->OwnerDoc()->GetWindow();
}
if (outerWindow) {
nsCOMPtr<nsPIDOMWindow> inner = outerWindow->GetCurrentInnerWindow();
mInnerWindowID = inner ? inner->WindowID() : 0;
mOuterWindowID = outerWindow->WindowID();
nsCOMPtr<nsPIDOMWindow> parent = outerWindow->GetScriptableParent();
mParentOuterWindowID = parent->WindowID();
ComputeIsThirdPartyContext(outerWindow);
}
mUpgradeInsecureRequests = aLoadingContext->OwnerDoc()->GetUpgradeInsecureRequests();
mUpgradeInsecurePreloads = aLoadingContext->OwnerDoc()->GetUpgradeInsecurePreloads();
}
const PrincipalOriginAttributes attrs = BasePrincipal::Cast(mLoadingPrincipal)->OriginAttributesRef();
mOriginAttributes.InheritFromDocToNecko(attrs);
}
NS_IMETHODIMP
nsTypeAheadFind::Find(const nsAString& aSearchString, bool aLinksOnly,
uint16_t* aResult)
{
*aResult = FIND_NOTFOUND;
nsCOMPtr<nsIPresShell> presShell (GetPresShell());
if (!presShell) {
nsCOMPtr<nsIDocShell> ds (do_QueryReferent(mDocShell));
NS_ENSURE_TRUE(ds, NS_ERROR_FAILURE);
presShell = ds->GetPresShell();
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
mPresShell = do_GetWeakReference(presShell);
}
nsCOMPtr<nsISelection> selection;
nsCOMPtr<nsISelectionController> selectionController =
do_QueryReferent(mSelectionController);
if (!selectionController) {
GetSelection(presShell, getter_AddRefs(selectionController),
getter_AddRefs(selection)); // cache for reuse
mSelectionController = do_GetWeakReference(selectionController);
} else {
selectionController->GetSelection(
nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));
}
if (selection)
selection->CollapseToStart();
if (aSearchString.IsEmpty()) {
mTypeAheadBuffer.Truncate();
// These will be initialized to their true values after the first character
// is typed
mStartFindRange = nullptr;
mSelectionController = nullptr;
*aResult = FIND_FOUND;
return NS_OK;
}
bool atEnd = false;
if (mTypeAheadBuffer.Length()) {
const nsAString& oldStr = Substring(mTypeAheadBuffer, 0, mTypeAheadBuffer.Length());
const nsAString& newStr = Substring(aSearchString, 0, mTypeAheadBuffer.Length());
if (oldStr.Equals(newStr))
atEnd = true;
const nsAString& newStr2 = Substring(aSearchString, 0, aSearchString.Length());
const nsAString& oldStr2 = Substring(mTypeAheadBuffer, 0, aSearchString.Length());
if (oldStr2.Equals(newStr2))
atEnd = true;
if (!atEnd)
mStartFindRange = nullptr;
}
if (!mIsSoundInitialized && !mNotFoundSoundURL.IsEmpty()) {
// This makes sure system sound library is loaded so that
// there's no lag before the first sound is played
// by waiting for the first keystroke, we still get the startup time benefits.
mIsSoundInitialized = true;
mSoundInterface = do_CreateInstance("@mozilla.org/sound;1");
if (mSoundInterface && !mNotFoundSoundURL.EqualsLiteral("beep")) {
mSoundInterface->Init();
}
}
#ifdef XP_WIN
// After each keystroke, ensure sound object is destroyed, to free up memory
// allocated for error sound, otherwise Windows' nsISound impl
// holds onto the last played sound, using up memory.
mSoundInterface = nullptr;
#endif
int32_t bufferLength = mTypeAheadBuffer.Length();
mTypeAheadBuffer = aSearchString;
bool isFirstVisiblePreferred = false;
// --------- Initialize find if 1st char ----------
if (bufferLength == 0) {
// If you can see the selection (not collapsed or thru caret browsing),
// or if already focused on a page element, start there.
// Otherwise we're going to start at the first visible element
bool isSelectionCollapsed = true;
if (selection)
selection->GetIsCollapsed(&isSelectionCollapsed);
// If true, we will scan from top left of visible area
// If false, we will scan from start of selection
isFirstVisiblePreferred = !atEnd && !mCaretBrowsingOn && isSelectionCollapsed;
if (isFirstVisiblePreferred) {
// Get the focused content. If there is a focused node, ensure the
// selection is at that point. Otherwise, we will just want to start
// from the caret position or the beginning of the document.
nsPresContext* presContext = presShell->GetPresContext();
NS_ENSURE_TRUE(presContext, NS_OK);
nsCOMPtr<nsIDocument> document =
do_QueryInterface(presShell->GetDocument());
if (!document)
return NS_ERROR_UNEXPECTED;
nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID);
if (fm) {
nsPIDOMWindowOuter* window = document->GetWindow();
nsCOMPtr<nsIDOMElement> focusedElement;
nsCOMPtr<mozIDOMWindowProxy> focusedWindow;
fm->GetFocusedElementForWindow(window, false,
getter_AddRefs(focusedWindow),
getter_AddRefs(focusedElement));
// If the root element is focused, then it's actually the document
// that has the focus, so ignore this.
if (focusedElement &&
!SameCOMIdentity(focusedElement, document->GetRootElement())) {
fm->MoveCaretToFocus(window);
isFirstVisiblePreferred = false;
}
}
}
}
// ----------- Find the text! ---------------------
// Beware! This may flush notifications via synchronous
// ScrollSelectionIntoView.
nsresult rv = FindItNow(nullptr, aLinksOnly, isFirstVisiblePreferred,
false, aResult);
// ---------Handle success or failure ---------------
if (NS_SUCCEEDED(rv)) {
if (mTypeAheadBuffer.Length() == 1) {
// If first letter, store where the first find succeeded
// (mStartFindRange)
mStartFindRange = nullptr;
if (selection) {
nsCOMPtr<nsIDOMRange> startFindRange;
selection->GetRangeAt(0, getter_AddRefs(startFindRange));
if (startFindRange)
startFindRange->CloneRange(getter_AddRefs(mStartFindRange));
}
}
}
else {
// Error sound
if (mTypeAheadBuffer.Length() > mLastFindLength)
PlayNotFoundSound();
}
SaveFind();
return NS_OK;
}
NS_IMETHODIMP
nsMsgSearchDBView::SetSearchSession(nsIMsgSearchSession *aSession)
{
m_searchSession = do_GetWeakReference(aSession);
return NS_OK;
}
void
TextComposition::StartHandlingComposition(nsIEditor* aEditor)
{
MOZ_ASSERT(!HasEditor(), "There is a handling editor already");
mEditorWeak = do_GetWeakReference(aEditor);
}
NS_IMETHODIMP
nsPluginStreamListenerPeer::OnStartRequest(nsIRequest *request,
nsISupports* aContext)
{
nsresult rv = NS_OK;
SAMPLE_LABEL("nsPluginStreamListenerPeer", "OnStartRequest");
if (mRequests.IndexOfObject(GetBaseRequest(request)) == -1) {
NS_ASSERTION(mRequests.Count() == 0,
"Only our initial stream should be unknown!");
TrackRequest(request);
}
if (mHaveFiredOnStartRequest) {
return NS_OK;
}
mHaveFiredOnStartRequest = true;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
NS_ENSURE_TRUE(channel, NS_ERROR_FAILURE);
// deal with 404 (Not Found) HTTP response,
// just return, this causes the request to be ignored.
nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
if (httpChannel) {
uint32_t responseCode = 0;
rv = httpChannel->GetResponseStatus(&responseCode);
if (NS_FAILED(rv)) {
// NPP_Notify() will be called from OnStopRequest
// in nsNPAPIPluginStreamListener::CleanUpStream
// return error will cancel this request
// ...and we also need to tell the plugin that
mRequestFailed = true;
return NS_ERROR_FAILURE;
}
if (responseCode > 206) { // not normal
bool bWantsAllNetworkStreams = false;
// We don't always have an instance here already, but if we do, check
// to see if it wants all streams.
if (mPluginInstance) {
rv = mPluginInstance->GetValueFromPlugin(NPPVpluginWantsAllNetworkStreams,
&bWantsAllNetworkStreams);
// If the call returned an error code make sure we still use our default value.
if (NS_FAILED(rv)) {
bWantsAllNetworkStreams = false;
}
}
if (!bWantsAllNetworkStreams) {
mRequestFailed = true;
return NS_ERROR_FAILURE;
}
}
}
// Get the notification callbacks from the channel and save it as
// week ref we'll use it in nsPluginStreamInfo::RequestRead() when
// we'll create channel for byte range request.
nsCOMPtr<nsIInterfaceRequestor> callbacks;
channel->GetNotificationCallbacks(getter_AddRefs(callbacks));
if (callbacks)
mWeakPtrChannelCallbacks = do_GetWeakReference(callbacks);
nsCOMPtr<nsILoadGroup> loadGroup;
channel->GetLoadGroup(getter_AddRefs(loadGroup));
if (loadGroup)
mWeakPtrChannelLoadGroup = do_GetWeakReference(loadGroup);
int32_t length;
rv = channel->GetContentLength(&length);
// it's possible for the server to not send a Content-Length.
// we should still work in this case.
if (NS_FAILED(rv) || length == -1) {
// check out if this is file channel
nsCOMPtr<nsIFileChannel> fileChannel = do_QueryInterface(channel);
if (fileChannel) {
// file does not exist
mRequestFailed = true;
return NS_ERROR_FAILURE;
}
mLength = 0;
}
else {
mLength = length;
}
nsAutoCString aContentType; // XXX but we already got the type above!
rv = channel->GetContentType(aContentType);
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIURI> aURL;
rv = channel->GetURI(getter_AddRefs(aURL));
if (NS_FAILED(rv))
return rv;
aURL->GetSpec(mURLSpec);
if (!aContentType.IsEmpty())
mContentType = aContentType;
#ifdef PLUGIN_LOGGING
PR_LOG(nsPluginLogging::gPluginLog, PLUGIN_LOG_NOISY,
("nsPluginStreamListenerPeer::OnStartRequest this=%p request=%p mime=%s, url=%s\n",
this, request, aContentType.get(), mURLSpec.get()));
PR_LogFlush();
#endif
// If we don't have an instance yet it means we weren't able to load
// a plugin previously because we didn't have the mimetype. Try again
// if we have a mime type now.
if (!mPluginInstance && mContent && !aContentType.IsEmpty()) {
nsObjectLoadingContent *olc = static_cast<nsObjectLoadingContent*>(mContent.get());
rv = olc->InstantiatePluginInstance();
if (NS_SUCCEEDED(rv)) {
rv = olc->GetPluginInstance(getter_AddRefs(mPluginInstance));
if (NS_FAILED(rv)) {
return rv;
}
}
}
// Set up the stream listener...
rv = SetUpStreamListener(request, aURL);
if (NS_FAILED(rv)) return rv;
return rv;
}
void
nsLocation::SetDocShell(nsIDocShell *aDocShell)
{
mDocShell = do_GetWeakReference(aDocShell);
}
nsresult
nsPluginStreamListenerPeer::RequestRead(NPByteRange* rangeList)
{
nsAutoCString rangeString;
int32_t numRequests;
MakeByteRangeString(rangeList, rangeString, &numRequests);
if (numRequests == 0)
return NS_ERROR_FAILURE;
nsresult rv = NS_OK;
nsCOMPtr<nsIInterfaceRequestor> callbacks = do_QueryReferent(mWeakPtrChannelCallbacks);
nsCOMPtr<nsILoadGroup> loadGroup = do_QueryReferent(mWeakPtrChannelLoadGroup);
nsCOMPtr<nsIChannel> channel;
rv = NS_NewChannel(getter_AddRefs(channel), mURL, nullptr, loadGroup, callbacks);
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
if (!httpChannel)
return NS_ERROR_FAILURE;
httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("Range"), rangeString, false);
mAbort = true; // instruct old stream listener to cancel
// the request on the next ODA.
nsCOMPtr<nsIStreamListener> converter;
if (numRequests == 1) {
converter = this;
// set current stream offset equal to the first offset in the range list
// it will work for single byte range request
// for multy range we'll reset it in ODA
SetStreamOffset(rangeList->offset);
} else {
nsWeakPtr weakpeer =
do_GetWeakReference(static_cast<nsISupportsWeakReference*>(this));
nsPluginByteRangeStreamListener *brrListener =
new nsPluginByteRangeStreamListener(weakpeer);
if (brrListener)
converter = brrListener;
else
return NS_ERROR_OUT_OF_MEMORY;
}
mPendingRequests += numRequests;
nsCOMPtr<nsISupportsPRUint32> container = do_CreateInstance(NS_SUPPORTS_PRUINT32_CONTRACTID, &rv);
if (NS_FAILED(rv))
return rv;
rv = container->SetData(MAGIC_REQUEST_CONTEXT);
if (NS_FAILED(rv))
return rv;
rv = channel->AsyncOpen(converter, container);
if (NS_SUCCEEDED(rv))
TrackRequest(channel);
return rv;
}
NS_IMETHODIMP
nsEditingSession::MakeWindowEditable(nsIDOMWindow *aWindow,
const char *aEditorType,
PRBool aDoAfterUriLoad,
PRBool aMakeWholeDocumentEditable,
PRBool aInteractive)
{
mEditorType.Truncate();
mEditorFlags = 0;
mWindowToBeEdited = do_GetWeakReference(aWindow);
// disable plugins
nsIDocShell *docShell = GetDocShellFromWindow(aWindow);
if (!docShell) return NS_ERROR_FAILURE;
mInteractive = aInteractive;
mMakeWholeDocumentEditable = aMakeWholeDocumentEditable;
nsresult rv;
if (!mInteractive) {
rv = DisableJSAndPlugins(aWindow);
NS_ENSURE_SUCCESS(rv, rv);
}
// Always remove existing editor
TearDownEditorOnWindow(aWindow);
// Tells embedder that startup is in progress
mEditorStatus = eEditorCreationInProgress;
//temporary to set editor type here. we will need different classes soon.
if (!aEditorType)
aEditorType = DEFAULT_EDITOR_TYPE;
mEditorType = aEditorType;
// if all this does is setup listeners and I don't need listeners,
// can't this step be ignored?? (based on aDoAfterURILoad)
rv = PrepareForEditing(aWindow);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIEditorDocShell> editorDocShell;
rv = GetEditorDocShellFromWindow(aWindow, getter_AddRefs(editorDocShell));
if (NS_FAILED(rv)) return rv;
// set the flag on the docShell to say that it's editable
rv = editorDocShell->MakeEditable(aDoAfterUriLoad);
if (NS_FAILED(rv)) return rv;
// Setup commands common to plaintext and html editors,
// including the document creation observers
// the first is an editor controller
rv = SetupEditorCommandController("@mozilla.org/editor/editorcontroller;1",
aWindow,
static_cast<nsIEditingSession*>(this),
&mBaseCommandControllerId);
if (NS_FAILED(rv)) return rv;
// The second is a controller to monitor doc state,
// such as creation and "dirty flag"
rv = SetupEditorCommandController("@mozilla.org/editor/editordocstatecontroller;1",
aWindow,
static_cast<nsIEditingSession*>(this),
&mDocStateControllerId);
if (NS_FAILED(rv)) return rv;
// aDoAfterUriLoad can be false only when making an existing window editable
if (!aDoAfterUriLoad)
{
rv = SetupEditorOnWindow(aWindow);
// mEditorStatus is set to the error reason
// Since this is used only when editing an existing page,
// it IS ok to destroy current editor
if (NS_FAILED(rv))
TearDownEditorOnWindow(aWindow);
}
return rv;
}
ResizerMouseMotionListener::ResizerMouseMotionListener(nsIHTMLEditor * aEditor)
{
mEditor = do_GetWeakReference(aEditor);
}
/*---------------------------------------------------------------------------
EndDocumentLoad
Called on end of load in a single frame
----------------------------------------------------------------------------*/
nsresult
nsEditingSession::EndDocumentLoad(nsIWebProgress *aWebProgress,
nsIChannel* aChannel, nsresult aStatus,
PRBool aIsToBeMadeEditable)
{
NS_ENSURE_ARG_POINTER(aWebProgress);
#ifdef NOISY_DOC_LOADING
printf("======= EndDocumentLoad ========\n");
printf("with status %d, ", aStatus);
nsCOMPtr<nsIURI> uri;
nsXPIDLCString spec;
if (NS_SUCCEEDED(aChannel->GetURI(getter_AddRefs(uri)))) {
uri->GetSpec(spec);
printf(" uri %s\n", spec.get());
}
#endif
// We want to call the base class EndDocumentLoad,
// but avoid some of the stuff
// that nsDocShell does (need to refactor).
// OK, time to make an editor on this document
nsCOMPtr<nsIDOMWindow> domWindow;
aWebProgress->GetDOMWindow(getter_AddRefs(domWindow));
// Set the error state -- we will create an editor
// anyway and load empty doc later
if (aIsToBeMadeEditable) {
if (aStatus == NS_ERROR_FILE_NOT_FOUND)
mEditorStatus = eEditorErrorFileNotFound;
}
nsIDocShell *docShell = GetDocShellFromWindow(domWindow);
if (!docShell) return NS_ERROR_FAILURE; // better error handling?
// cancel refresh from meta tags
// we need to make sure that all pages in editor (whether editable or not)
// can't refresh contents being edited
nsCOMPtr<nsIRefreshURI> refreshURI = do_QueryInterface(docShell);
if (refreshURI)
refreshURI->CancelRefreshURITimers();
nsCOMPtr<nsIEditorDocShell> editorDocShell = do_QueryInterface(docShell);
nsresult rv = NS_OK;
// did someone set the flag to make this shell editable?
if (aIsToBeMadeEditable && mCanCreateEditor && editorDocShell)
{
PRBool makeEditable;
editorDocShell->GetEditable(&makeEditable);
if (makeEditable)
{
// To keep pre Gecko 1.9 behavior, setup editor always when
// mMakeWholeDocumentEditable.
PRBool needsSetup;
if (mMakeWholeDocumentEditable) {
needsSetup = PR_TRUE;
} else {
// do we already have an editor here?
nsCOMPtr<nsIEditor> editor;
rv = editorDocShell->GetEditor(getter_AddRefs(editor));
if (NS_FAILED(rv))
return rv;
needsSetup = !editor;
}
if (needsSetup)
{
mCanCreateEditor = PR_FALSE;
rv = SetupEditorOnWindow(domWindow);
if (NS_FAILED(rv))
{
// If we had an error, setup timer to load a blank page later
if (mLoadBlankDocTimer)
{
// Must cancel previous timer?
mLoadBlankDocTimer->Cancel();
mLoadBlankDocTimer = NULL;
}
mLoadBlankDocTimer = do_CreateInstance("@mozilla.org/timer;1", &rv);
if (NS_FAILED(rv)) return rv;
mEditorStatus = eEditorCreationInProgress;
mDocShell = do_GetWeakReference(docShell);
mLoadBlankDocTimer->InitWithFuncCallback(
nsEditingSession::TimerCallback,
static_cast<void*> (mDocShell.get()),
10, nsITimer::TYPE_ONE_SHOT);
}
}
}
}
return rv;
}
NS_IMETHODIMP
nsPluginStreamListenerPeer::OnStartRequest(nsIRequest* request) {
nsresult rv = NS_OK;
AUTO_PROFILER_LABEL("nsPluginStreamListenerPeer::OnStartRequest", OTHER);
if (mRequests.IndexOfObject(request) == -1) {
NS_ASSERTION(mRequests.Count() == 0,
"Only our initial stream should be unknown!");
TrackRequest(request);
}
if (mHaveFiredOnStartRequest) {
return NS_OK;
}
mHaveFiredOnStartRequest = true;
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
NS_ENSURE_TRUE(channel, NS_ERROR_FAILURE);
// deal with 404 (Not Found) HTTP response,
// just return, this causes the request to be ignored.
nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
if (httpChannel) {
uint32_t responseCode = 0;
rv = httpChannel->GetResponseStatus(&responseCode);
if (NS_FAILED(rv)) {
// NPP_Notify() will be called from OnStopRequest
// in nsNPAPIPluginStreamListener::CleanUpStream
// return error will cancel this request
// ...and we also need to tell the plugin that
mRequestFailed = true;
return NS_ERROR_FAILURE;
}
if (responseCode > 206) { // not normal
uint32_t wantsAllNetworkStreams = 0;
// We don't always have an instance here already, but if we do, check
// to see if it wants all streams.
if (mPluginInstance) {
rv = mPluginInstance->GetValueFromPlugin(
NPPVpluginWantsAllNetworkStreams, &wantsAllNetworkStreams);
// If the call returned an error code make sure we still use our default
// value.
if (NS_FAILED(rv)) {
wantsAllNetworkStreams = 0;
}
}
if (!wantsAllNetworkStreams) {
mRequestFailed = true;
return NS_ERROR_FAILURE;
}
}
}
nsAutoCString contentType;
rv = channel->GetContentType(contentType);
if (NS_FAILED(rv)) return rv;
// Check ShouldProcess with content policy
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
int16_t shouldLoad = nsIContentPolicy::ACCEPT;
rv = NS_CheckContentProcessPolicy(mURL, loadInfo, contentType, &shouldLoad);
if (NS_FAILED(rv) || NS_CP_REJECTED(shouldLoad)) {
mRequestFailed = true;
return NS_ERROR_CONTENT_BLOCKED;
}
// Get the notification callbacks from the channel and save it as
// week ref we'll use it in nsPluginStreamInfo::RequestRead() when
// we'll create channel for byte range request.
nsCOMPtr<nsIInterfaceRequestor> callbacks;
channel->GetNotificationCallbacks(getter_AddRefs(callbacks));
if (callbacks) mWeakPtrChannelCallbacks = do_GetWeakReference(callbacks);
nsCOMPtr<nsILoadGroup> loadGroup;
channel->GetLoadGroup(getter_AddRefs(loadGroup));
if (loadGroup) mWeakPtrChannelLoadGroup = do_GetWeakReference(loadGroup);
int64_t length;
rv = channel->GetContentLength(&length);
// it's possible for the server to not send a Content-Length.
// we should still work in this case.
if (NS_FAILED(rv) || length < 0 || length > UINT32_MAX) {
// check out if this is file channel
nsCOMPtr<nsIFileChannel> fileChannel = do_QueryInterface(channel);
if (fileChannel) {
// file does not exist
mRequestFailed = true;
return NS_ERROR_FAILURE;
}
mLength = 0;
} else {
mLength = uint32_t(length);
}
nsCOMPtr<nsIURI> aURL;
rv = channel->GetURI(getter_AddRefs(aURL));
if (NS_FAILED(rv)) return rv;
aURL->GetSpec(mURLSpec);
if (!contentType.IsEmpty()) mContentType = contentType;
#ifdef PLUGIN_LOGGING
MOZ_LOG(nsPluginLogging::gPluginLog, PLUGIN_LOG_NOISY,
("nsPluginStreamListenerPeer::OnStartRequest this=%p request=%p "
"mime=%s, url=%s\n",
this, request, contentType.get(), mURLSpec.get()));
PR_LogFlush();
#endif
// Set up the stream listener...
rv = SetUpStreamListener(request, aURL);
if (NS_FAILED(rv)) {
return rv;
}
return rv;
}
