LCOV - app.info - content/xml/document/src/nsXMLDocument.cpp

LCOV - code coverage report
| Current view: | directory - content/xml/document/src - nsXMLDocument.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 258 | 108 | 41.9 %
| Date: | 2012-06-02 | Functions: | 21 | 14 | 66.7 %

           1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : /* ***** BEGIN LICENSE BLOCK *****
           3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           4                 :  *
           5                 :  * The contents of this file are subject to the Mozilla Public License Version
           6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           7                 :  * the License. You may obtain a copy of the License at
           8                 :  * http://www.mozilla.org/MPL/
           9                 :  *
          10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          12                 :  * for the specific language governing rights and limitations under the
          13                 :  * License.
          14                 :  *
          15                 :  * The Original Code is Mozilla Communicator client code.
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *   Pierre Phaneuf <pp@ludusdesign.com>
          24                 :  *
          25                 :  * Alternatively, the contents of this file may be used under the terms of
          26                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          27                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          28                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          29                 :  * of those above. If you wish to allow use of your version of this file only
          30                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          31                 :  * use your version of this file under the terms of the MPL, indicate your
          32                 :  * decision by deleting the provisions above and replace them with the notice
          33                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          34                 :  * the provisions above, a recipient may use your version of this file under
          35                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          36                 :  *
          37                 :  * ***** END LICENSE BLOCK ***** */
          38                 :
          39                 :
          40                 : #include "nsXMLDocument.h"
          41                 : #include "nsParserCIID.h"
          42                 : #include "nsIParser.h"
          43                 : #include "nsIXMLContentSink.h"
          44                 : #include "nsPresContext.h"
          45                 : #include "nsIContent.h"
          46                 : #include "nsIContentViewerContainer.h"
          47                 : #include "nsIContentViewer.h"
          48                 : #include "nsIDocShell.h"
          49                 : #include "nsIMarkupDocumentViewer.h"
          50                 : #include "nsHTMLParts.h"
          51                 : #include "nsIComponentManager.h"
          52                 : #include "nsIDOMElement.h"
          53                 : #include "nsIBaseWindow.h"
          54                 : #include "nsIDOMWindow.h"
          55                 : #include "nsIDOMDocumentType.h"
          56                 : #include "nsINameSpaceManager.h"
          57                 : #include "nsCOMPtr.h"
          58                 : #include "nsXPIDLString.h"
          59                 : #include "nsIHttpChannel.h"
          60                 : #include "nsIURI.h"
          61                 : #include "nsIServiceManager.h"
          62                 : #include "nsNetUtil.h"
          63                 : #include "nsDOMError.h"
          64                 : #include "nsIScriptSecurityManager.h"
          65                 : #include "nsIPrincipal.h"
          66                 : #include "nsLayoutCID.h"
          67                 : #include "nsDOMAttribute.h"
          68                 : #include "nsGUIEvent.h"
          69                 : #include "nsCExternalHandlerService.h"
          70                 : #include "nsNetUtil.h"
          71                 : #include "nsMimeTypes.h"
          72                 : #include "nsEventListenerManager.h"
          73                 : #include "nsContentUtils.h"
          74                 : #include "nsThreadUtils.h"
          75                 : #include "nsJSUtils.h"
          76                 : #include "nsCRT.h"
          77                 : #include "nsIAuthPrompt.h"
          78                 : #include "nsIScriptGlobalObjectOwner.h"
          79                 : #include "nsIJSContextStack.h"
          80                 : #include "nsContentCreatorFunctions.h"
          81                 : #include "nsContentPolicyUtils.h"
          82                 : #include "nsContentErrors.h"
          83                 : #include "nsIDOMUserDataHandler.h"
          84                 : #include "nsEventDispatcher.h"
          85                 : #include "nsNodeUtils.h"
          86                 : #include "nsIConsoleService.h"
          87                 : #include "nsIScriptError.h"
          88                 : #include "nsIHTMLDocument.h"
          89                 : #include "nsGenericElement.h"
          90                 :
          91                 : // ==================================================================
          92                 : // =
          93                 : // ==================================================================
          94                 :
          95                 :
          96                 : nsresult
          97            1273 : NS_NewDOMDocument(nsIDOMDocument** aInstancePtrResult,
          98                 :                   const nsAString& aNamespaceURI,
          99                 :                   const nsAString& aQualifiedName,
         100                 :                   nsIDOMDocumentType* aDoctype,
         101                 :                   nsIURI* aDocumentURI,
         102                 :                   nsIURI* aBaseURI,
         103                 :                   nsIPrincipal* aPrincipal,
         104                 :                   bool aLoadedAsData,
         105                 :                   nsIScriptGlobalObject* aEventObject,
         106                 :                   DocumentFlavor aFlavor)
         107                 : {
         108                 :   // Note: can't require that aDocumentURI/aBaseURI/aPrincipal be non-null,
         109                 :   // since at least one caller (XMLHttpRequest) doesn't have decent args to
         110                 :   // pass in.
         111                 :
         112                 :   nsresult rv;
         113                 :
         114            1273 :   *aInstancePtrResult = nsnull;
         115                 :
         116            2546 :   nsCOMPtr<nsIDocument> d;
         117            1273 :   bool isHTML = false;
         118            1273 :   bool isXHTML = false;
         119            1273 :   if (aFlavor == DocumentFlavorSVG) {
         120               0 :     rv = NS_NewSVGDocument(getter_AddRefs(d));
         121            1273 :   } else if (aFlavor == DocumentFlavorHTML) {
         122             234 :     rv = NS_NewHTMLDocument(getter_AddRefs(d));
         123             234 :     isHTML = true;
         124            1039 :   } else if (aDoctype) {
         125               0 :     nsAutoString publicId, name;
         126               0 :     aDoctype->GetPublicId(publicId);
         127               0 :     if (publicId.IsEmpty()) {
         128               0 :       aDoctype->GetName(name);
         129                 :     }
         130               0 :     if (name.EqualsLiteral("html") ||
         131               0 :         publicId.EqualsLiteral("-//W3C//DTD HTML 4.01//EN") ||
         132               0 :         publicId.EqualsLiteral("-//W3C//DTD HTML 4.01 Frameset//EN") ||
         133               0 :         publicId.EqualsLiteral("-//W3C//DTD HTML 4.01 Transitional//EN") ||
         134               0 :         publicId.EqualsLiteral("-//W3C//DTD HTML 4.0//EN") ||
         135               0 :         publicId.EqualsLiteral("-//W3C//DTD HTML 4.0 Frameset//EN") ||
         136               0 :         publicId.EqualsLiteral("-//W3C//DTD HTML 4.0 Transitional//EN")) {
         137               0 :       rv = NS_NewHTMLDocument(getter_AddRefs(d));
         138               0 :       isHTML = true;
         139               0 :     } else if (publicId.EqualsLiteral("-//W3C//DTD XHTML 1.0 Strict//EN") ||
         140               0 :                publicId.EqualsLiteral("-//W3C//DTD XHTML 1.0 Transitional//EN") ||
         141               0 :                publicId.EqualsLiteral("-//W3C//DTD XHTML 1.0 Frameset//EN")) {
         142               0 :       rv = NS_NewHTMLDocument(getter_AddRefs(d));
         143               0 :       isHTML = true;
         144               0 :       isXHTML = true;
         145                 :     }
         146               0 :     else if (publicId.EqualsLiteral("-//W3C//DTD SVG 1.1//EN")) {
         147               0 :       rv = NS_NewSVGDocument(getter_AddRefs(d));
         148                 :     }
         149                 :     // XXX Add support for XUL documents.
         150                 :     else {
         151               0 :       rv = NS_NewXMLDocument(getter_AddRefs(d));
         152                 :     }
         153                 :   } else {
         154            1039 :     rv = NS_NewXMLDocument(getter_AddRefs(d));
         155                 :   }
         156                 :
         157            1273 :   if (NS_FAILED(rv)) {
         158               0 :     return rv;
         159                 :   }
         160                 :
         161            1273 :   d->SetScriptHandlingObject(aEventObject);
         162                 :
         163            1273 :   if (isHTML) {
         164             468 :     nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(d);
         165             234 :     NS_ASSERTION(htmlDoc, "HTML Document doesn't implement nsIHTMLDocument?");
         166             234 :     htmlDoc->SetCompatibilityMode(eCompatibility_FullStandards);
         167             234 :     htmlDoc->SetIsXHTML(isXHTML);
         168                 :   }
         169            1273 :   nsDocument* doc = static_cast<nsDocument*>(d.get());
         170            1273 :   doc->SetLoadedAsData(aLoadedAsData);
         171            1273 :   doc->nsDocument::SetDocumentURI(aDocumentURI);
         172                 :   // Must set the principal first, since SetBaseURI checks it.
         173            1273 :   doc->SetPrincipal(aPrincipal);
         174            1273 :   doc->SetBaseURI(aBaseURI);
         175                 :
         176                 :   // XMLDocuments and documents "created in memory" get to be UTF-8 by default,
         177                 :   // unlike the legacy HTML mess
         178            1273 :   doc->SetDocumentCharacterSet(NS_LITERAL_CSTRING("UTF-8"));
         179                 :
         180            1273 :   if (aDoctype) {
         181               0 :     nsCOMPtr<nsIDOMNode> tmpNode;
         182               0 :     rv = doc->AppendChild(aDoctype, getter_AddRefs(tmpNode));
         183               0 :     NS_ENSURE_SUCCESS(rv, rv);
         184                 :   }
         185                 :
         186            1273 :   if (!aQualifiedName.IsEmpty()) {
         187               2 :     nsCOMPtr<nsIDOMElement> root;
         188                 :     rv = doc->CreateElementNS(aNamespaceURI, aQualifiedName,
         189               1 :                               getter_AddRefs(root));
         190               1 :     NS_ENSURE_SUCCESS(rv, rv);
         191                 :
         192               2 :     nsCOMPtr<nsIDOMNode> tmpNode;
         193                 :
         194               1 :     rv = doc->AppendChild(root, getter_AddRefs(tmpNode));
         195               1 :     NS_ENSURE_SUCCESS(rv, rv);
         196                 :   }
         197                 :
         198            1273 :   *aInstancePtrResult = doc;
         199            1273 :   NS_ADDREF(*aInstancePtrResult);
         200                 :
         201            1273 :   return NS_OK;
         202                 : }
         203                 :
         204                 :
         205                 : nsresult
         206            1039 : NS_NewXMLDocument(nsIDocument** aInstancePtrResult)
         207                 : {
         208            1039 :   nsXMLDocument* doc = new nsXMLDocument();
         209            1039 :   NS_ENSURE_TRUE(doc, NS_ERROR_OUT_OF_MEMORY);
         210                 :
         211            1039 :   NS_ADDREF(doc);
         212            1039 :   nsresult rv = doc->Init();
         213                 :
         214            1039 :   if (NS_FAILED(rv)) {
         215               0 :     NS_RELEASE(doc);
         216                 :   }
         217                 :
         218            1039 :   *aInstancePtrResult = doc;
         219                 :
         220            1039 :   return rv;
         221                 : }
         222                 :
         223                 : nsresult
         224               0 : NS_NewXBLDocument(nsIDOMDocument** aInstancePtrResult,
         225                 :                   nsIURI* aDocumentURI,
         226                 :                   nsIURI* aBaseURI,
         227                 :                   nsIPrincipal* aPrincipal)
         228                 : {
         229                 :   nsresult rv = NS_NewDOMDocument(aInstancePtrResult,
         230               0 :                                   NS_LITERAL_STRING("http://www.mozilla.org/xbl"),
         231               0 :                                   NS_LITERAL_STRING("bindings"), nsnull,
         232                 :                                   aDocumentURI, aBaseURI, aPrincipal, false,
         233               0 :                                   nsnull, DocumentFlavorLegacyGuess);
         234               0 :   NS_ENSURE_SUCCESS(rv, rv);
         235                 :
         236               0 :   nsCOMPtr<nsIDocument> idoc = do_QueryInterface(*aInstancePtrResult);
         237               0 :   nsDocument* doc = static_cast<nsDocument*>(idoc.get());
         238               0 :   doc->SetLoadedAsInteractiveData(true);
         239               0 :   doc->SetReadyStateInternal(nsIDocument::READYSTATE_COMPLETE);
         240                 :
         241               0 :   return NS_OK;
         242                 : }
         243                 :
         244                 :   // NOTE! nsDocument::operator new() zeroes out all members, so don't
         245                 :   // bother initializing members to 0.
         246                 :
         247            1039 : nsXMLDocument::nsXMLDocument(const char* aContentType)
         248                 :   : nsDocument(aContentType),
         249            1039 :     mAsync(true)
         250                 : {
         251                 :
         252                 :   // NOTE! nsDocument::operator new() zeroes out all members, so don't
         253                 :   // bother initializing members to 0.
         254            1039 : }
         255                 :
         256            3111 : nsXMLDocument::~nsXMLDocument()
         257                 : {
         258                 :   // XXX We rather crash than hang
         259            1037 :   mLoopingForSyncLoad = false;
         260            2074 : }
         261                 :
         262             393 : DOMCI_NODE_DATA(XMLDocument, nsXMLDocument)
         263                 :
         264                 : // QueryInterface implementation for nsXMLDocument
         265          212308 : NS_INTERFACE_TABLE_HEAD(nsXMLDocument)
         266                 :   NS_DOCUMENT_INTERFACE_TABLE_BEGIN(nsXMLDocument)
         267                 :     NS_INTERFACE_TABLE_ENTRY(nsXMLDocument, nsIDOMXMLDocument)
         268          212308 :   NS_OFFSET_AND_INTERFACE_TABLE_END
         269          212266 :   NS_OFFSET_AND_INTERFACE_TABLE_TO_MAP_SEGUE
         270          149356 :   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(XMLDocument)
         271          148787 : NS_INTERFACE_MAP_END_INHERITING(nsDocument)
         272                 :
         273                 :
         274          160115 : NS_IMPL_ADDREF_INHERITED(nsXMLDocument, nsDocument)
         275          160111 : NS_IMPL_RELEASE_INHERITED(nsXMLDocument, nsDocument)
         276                 :
         277                 :
         278                 : nsresult
         279            1039 : nsXMLDocument::Init()
         280                 : {
         281            1039 :   nsresult rv = nsDocument::Init();
         282            1039 :   NS_ENSURE_SUCCESS(rv, rv);
         283                 :
         284            1039 :   return rv;
         285                 : }
         286                 :
         287                 : void
         288             469 : nsXMLDocument::Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup)
         289                 : {
         290             469 :   nsDocument::Reset(aChannel, aLoadGroup);
         291             469 : }
         292                 :
         293                 : void
         294             469 : nsXMLDocument::ResetToURI(nsIURI *aURI, nsILoadGroup *aLoadGroup,
         295                 :                           nsIPrincipal* aPrincipal)
         296                 : {
         297             469 :   if (mChannelIsPending) {
         298               0 :     StopDocumentLoad();
         299               0 :     mChannel->Cancel(NS_BINDING_ABORTED);
         300               0 :     mChannelIsPending = nsnull;
         301                 :   }
         302                 :
         303             469 :   nsDocument::ResetToURI(aURI, aLoadGroup, aPrincipal);
         304             469 : }
         305                 :
         306                 : NS_IMETHODIMP
         307               0 : nsXMLDocument::GetAsync(bool *aAsync)
         308                 : {
         309               0 :   NS_ENSURE_ARG_POINTER(aAsync);
         310               0 :   *aAsync = mAsync;
         311               0 :   return NS_OK;
         312                 : }
         313                 :
         314                 : NS_IMETHODIMP
         315               0 : nsXMLDocument::SetAsync(bool aAsync)
         316                 : {
         317               0 :   mAsync = aAsync;
         318               0 :   return NS_OK;
         319                 : }
         320                 :
         321                 : static void
         322               0 : ReportUseOfDeprecatedMethod(nsIDocument *aDoc, const char* aWarning)
         323                 : {
         324                 :   nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
         325                 :                                   "DOM3 Load", aDoc,
         326                 :                                   nsContentUtils::eDOM_PROPERTIES,
         327               0 :                                   aWarning);
         328               0 : }
         329                 :
         330                 : NS_IMETHODIMP
         331               0 : nsXMLDocument::Load(const nsAString& aUrl, bool *aReturn)
         332                 : {
         333               0 :   bool hasHadScriptObject = true;
         334                 :   nsIScriptGlobalObject* scriptObject =
         335               0 :     GetScriptHandlingObject(hasHadScriptObject);
         336               0 :   NS_ENSURE_STATE(scriptObject || !hasHadScriptObject);
         337                 :
         338               0 :   ReportUseOfDeprecatedMethod(this, "UseOfDOM3LoadMethodWarning");
         339                 :
         340               0 :   NS_ENSURE_ARG_POINTER(aReturn);
         341               0 :   *aReturn = false;
         342                 :
         343                 :   nsCOMPtr<nsIDocument> callingDoc =
         344               0 :     do_QueryInterface(nsContentUtils::GetDocumentFromContext());
         345                 :
         346               0 :   nsIURI *baseURI = mDocumentURI;
         347               0 :   nsCAutoString charset;
         348                 :
         349               0 :   if (callingDoc) {
         350               0 :     baseURI = callingDoc->GetDocBaseURI();
         351               0 :     charset = callingDoc->GetDocumentCharacterSet();
         352                 :   }
         353                 :
         354                 :   // Create a new URI
         355               0 :   nsCOMPtr<nsIURI> uri;
         356               0 :   nsresult rv = NS_NewURI(getter_AddRefs(uri), aUrl, charset.get(), baseURI);
         357               0 :   if (NS_FAILED(rv)) {
         358               0 :     return rv;
         359                 :   }
         360                 :
         361                 :   // Check to see whether the current document is allowed to load this URI.
         362                 :   // It's important to use the current document's principal for this check so
         363                 :   // that we don't end up in a case where code with elevated privileges is
         364                 :   // calling us and changing the principal of this document.
         365                 :
         366                 :   // Enforce same-origin even for chrome loaders to avoid someone accidentally
         367                 :   // using a document that content has a reference to and turn that into a
         368                 :   // chrome document.
         369               0 :   nsCOMPtr<nsIPrincipal> principal = NodePrincipal();
         370               0 :   if (!nsContentUtils::IsSystemPrincipal(principal)) {
         371               0 :     rv = principal->CheckMayLoad(uri, false);
         372               0 :     NS_ENSURE_SUCCESS(rv, rv);
         373                 :
         374               0 :     PRInt16 shouldLoad = nsIContentPolicy::ACCEPT;
         375                 :     rv = NS_CheckContentLoadPolicy(nsIContentPolicy::TYPE_XMLHTTPREQUEST,
         376                 :                                    uri,
         377                 :                                    principal,
         378                 :                                    callingDoc ? callingDoc.get() :
         379               0 :                                      static_cast<nsIDocument*>(this),
         380               0 :                                    NS_LITERAL_CSTRING("application/xml"),
         381                 :                                    nsnull,
         382                 :                                    &shouldLoad,
         383                 :                                    nsContentUtils::GetContentPolicy(),
         384               0 :                                    nsContentUtils::GetSecurityManager());
         385               0 :     NS_ENSURE_SUCCESS(rv, rv);
         386               0 :     if (NS_CP_REJECTED(shouldLoad)) {
         387               0 :       return NS_ERROR_CONTENT_BLOCKED;
         388                 :     }
         389                 :   } else {
         390                 :     // We're called from chrome, check to make sure the URI we're
         391                 :     // about to load is also chrome.
         392                 :
         393               0 :     bool isChrome = false;
         394               0 :     if (NS_FAILED(uri->SchemeIs("chrome", &isChrome)) || !isChrome) {
         395               0 :       nsCAutoString spec;
         396               0 :       if (mDocumentURI)
         397               0 :         mDocumentURI->GetSpec(spec);
         398                 :
         399               0 :       nsAutoString error;
         400                 :       error.AssignLiteral("Cross site loading using document.load is no "
         401               0 :                           "longer supported. Use XMLHttpRequest instead.");
         402                 :       nsCOMPtr<nsIScriptError> errorObject =
         403               0 :           do_CreateInstance(NS_SCRIPTERROR_CONTRACTID, &rv);
         404               0 :       NS_ENSURE_SUCCESS(rv, rv);
         405                 :
         406               0 :       rv = errorObject->InitWithWindowID(error.get(), NS_ConvertUTF8toUTF16(spec).get(),
         407                 :                                          nsnull, 0, 0, nsIScriptError::warningFlag,
         408                 :                                          "DOM",
         409                 :                                          callingDoc ?
         410               0 :                                            callingDoc->InnerWindowID() :
         411               0 :                                            this->InnerWindowID());
         412                 :
         413               0 :       NS_ENSURE_SUCCESS(rv, rv);
         414                 :
         415                 :       nsCOMPtr<nsIConsoleService> consoleService =
         416               0 :         do_GetService(NS_CONSOLESERVICE_CONTRACTID);
         417               0 :       if (consoleService) {
         418               0 :         consoleService->LogMessage(errorObject);
         419                 :       }
         420                 :
         421               0 :       return NS_ERROR_DOM_SECURITY_ERR;
         422                 :     }
         423                 :   }
         424                 :
         425                 :   // Partial Reset, need to restore principal for security reasons and
         426                 :   // event listener manager so that load listeners etc. will
         427                 :   // remain. This should be done before the security check is done to
         428                 :   // ensure that the document is reset even if the new document can't
         429                 :   // be loaded.  Note that we need to hold a strong ref to |principal|
         430                 :   // here, because ResetToURI will null out our node principal before
         431                 :   // setting the new one.
         432               0 :   nsRefPtr<nsEventListenerManager> elm(mListenerManager);
         433               0 :   mListenerManager = nsnull;
         434                 :
         435                 :   // When we are called from JS we can find the load group for the page,
         436                 :   // and add ourselves to it. This way any pending requests
         437                 :   // will be automatically aborted if the user leaves the page.
         438                 :
         439               0 :   nsCOMPtr<nsILoadGroup> loadGroup;
         440               0 :   if (callingDoc) {
         441               0 :     loadGroup = callingDoc->GetDocumentLoadGroup();
         442                 :   }
         443                 :
         444               0 :   ResetToURI(uri, loadGroup, principal);
         445                 :
         446               0 :   mListenerManager = elm;
         447                 :
         448                 :   // Create a channel
         449               0 :   nsCOMPtr<nsIInterfaceRequestor> req = nsContentUtils::GetSameOriginChecker();
         450               0 :   NS_ENSURE_TRUE(req, NS_ERROR_OUT_OF_MEMORY);
         451                 :
         452               0 :   nsCOMPtr<nsIChannel> channel;
         453                 :   // nsIRequest::LOAD_BACKGROUND prevents throbber from becoming active,
         454                 :   // which in turn keeps STOP button from becoming active
         455               0 :   rv = NS_NewChannel(getter_AddRefs(channel), uri, nsnull, loadGroup, req,
         456               0 :                      nsIRequest::LOAD_BACKGROUND);
         457               0 :   if (NS_FAILED(rv)) {
         458               0 :     return rv;
         459                 :   }
         460                 :
         461                 :   // Prepare for loading the XML document "into oneself"
         462               0 :   nsCOMPtr<nsIStreamListener> listener;
         463               0 :   if (NS_FAILED(rv = StartDocumentLoad(kLoadAsData, channel,
         464                 :                                        loadGroup, nsnull,
         465                 :                                        getter_AddRefs(listener),
         466                 :                                        false))) {
         467               0 :     NS_ERROR("nsXMLDocument::Load: Failed to start the document load.");
         468               0 :     return rv;
         469                 :   }
         470                 :
         471                 :   // After this point, if we error out of this method we should clear
         472                 :   // mChannelIsPending.
         473                 :
         474                 :   // Start an asynchronous read of the XML document
         475               0 :   rv = channel->AsyncOpen(listener, nsnull);
         476               0 :   if (NS_FAILED(rv)) {
         477               0 :     mChannelIsPending = false;
         478               0 :     return rv;
         479                 :   }
         480                 :
         481               0 :   if (!mAsync) {
         482               0 :     nsCOMPtr<nsIThread> thread = do_GetCurrentThread();
         483                 :
         484               0 :     mLoopingForSyncLoad = true;
         485               0 :     while (mLoopingForSyncLoad) {
         486               0 :       if (!NS_ProcessNextEvent(thread))
         487               0 :         break;
         488                 :     }
         489                 :
         490                 :     // We set return to true unless there was a parsing error
         491               0 :     nsCOMPtr<nsIDOMNode> node = do_QueryInterface(GetRootElement());
         492               0 :     if (node) {
         493               0 :       nsAutoString name, ns;
         494               0 :       if (NS_SUCCEEDED(node->GetLocalName(name)) &&
         495               0 :           name.EqualsLiteral("parsererror") &&
         496               0 :           NS_SUCCEEDED(node->GetNamespaceURI(ns)) &&
         497               0 :           ns.EqualsLiteral("http://www.mozilla.org/newlayout/xml/parsererror.xml")) {
         498                 :         //return is already false
         499                 :       } else {
         500               0 :         *aReturn = true;
         501                 :       }
         502                 :     }
         503                 :   } else {
         504               0 :     *aReturn = true;
         505                 :   }
         506                 :
         507               0 :   return NS_OK;
         508                 : }
         509                 :
         510                 : nsresult
         511            1038 : nsXMLDocument::StartDocumentLoad(const char* aCommand,
         512                 :                                  nsIChannel* aChannel,
         513                 :                                  nsILoadGroup* aLoadGroup,
         514                 :                                  nsISupports* aContainer,
         515                 :                                  nsIStreamListener **aDocListener,
         516                 :                                  bool aReset,
         517                 :                                  nsIContentSink* aSink)
         518                 : {
         519                 :   nsresult rv = nsDocument::StartDocumentLoad(aCommand,
         520                 :                                               aChannel, aLoadGroup,
         521                 :                                               aContainer,
         522            1038 :                                               aDocListener, aReset, aSink);
         523            1038 :   if (NS_FAILED(rv)) return rv;
         524                 :
         525            1038 :   if (nsCRT::strcmp("loadAsInteractiveData", aCommand) == 0) {
         526               0 :     mLoadedAsInteractiveData = true;
         527               0 :     aCommand = kLoadAsData; // XBL, for example, needs scripts and styles
         528                 :   }
         529                 :
         530                 :
         531            1038 :   PRInt32 charsetSource = kCharsetFromDocTypeDefault;
         532            2076 :   nsCAutoString charset(NS_LITERAL_CSTRING("UTF-8"));
         533            1038 :   TryChannelCharset(aChannel, charsetSource, charset);
         534                 :
         535            2076 :   nsCOMPtr<nsIURI> aUrl;
         536            1038 :   rv = aChannel->GetURI(getter_AddRefs(aUrl));
         537            1038 :   if (NS_FAILED(rv)) return rv;
         538                 :
         539                 :   static NS_DEFINE_CID(kCParserCID, NS_PARSER_CID);
         540                 :
         541            1038 :   mParser = do_CreateInstance(kCParserCID, &rv);
         542            1038 :   NS_ENSURE_SUCCESS(rv, rv);
         543                 :
         544            2076 :   nsCOMPtr<nsIXMLContentSink> sink;
         545                 :
         546            1038 :   if (aSink) {
         547               0 :     sink = do_QueryInterface(aSink);
         548                 :   }
         549                 :   else {
         550            2076 :     nsCOMPtr<nsIDocShell> docShell;
         551            1038 :     if (aContainer) {
         552               0 :       docShell = do_QueryInterface(aContainer);
         553               0 :       NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
         554                 :     }
         555            1038 :     rv = NS_NewXMLContentSink(getter_AddRefs(sink), this, aUrl, docShell,
         556            1038 :                               aChannel);
         557            1038 :     NS_ENSURE_SUCCESS(rv, rv);
         558                 :   }
         559                 :
         560                 :   // Set the parser as the stream listener for the document loader...
         561            1038 :   rv = CallQueryInterface(mParser, aDocListener);
         562            1038 :   NS_ENSURE_SUCCESS(rv, rv);
         563                 :
         564            1038 :   NS_ASSERTION(mChannel, "How can we not have a channel here?");
         565            1038 :   mChannelIsPending = true;
         566                 :
         567            1038 :   SetDocumentCharacterSet(charset);
         568            1038 :   mParser->SetDocumentCharset(charset, charsetSource);
         569            1038 :   mParser->SetCommand(aCommand);
         570            1038 :   mParser->SetContentSink(sink);
         571            1038 :   mParser->Parse(aUrl, nsnull, (void *)this);
         572                 :
         573            1038 :   return NS_OK;
         574                 : }
         575                 :
         576                 : void
         577            1038 : nsXMLDocument::EndLoad()
         578                 : {
         579            1038 :   mChannelIsPending = false;
         580            1038 :   mLoopingForSyncLoad = false;
         581                 :
         582            1038 :   mSynchronousDOMContentLoaded = (mLoadedAsData || mLoadedAsInteractiveData);
         583            1038 :   nsDocument::EndLoad();
         584            1038 :   if (mSynchronousDOMContentLoaded) {
         585            1038 :     mSynchronousDOMContentLoaded = false;
         586            1038 :     nsDocument::SetReadyStateInternal(nsIDocument::READYSTATE_COMPLETE);
         587                 :     // Generate a document load event for the case when an XML
         588                 :     // document was loaded as pure data without any presentation
         589                 :     // attached to it.
         590            2076 :     nsEvent event(true, NS_LOAD);
         591                 :     nsEventDispatcher::Dispatch(static_cast<nsIDocument*>(this), nsnull,
         592            1038 :                                 &event);
         593                 :   }
         594            1038 : }
         595                 :
         596                 : /* virtual */ void
         597               0 : nsXMLDocument::DocSizeOfExcludingThis(nsWindowSizes* aWindowSizes) const
         598                 : {
         599               0 :   nsDocument::DocSizeOfExcludingThis(aWindowSizes);
         600               0 : }
         601                 :
         602                 : // nsIDOMDocument interface
         603                 :
         604                 : nsresult
         605               0 : nsXMLDocument::Clone(nsINodeInfo *aNodeInfo, nsINode **aResult) const
         606                 : {
         607               0 :   NS_ASSERTION(aNodeInfo->NodeInfoManager() == mNodeInfoManager,
         608                 :                "Can't import this document into another document!");
         609                 :
         610               0 :   nsRefPtr<nsXMLDocument> clone = new nsXMLDocument();
         611               0 :   NS_ENSURE_TRUE(clone, NS_ERROR_OUT_OF_MEMORY);
         612               0 :   nsresult rv = CloneDocHelper(clone);
         613               0 :   NS_ENSURE_SUCCESS(rv, rv);
         614                 :
         615                 :   // State from nsXMLDocument
         616               0 :   clone->mAsync = mAsync;
         617                 :
         618               0 :   return CallQueryInterface(clone.get(), aResult);
         619                 : }

Generated by: LCOV version 1.7