wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
2c3e543d1d
gecko/layout/build/nsLayoutModule.cpp
Zack Weinberg 2c3e543d1d Bug 544112 part 2: DeCOMtaminate and devirtualize nsCSSLoader. r=bzbarsky sr=dbaron 
--HG--
rename : layout/style/nsICSSLoader.h => layout/style/nsCSSLoader.h
2010-03-02 13:00:53 -08:00

1518 lines
49 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla Communicator client code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Pierre Phaneuf <pp@ludusdesign.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsLayoutStatics.h"
#include "nsContentCID.h"
#include "nsContentDLF.h"
#include "nsContentPolicyUtils.h"
#include "nsDataDocumentContentPolicy.h"
#include "nsNoDataProtocolContentPolicy.h"
#include "nsDOMCID.h"
#include "nsHTMLContentSerializer.h"
#include "nsHTMLParts.h"
#include "nsGenericHTMLElement.h"
#include "nsICategoryManager.h"
#include "nsIComponentManager.h"
#include "nsIContentIterator.h"
#include "nsIContentSerializer.h"
#include "nsIController.h"
#include "nsIControllers.h"
#include "nsIDOMDOMImplementation.h"
#include "nsIDOMEventGroup.h"
#include "nsIDOMRange.h"
#include "nsIDocument.h"
#include "nsIDocumentEncoder.h"
#include "nsIDocumentViewer.h"
#include "nsIEventListenerManager.h"
#include "nsIFactory.h"
#include "nsFrameSelection.h"
#include "nsIFrameUtil.h"
#include "nsIGenericFactory.h"
#include "nsIFragmentContentSink.h"
#include "nsHTMLStyleSheet.h"
#include "nsIHTMLToTextSink.h"
#include "nsILayoutDebugger.h"
#include "nsINameSpaceManager.h"
#include "nsINodeInfo.h"
#include "nsIObserver.h"
#include "nsIObserverService.h"
#include "nsPresContext.h"
#include "nsIPresShell.h"
#include "nsIPrivateDOMImplementation.h"
#include "nsIRangeUtils.h"
#include "nsIScriptNameSpaceManager.h"
#include "nsISelection.h"
#include "nsIXBLService.h"
#include "nsCaret.h"
#include "nsPlainTextSerializer.h"
#include "mozSanitizingSerializer.h"
#include "nsXMLContentSerializer.h"
#include "nsXHTMLContentSerializer.h"
#include "nsRuleNode.h"
#include "nsWyciwygProtocolHandler.h"
#include "nsContentAreaDragDrop.h"
#include "nsContentList.h"
#include "nsSyncLoadService.h"
#include "nsBox.h"
#include "nsIFrameTraversal.h"
#include "nsLayoutCID.h"
#include "nsILanguageAtomService.h"
#include "nsStyleSheetService.h"
#include "nsXULPopupManager.h"
#include "nsFocusManager.h"
#include "nsIEventListenerService.h"
// Transformiix stuff
#include "nsXPathEvaluator.h"
#include "txMozillaXSLTProcessor.h"
#include "txNodeSetAdaptor.h"
#include "nsXPath1Scheme.h"
#include "nsDOMParser.h"
#include "nsDOMSerializer.h"
#include "nsXMLHttpRequest.h"
// view stuff
#include "nsViewsCID.h"
#include "nsViewManager.h"
#include "nsContentCreatorFunctions.h"
// DOM includes
#include "nsDOMException.h"
#include "nsDOMFileReader.h"
#include "nsFormData.h"
#include "nsGlobalWindowCommands.h"
#include "nsIControllerCommandTable.h"
#include "nsJSProtocolHandler.h"
#include "nsScriptNameSpaceManager.h"
#include "nsIControllerContext.h"
#include "nsDOMScriptObjectFactory.h"
#include "nsDOMStorage.h"
#include "nsJSON.h"
// Editor stuff
#include "nsEditorCID.h"
#include "nsEditor.h"
#include "nsPlaintextEditor.h"
#include "nsEditorController.h" //CID
#include "nsIController.h"
#include "nsIControllerContext.h"
#include "nsIControllerCommandTable.h"
#ifndef MOZILLA_PLAINTEXT_EDITOR_ONLY
#include "nsHTMLEditor.h"
#include "nsTextServicesDocument.h"
#include "nsTextServicesCID.h"
#endif
#define NS_EDITORCOMMANDTABLE_CID \
{ 0x4f5e62b8, 0xd659, 0x4156, { 0x84, 0xfc, 0x2f, 0x60, 0x99, 0x40, 0x03, 0x69 }}
static NS_DEFINE_CID(kEditorCommandTableCID, NS_EDITORCOMMANDTABLE_CID);
NS_GENERIC_FACTORY_CONSTRUCTOR(nsPlaintextEditor)
// Constructor of a controller which is set up to use, internally, a
// singleton command-table pre-filled with editor commands.
static NS_METHOD
nsEditorControllerConstructor(nsISupports *aOuter, REFNSIID aIID,
void **aResult)
{
nsresult rv;
nsCOMPtr<nsIController> controller = do_CreateInstance("@mozilla.org/embedcomp/base-command-controller;1", &rv);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIControllerCommandTable> editorCommandTable = do_GetService(kEditorCommandTableCID, &rv);
if (NS_FAILED(rv)) return rv;
// this guy is a singleton, so make it immutable
editorCommandTable->MakeImmutable();
nsCOMPtr<nsIControllerContext> controllerContext = do_QueryInterface(controller, &rv);
if (NS_FAILED(rv)) return rv;
rv = controllerContext->Init(editorCommandTable);
if (NS_FAILED(rv)) return rv;
return controller->QueryInterface(aIID, aResult);
}
// Constructor for a command-table pref-filled with editor commands
static NS_METHOD
nsEditorCommandTableConstructor(nsISupports *aOuter, REFNSIID aIID,
void **aResult)
{
nsresult rv;
nsCOMPtr<nsIControllerCommandTable> commandTable =
do_CreateInstance(NS_CONTROLLERCOMMANDTABLE_CONTRACTID, &rv);
if (NS_FAILED(rv)) return rv;
rv = nsEditorController::RegisterEditorCommands(commandTable);
if (NS_FAILED(rv)) return rv;
// we don't know here whether we're being created as an instance,
// or a service, so we can't become immutable
return commandTable->QueryInterface(aIID, aResult);
}
#ifndef MOZILLA_PLAINTEXT_EDITOR_ONLY
NS_GENERIC_FACTORY_CONSTRUCTOR(nsTextServicesDocument)
#ifdef ENABLE_EDITOR_API_LOG
#include "nsHTMLEditorLog.h"
NS_GENERIC_FACTORY_CONSTRUCTOR(nsHTMLEditorLog)
#else
NS_GENERIC_FACTORY_CONSTRUCTOR(nsHTMLEditor)
#endif
#endif
#include "nsHTMLCanvasFrame.h"
#include "nsIDOMCanvasRenderingContext2D.h"
#include "nsICanvasRenderingContextWebGL.h"
class nsIDocumentLoaderFactory;
#define PRODUCT_NAME "Gecko"
#define NS_HTMLIMGELEMENT_CONTRACTID \
"@mozilla.org/content/element/html;1?name=img"
#define NS_HTMLOPTIONELEMENT_CONTRACTID \
"@mozilla.org/content/element/html;1?name=option"
#ifdef MOZ_MEDIA
#define NS_HTMLAUDIOELEMENT_CONTRACTID \
"@mozilla.org/content/element/html;1?name=audio"
#endif
/* 0ddf4df8-4dbb-4133-8b79-9afb966514f5 */
#define NS_PLUGINDOCLOADERFACTORY_CID \
{ 0x0ddf4df8, 0x4dbb, 0x4133, { 0x8b, 0x79, 0x9a, 0xfb, 0x96, 0x65, 0x14, 0xf5 } }
#define NS_WINDOWCOMMANDTABLE_CID \
{ /* 0DE2FBFA-6B7F-11D7-BBBA-0003938A9D96 */ \
0x0DE2FBFA, 0x6B7F, 0x11D7, {0xBB, 0xBA, 0x00, 0x03, 0x93, 0x8A, 0x9D, 0x96} }
static NS_DEFINE_CID(kWindowCommandTableCID, NS_WINDOWCOMMANDTABLE_CID);
#include "nsIBoxObject.h"
#ifndef MOZ_NO_INSPECTOR_APIS
#ifdef MOZ_XUL
#include "inDOMView.h"
#endif /* MOZ_XUL */
#include "inDeepTreeWalker.h"
#include "inFlasher.h"
#include "inCSSValueSearch.h"
#include "inDOMUtils.h"
#endif /* MOZ_NO_INSPECTOR_APIS */
#ifdef MOZ_XUL
#include "nsIXULDocument.h"
#include "nsIXULPrototypeCache.h"
#include "nsIXULSortService.h"
NS_IMETHODIMP
NS_NewXULContentBuilder(nsISupports* aOuter, REFNSIID aIID, void** aResult);
NS_IMETHODIMP
NS_NewXULTreeBuilder(nsISupports* aOuter, REFNSIID aIID, void** aResult);
#endif
static nsresult Initialize(nsIModule* aSelf);
static void Shutdown();
#ifdef MOZ_XTF
#include "nsIXTFService.h"
#include "nsIXMLContentBuilder.h"
#endif
#include "nsGeolocation.h"
#include "nsCSPService.h"
// Transformiix
/* {0C351177-0159-4500-86B0-A219DFDE4258} */
#define TRANSFORMIIX_XPATH1_SCHEME_CID \
{ 0xc351177, 0x159, 0x4500, { 0x86, 0xb0, 0xa2, 0x19, 0xdf, 0xde, 0x42, 0x58 } }
/* 5d5d92cd-6bf8-11d9-bf4a-000a95dc234c */
#define TRANSFORMIIX_NODESET_CID \
{ 0x5d5d92cd, 0x6bf8, 0x11d9, { 0xbf, 0x4a, 0x0, 0x0a, 0x95, 0xdc, 0x23, 0x4c } }
#define TRANSFORMIIX_NODESET_CONTRACTID \
"@mozilla.org/transformiix-nodeset;1"
NS_GENERIC_FACTORY_CONSTRUCTOR(nsXPath1SchemeProcessor)
// Factory Constructor
NS_GENERIC_FACTORY_CONSTRUCTOR(txMozillaXSLTProcessor)
NS_GENERIC_AGGREGATED_CONSTRUCTOR_INIT(nsXPathEvaluator, Init)
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(txNodeSetAdaptor, Init)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsDOMSerializer)
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsXMLHttpRequest, Init)
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsDOMFileReader, Init)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsFormData)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsDOMParser)
NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsDOMStorageManager,
nsDOMStorageManager::GetInstance)
//-----------------------------------------------------------------------------
// Per bug 209804, it is necessary to observe the "xpcom-shutdown" event and
// perform shutdown of the layout modules at that time instead of waiting for
// our module destructor to run. If we do not do this, then we risk holding
// references to objects in other component libraries that have already been
// shutdown (and possibly unloaded if 60709 is ever fixed).
class LayoutShutdownObserver : public nsIObserver
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER
};
NS_IMPL_ISUPPORTS1(LayoutShutdownObserver, nsIObserver)
NS_IMETHODIMP
LayoutShutdownObserver::Observe(nsISupports *aSubject,
const char *aTopic,
const PRUnichar *someData)
{
if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID))
Shutdown();
return NS_OK;
}
//-----------------------------------------------------------------------------
static PRBool gInitialized = PR_FALSE;
// Perform our one-time intialization for this module
// static
nsresult
Initialize(nsIModule* aSelf)
{
NS_PRECONDITION(!gInitialized, "module already initialized");
if (gInitialized) {
return NS_OK;
}
NS_ASSERTION(sizeof(PtrBits) == sizeof(void *),
"Eeek! You'll need to adjust the size of PtrBits to the size "
"of a pointer on your platform.");
gInitialized = PR_TRUE;
nsresult rv = nsLayoutStatics::Initialize();
if (NS_FAILED(rv)) {
Shutdown();
return rv;
}
// Add our shutdown observer.
nsCOMPtr<nsIObserverService> observerService =
do_GetService("@mozilla.org/observer-service;1");
if (observerService) {
LayoutShutdownObserver* observer = new LayoutShutdownObserver();
if (!observer) {
Shutdown();
return NS_ERROR_OUT_OF_MEMORY;
}
observerService->AddObserver(observer, NS_XPCOM_SHUTDOWN_OBSERVER_ID, PR_FALSE);
} else {
NS_WARNING("Could not get an observer service. We will leak on shutdown.");
}
return NS_OK;
}
// Shutdown this module, releasing all of the module resources
// static
void
Shutdown()
{
NS_PRECONDITION(gInitialized, "module not initialized");
if (!gInitialized)
return;
gInitialized = PR_FALSE;
nsLayoutStatics::Release();
}
#ifdef NS_DEBUG
nsresult NS_NewFrameUtil(nsIFrameUtil** aResult);
nsresult NS_NewLayoutDebugger(nsILayoutDebugger** aResult);
#endif
nsresult NS_NewBoxObject(nsIBoxObject** aResult);
#ifdef MOZ_XUL
nsresult NS_NewListBoxObject(nsIBoxObject** aResult);
nsresult NS_NewScrollBoxObject(nsIBoxObject** aResult);
nsresult NS_NewMenuBoxObject(nsIBoxObject** aResult);
nsresult NS_NewPopupBoxObject(nsIBoxObject** aResult);
nsresult NS_NewContainerBoxObject(nsIBoxObject** aResult);
nsresult NS_NewTreeBoxObject(nsIBoxObject** aResult);
#endif
nsresult NS_NewCanvasRenderingContext2D(nsIDOMCanvasRenderingContext2D** aResult);
nsresult NS_NewCanvasRenderingContextWebGL(nsICanvasRenderingContextWebGL** aResult);
nsresult NS_CreateFrameTraversal(nsIFrameTraversal** aResult);
nsresult NS_NewSelection(nsFrameSelection** aResult);
nsresult NS_NewDomSelection(nsISelection** aResult);
nsresult NS_NewDocumentViewer(nsIDocumentViewer** aResult);
nsresult NS_NewRange(nsIDOMRange** aResult);
nsresult NS_NewRangeUtils(nsIRangeUtils** aResult);
nsresult NS_NewContentIterator(nsIContentIterator** aResult);
nsresult NS_NewPreContentIterator(nsIContentIterator** aResult);
nsresult NS_NewGenRegularIterator(nsIContentIterator** aResult);
nsresult NS_NewContentSubtreeIterator(nsIContentIterator** aResult);
nsresult NS_NewGenSubtreeIterator(nsIContentIterator** aInstancePtrResult);
nsresult NS_NewContentDocumentLoaderFactory(nsIDocumentLoaderFactory** aResult);
nsresult NS_NewHTMLCopyTextEncoder(nsIDocumentEncoder** aResult);
nsresult NS_NewTextEncoder(nsIDocumentEncoder** aResult);
nsresult NS_NewXBLService(nsIXBLService** aResult);
nsresult NS_NewContentPolicy(nsIContentPolicy** aResult);
nsresult NS_NewDOMEventGroup(nsIDOMEventGroup** aResult);
nsresult NS_NewEventListenerService(nsIEventListenerService** aResult);
NS_IMETHODIMP NS_NewXULControllers(nsISupports* aOuter, REFNSIID aIID, void** aResult);
#define MAKE_CTOR(ctor_, iface_, func_) \
static NS_IMETHODIMP \
ctor_(nsISupports* aOuter, REFNSIID aIID, void** aResult) \
{ \
*aResult = nsnull; \
if (aOuter) \
return NS_ERROR_NO_AGGREGATION; \
iface_* inst; \
nsresult rv = func_(&inst); \
if (NS_SUCCEEDED(rv)) { \
rv = inst->QueryInterface(aIID, aResult); \
NS_RELEASE(inst); \
} \
return rv; \
}
#ifdef DEBUG
MAKE_CTOR(CreateNewFrameUtil, nsIFrameUtil, NS_NewFrameUtil)
MAKE_CTOR(CreateNewLayoutDebugger, nsILayoutDebugger, NS_NewLayoutDebugger)
#endif
MAKE_CTOR(CreateNewFrameTraversal, nsIFrameTraversal, NS_CreateFrameTraversal)
MAKE_CTOR(CreateNewPresShell, nsIPresShell, NS_NewPresShell)
MAKE_CTOR(CreateNewBoxObject, nsIBoxObject, NS_NewBoxObject)
#ifdef MOZ_XUL
MAKE_CTOR(CreateNewListBoxObject, nsIBoxObject, NS_NewListBoxObject)
MAKE_CTOR(CreateNewMenuBoxObject, nsIBoxObject, NS_NewMenuBoxObject)
MAKE_CTOR(CreateNewPopupBoxObject, nsIBoxObject, NS_NewPopupBoxObject)
MAKE_CTOR(CreateNewScrollBoxObject, nsIBoxObject, NS_NewScrollBoxObject)
MAKE_CTOR(CreateNewTreeBoxObject, nsIBoxObject, NS_NewTreeBoxObject)
MAKE_CTOR(CreateNewContainerBoxObject, nsIBoxObject, NS_NewContainerBoxObject)
#endif // MOZ_XUL
#ifndef MOZ_NO_INSPECTOR_APIS
#ifdef MOZ_XUL
NS_GENERIC_FACTORY_CONSTRUCTOR(inDOMView)
#endif
NS_GENERIC_FACTORY_CONSTRUCTOR(inDeepTreeWalker)
NS_GENERIC_FACTORY_CONSTRUCTOR(inFlasher)
NS_GENERIC_FACTORY_CONSTRUCTOR(inCSSValueSearch)
NS_GENERIC_FACTORY_CONSTRUCTOR(inDOMUtils)
#endif
MAKE_CTOR(CreateNameSpaceManager, nsINameSpaceManager, NS_GetNameSpaceManager)
MAKE_CTOR(CreateEventListenerManager, nsIEventListenerManager, NS_NewEventListenerManager)
MAKE_CTOR(CreateDOMEventGroup, nsIDOMEventGroup, NS_NewDOMEventGroup)
MAKE_CTOR(CreateDocumentViewer, nsIDocumentViewer, NS_NewDocumentViewer)
MAKE_CTOR(CreateHTMLDocument, nsIDocument, NS_NewHTMLDocument)
MAKE_CTOR(CreateDOMImplementation, nsIDOMDOMImplementation, NS_NewDOMImplementation)
MAKE_CTOR(CreateXMLDocument, nsIDocument, NS_NewXMLDocument)
#ifdef MOZ_SVG
MAKE_CTOR(CreateSVGDocument, nsIDocument, NS_NewSVGDocument)
#endif
MAKE_CTOR(CreateImageDocument, nsIDocument, NS_NewImageDocument)
MAKE_CTOR(CreateDOMSelection, nsISelection, NS_NewDomSelection)
MAKE_CTOR(CreateSelection, nsFrameSelection, NS_NewSelection)
MAKE_CTOR(CreateRange, nsIDOMRange, NS_NewRange)
MAKE_CTOR(CreateRangeUtils, nsIRangeUtils, NS_NewRangeUtils)
MAKE_CTOR(CreateContentIterator, nsIContentIterator, NS_NewContentIterator)
MAKE_CTOR(CreatePreContentIterator, nsIContentIterator, NS_NewPreContentIterator)
MAKE_CTOR(CreateSubtreeIterator, nsIContentIterator, NS_NewContentSubtreeIterator)
// CreateHTMLImgElement, see below
// CreateHTMLOptionElement, see below
// CreateHTMLAudioElement, see below
MAKE_CTOR(CreateTextEncoder, nsIDocumentEncoder, NS_NewTextEncoder)
MAKE_CTOR(CreateHTMLCopyTextEncoder, nsIDocumentEncoder, NS_NewHTMLCopyTextEncoder)
MAKE_CTOR(CreateXMLContentSerializer, nsIContentSerializer, NS_NewXMLContentSerializer)
MAKE_CTOR(CreateHTMLContentSerializer, nsIContentSerializer, NS_NewHTMLContentSerializer)
MAKE_CTOR(CreateXHTMLContentSerializer, nsIContentSerializer, NS_NewXHTMLContentSerializer)
MAKE_CTOR(CreatePlainTextSerializer, nsIContentSerializer, NS_NewPlainTextSerializer)
MAKE_CTOR(CreateHTMLFragmentSink, nsIFragmentContentSink, NS_NewHTMLFragmentContentSink)
MAKE_CTOR(CreateHTMLFragmentSink2, nsIFragmentContentSink, NS_NewHTMLFragmentContentSink2)
MAKE_CTOR(CreateHTMLParanoidFragmentSink, nsIFragmentContentSink, NS_NewHTMLParanoidFragmentSink)
MAKE_CTOR(CreateXMLFragmentSink, nsIFragmentContentSink, NS_NewXMLFragmentContentSink)
MAKE_CTOR(CreateXMLFragmentSink2, nsIFragmentContentSink, NS_NewXMLFragmentContentSink2)
MAKE_CTOR(CreateXHTMLParanoidFragmentSink,nsIFragmentContentSink, NS_NewXHTMLParanoidFragmentSink)
MAKE_CTOR(CreateSanitizingHTMLSerializer, nsIContentSerializer, NS_NewSanitizingHTMLSerializer)
MAKE_CTOR(CreateXBLService, nsIXBLService, NS_NewXBLService)
MAKE_CTOR(CreateContentPolicy, nsIContentPolicy, NS_NewContentPolicy)
#ifdef MOZ_XUL
MAKE_CTOR(CreateXULSortService, nsIXULSortService, NS_NewXULSortService)
// NS_NewXULContentBuilder
// NS_NewXULTreeBuilder
MAKE_CTOR(CreateXULDocument, nsIXULDocument, NS_NewXULDocument)
// NS_NewXULControllers
// NS_NewXULPrototypeCache
MAKE_CTOR(CreateXULPopupManager, nsISupports, NS_NewXULPopupManager)
#endif
#ifdef MOZ_XTF
MAKE_CTOR(CreateXTFService, nsIXTFService, NS_NewXTFService)
MAKE_CTOR(CreateXMLContentBuilder, nsIXMLContentBuilder, NS_NewXMLContentBuilder)
#endif
MAKE_CTOR(CreateContentDLF, nsIDocumentLoaderFactory, NS_NewContentDocumentLoaderFactory)
MAKE_CTOR(CreateEventListenerService, nsIEventListenerService, NS_NewEventListenerService)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsWyciwygProtocolHandler)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsContentAreaDragDrop)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsDataDocumentContentPolicy)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsNoDataProtocolContentPolicy)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsSyncLoadService)
MAKE_CTOR(CreatePluginDocument, nsIDocument, NS_NewPluginDocument)
#ifdef MOZ_MEDIA
MAKE_CTOR(CreateVideoDocument, nsIDocument, NS_NewVideoDocument)
#endif
MAKE_CTOR(CreateFocusManager, nsIFocusManager, NS_NewFocusManager)
MAKE_CTOR(CreateCanvasRenderingContext2D, nsIDOMCanvasRenderingContext2D, NS_NewCanvasRenderingContext2D)
MAKE_CTOR(CreateCanvasRenderingContextWebGL, nsICanvasRenderingContextWebGL, NS_NewCanvasRenderingContextWebGL)
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsStyleSheetService, Init)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsJSURI)
// views are not refcounted, so this is the same as
// NS_GENERIC_FACTORY_CONSTRUCTOR without the NS_ADDREF/NS_RELEASE
#define NS_GENERIC_FACTORY_CONSTRUCTOR_NOREFS(_InstanceClass) \
static NS_IMETHODIMP \
_InstanceClass##Constructor(nsISupports *aOuter, REFNSIID aIID, \
void **aResult) \
{ \
nsresult rv; \
\
_InstanceClass * inst; \
\
*aResult = NULL; \
if (NULL != aOuter) { \
rv = NS_ERROR_NO_AGGREGATION; \
return rv; \
} \
\
NS_NEWXPCOM(inst, _InstanceClass); \
if (NULL == inst) { \
rv = NS_ERROR_OUT_OF_MEMORY; \
return rv; \
} \
rv = inst->QueryInterface(aIID, aResult); \
\
return rv; \
} \
NS_GENERIC_FACTORY_CONSTRUCTOR(nsViewManager)
static NS_IMETHODIMP
CreateHTMLImgElement(nsISupports* aOuter, REFNSIID aIID, void** aResult)
{
*aResult = nsnull;
if (aOuter)
return NS_ERROR_NO_AGGREGATION;
// Note! NS_NewHTMLImageElement is special cased to handle a null nodeinfo
nsIContent* inst = NS_NewHTMLImageElement(nsnull);
nsresult rv = NS_ERROR_OUT_OF_MEMORY;
if (inst) {
NS_ADDREF(inst);
rv = inst->QueryInterface(aIID, aResult);
NS_RELEASE(inst);
}
return rv;
}
static NS_IMETHODIMP
RegisterHTMLImgElement(nsIComponentManager *aCompMgr,
nsIFile* aPath,
const char* aRegistryLocation,
const char* aComponentType,
const nsModuleComponentInfo* aInfo)
{
nsCOMPtr<nsICategoryManager> catman =
do_GetService(NS_CATEGORYMANAGER_CONTRACTID);
if (!catman)
return NS_ERROR_FAILURE;
nsXPIDLCString previous;
nsresult rv = catman->AddCategoryEntry(JAVASCRIPT_GLOBAL_CONSTRUCTOR_CATEGORY,
"Image", NS_HTMLIMGELEMENT_CONTRACTID,
PR_TRUE, PR_TRUE, getter_Copies(previous));
NS_ENSURE_SUCCESS(rv, rv);
return catman->AddCategoryEntry(JAVASCRIPT_GLOBAL_CONSTRUCTOR_PROTO_ALIAS_CATEGORY,
"Image", "HTMLImageElement",
PR_TRUE, PR_TRUE, getter_Copies(previous));
}
static NS_IMETHODIMP
UnregisterHTMLImgElement(nsIComponentManager* aCompMgr,
nsIFile* aPath,
const char* aRegistryLocation,
const nsModuleComponentInfo* aInfo)
{
// XXX remove category entry
return NS_OK;
}
static NS_IMETHODIMP
CreateHTMLOptionElement(nsISupports* aOuter, REFNSIID aIID, void** aResult)
{
*aResult = nsnull;
if (aOuter)
return NS_ERROR_NO_AGGREGATION;
// Note! NS_NewHTMLOptionElement is special cased to handle a null nodeinfo
nsIContent* inst = NS_NewHTMLOptionElement(nsnull);
nsresult rv = NS_ERROR_OUT_OF_MEMORY;
if (inst) {
NS_ADDREF(inst);
rv = inst->QueryInterface(aIID, aResult);
NS_RELEASE(inst);
}
return rv;
}
static NS_IMETHODIMP
RegisterHTMLOptionElement(nsIComponentManager *aCompMgr,
nsIFile* aPath,
const char* aRegistryLocation,
const char* aComponentType,
const nsModuleComponentInfo* aInfo)
{
nsCOMPtr<nsICategoryManager> catman =
do_GetService(NS_CATEGORYMANAGER_CONTRACTID);
if (!catman)
return NS_ERROR_FAILURE;
nsXPIDLCString previous;
nsresult rv = catman->AddCategoryEntry(JAVASCRIPT_GLOBAL_CONSTRUCTOR_CATEGORY,
"Option", NS_HTMLOPTIONELEMENT_CONTRACTID,
PR_TRUE, PR_TRUE, getter_Copies(previous));
NS_ENSURE_SUCCESS(rv, rv);
return catman->AddCategoryEntry(JAVASCRIPT_GLOBAL_CONSTRUCTOR_PROTO_ALIAS_CATEGORY,
"Option", "HTMLOptionElement",
PR_TRUE, PR_TRUE, getter_Copies(previous));
}
static NS_IMETHODIMP
UnregisterHTMLOptionElement(nsIComponentManager* aCompMgr,
nsIFile* aPath,
const char* aRegistryLocation,
const nsModuleComponentInfo* aInfo)
{
// XXX remove category entry
return NS_OK;
}
#ifdef MOZ_MEDIA
static NS_IMETHODIMP
CreateHTMLAudioElement(nsISupports* aOuter, REFNSIID aIID, void** aResult)
{
*aResult = nsnull;
if (aOuter)
return NS_ERROR_NO_AGGREGATION;
// Note! NS_NewHTMLAudioElement is special cased to handle a null nodeinfo
nsCOMPtr<nsIContent> inst(NS_NewHTMLAudioElement(nsnull));
return inst ? inst->QueryInterface(aIID, aResult) : NS_ERROR_OUT_OF_MEMORY;
}
static NS_IMETHODIMP
RegisterHTMLAudioElement(nsIComponentManager *aCompMgr,
nsIFile* aPath,
const char* aRegistryLocation,
const char* aComponentType,
const nsModuleComponentInfo* aInfo)
{
nsCOMPtr<nsICategoryManager> catman =
do_GetService(NS_CATEGORYMANAGER_CONTRACTID);
if (!catman)
return NS_ERROR_FAILURE;
nsXPIDLCString previous;
nsresult rv = catman->AddCategoryEntry(JAVASCRIPT_GLOBAL_CONSTRUCTOR_CATEGORY,
"Audio", NS_HTMLAUDIOELEMENT_CONTRACTID,
PR_TRUE, PR_TRUE, getter_Copies(previous));
NS_ENSURE_SUCCESS(rv, rv);
return catman->AddCategoryEntry(JAVASCRIPT_GLOBAL_CONSTRUCTOR_PROTO_ALIAS_CATEGORY,
"Audio", "HTMLAudioElement",
PR_TRUE, PR_TRUE, getter_Copies(previous));
}
static NS_IMETHODIMP
UnregisterHTMLAudioElement(nsIComponentManager* aCompMgr,
nsIFile* aPath,
const char* aRegistryLocation,
const nsModuleComponentInfo* aInfo)
{
// XXX remove category entry
return NS_OK;
}
#endif
static NS_METHOD
RegisterDataDocumentContentPolicy(nsIComponentManager *aCompMgr,
nsIFile* aPath,
const char* aRegistryLocation,
const char* aComponentType,
const nsModuleComponentInfo* aInfo)
{
nsresult rv;
nsCOMPtr<nsICategoryManager> catman =
do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
if (NS_FAILED(rv)) {
return rv;
}
nsXPIDLCString previous;
return catman->AddCategoryEntry("content-policy",
NS_DATADOCUMENTCONTENTPOLICY_CONTRACTID,
NS_DATADOCUMENTCONTENTPOLICY_CONTRACTID,
PR_TRUE, PR_TRUE, getter_Copies(previous));
}
static NS_METHOD
UnregisterDataDocumentContentPolicy(nsIComponentManager *aCompMgr,
nsIFile *aPath,
const char *registryLocation,
const nsModuleComponentInfo *info)
{
nsresult rv;
nsCOMPtr<nsICategoryManager> catman =
do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
if (NS_FAILED(rv)) {
return rv;
}
return catman->DeleteCategoryEntry("content-policy",
NS_DATADOCUMENTCONTENTPOLICY_CONTRACTID,
PR_TRUE);
}
static NS_METHOD
RegisterNoDataProtocolContentPolicy(nsIComponentManager *aCompMgr,
nsIFile* aPath,
const char* aRegistryLocation,
const char* aComponentType,
const nsModuleComponentInfo* aInfo)
{
nsresult rv;
nsCOMPtr<nsICategoryManager> catman =
do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
if (NS_FAILED(rv)) {
return rv;
}
nsXPIDLCString previous;
return catman->AddCategoryEntry("content-policy",
NS_NODATAPROTOCOLCONTENTPOLICY_CONTRACTID,
NS_NODATAPROTOCOLCONTENTPOLICY_CONTRACTID,
PR_TRUE, PR_TRUE, getter_Copies(previous));
}
static NS_METHOD
UnregisterNoDataProtocolContentPolicy(nsIComponentManager *aCompMgr,
nsIFile *aPath,
const char *registryLocation,
const nsModuleComponentInfo *info)
{
nsresult rv;
nsCOMPtr<nsICategoryManager> catman =
do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
if (NS_FAILED(rv)) {
return rv;
}
return catman->DeleteCategoryEntry("content-policy",
NS_NODATAPROTOCOLCONTENTPOLICY_CONTRACTID,
PR_TRUE);
}
static NS_METHOD
CreateWindowCommandTableConstructor(nsISupports *aOuter,
REFNSIID aIID, void **aResult)
{
nsresult rv;
nsCOMPtr<nsIControllerCommandTable> commandTable =
do_CreateInstance(NS_CONTROLLERCOMMANDTABLE_CONTRACTID, &rv);
if (NS_FAILED(rv)) return rv;
rv = nsWindowCommandRegistration::RegisterWindowCommands(commandTable);
if (NS_FAILED(rv)) return rv;
return commandTable->QueryInterface(aIID, aResult);
}
static NS_METHOD
CreateWindowControllerWithSingletonCommandTable(nsISupports *aOuter,
REFNSIID aIID, void **aResult)
{
nsresult rv;
nsCOMPtr<nsIController> controller =
do_CreateInstance("@mozilla.org/embedcomp/base-command-controller;1", &rv);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIControllerCommandTable> windowCommandTable = do_GetService(kWindowCommandTableCID, &rv);
if (NS_FAILED(rv)) return rv;
// this is a singleton; make it immutable
windowCommandTable->MakeImmutable();
nsCOMPtr<nsIControllerContext> controllerContext = do_QueryInterface(controller, &rv);
if (NS_FAILED(rv)) return rv;
controllerContext->Init(windowCommandTable);
if (NS_FAILED(rv)) return rv;
return controller->QueryInterface(aIID, aResult);
}
NS_GENERIC_FACTORY_CONSTRUCTOR(nsDOMScriptObjectFactory)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsBaseDOMException)
#define NS_GEOLOCATION_CID \
{ 0x1E1C3FF, 0x94A, 0xD048, { 0x44, 0xB4, 0x62, 0xD2, 0x9C, 0x7B, 0x4F, 0x39 } }
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsGeolocation, Init)
#define NS_GEOLOCATION_SERVICE_CID \
{ 0x404d02a, 0x1CA, 0xAAAB, { 0x47, 0x62, 0x94, 0x4b, 0x1b, 0xf2, 0xf7, 0xb5 } }
NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsGeolocationService, nsGeolocationService::GetGeolocationService)
static NS_METHOD
CSPServiceRegistration(nsIComponentManager *aCompMgr,
nsIFile *aPath,
const char *registryLocation,
const char *componentType,
const nsModuleComponentInfo *info)
{
nsresult rv;
nsCOMPtr<nsIServiceManager> servman = do_QueryInterface((nsISupports*)aCompMgr, &rv);
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsICategoryManager> catman;
rv = servman->GetServiceByContractID(NS_CATEGORYMANAGER_CONTRACTID,
NS_GET_IID(nsICategoryManager),
getter_AddRefs(catman));
if (NS_FAILED(rv))
return rv;
nsXPIDLCString previous;
rv = catman->AddCategoryEntry("content-policy",
"CSPService",
CSPSERVICE_CONTRACTID,
PR_TRUE,
PR_TRUE,
getter_Copies(previous));
return rv;
}
static NS_METHOD
CSPServiceUnregistration(nsIComponentManager *aCompMgr,
nsIFile *aPath,
const char *registryLocation,
const nsModuleComponentInfo *info){
nsresult rv;
nsCOMPtr<nsIServiceManager> servman = do_QueryInterface((nsISupports*)aCompMgr, &rv);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsICategoryManager> catman;
rv = servman->GetServiceByContractID(NS_CATEGORYMANAGER_CONTRACTID,
NS_GET_IID(nsICategoryManager),
getter_AddRefs(catman));
if (NS_FAILED(rv)) return rv;
rv = catman->DeleteCategoryEntry("content-policy",
"CSPService",
PR_TRUE);
return rv;
}
NS_GENERIC_FACTORY_CONSTRUCTOR(CSPService)
// The list of components we register
static const nsModuleComponentInfo gComponents[] = {
#ifdef DEBUG
{ "Frame utility",
NS_FRAME_UTIL_CID,
nsnull,
CreateNewFrameUtil },
{ "Layout debugger",
NS_LAYOUT_DEBUGGER_CID,
nsnull,
CreateNewLayoutDebugger },
#endif
{ "Frame Traversal",
NS_FRAMETRAVERSAL_CID,
nsnull,
CreateNewFrameTraversal },
// XXX ick
{ "Presentation shell",
NS_PRESSHELL_CID,
nsnull,
CreateNewPresShell },
// XXX end ick
{ "Box Object",
NS_BOXOBJECT_CID,
"@mozilla.org/layout/xul-boxobject;1",
CreateNewBoxObject },
#ifdef MOZ_XUL
{ "XUL Listbox Box Object",
NS_LISTBOXOBJECT_CID,
"@mozilla.org/layout/xul-boxobject-listbox;1",
CreateNewListBoxObject },
{ "XUL Menu Box Object",
NS_MENUBOXOBJECT_CID,
"@mozilla.org/layout/xul-boxobject-menu;1",
CreateNewMenuBoxObject },
{ "XUL Popup Box Object",
NS_POPUPBOXOBJECT_CID,
"@mozilla.org/layout/xul-boxobject-popup;1",
CreateNewPopupBoxObject },
{ "Container Box Object",
NS_CONTAINERBOXOBJECT_CID,
"@mozilla.org/layout/xul-boxobject-container;1",
CreateNewContainerBoxObject },
{ "XUL ScrollBox Object",
NS_SCROLLBOXOBJECT_CID,
"@mozilla.org/layout/xul-boxobject-scrollbox;1",
CreateNewScrollBoxObject },
{ "XUL Tree Box Object",
NS_TREEBOXOBJECT_CID,
"@mozilla.org/layout/xul-boxobject-tree;1",
CreateNewTreeBoxObject },
#endif // MOZ_XUL
#ifndef MOZ_NO_INSPECTOR_APIS
#ifdef MOZ_XUL
{ "DOM View",
IN_DOMVIEW_CID,
"@mozilla.org/inspector/dom-view;1",
inDOMViewConstructor },
#endif
{ "Deep Tree Walker",
IN_DEEPTREEWALKER_CID,
"@mozilla.org/inspector/deep-tree-walker;1",
inDeepTreeWalkerConstructor },
{ "Flasher",
IN_FLASHER_CID,
"@mozilla.org/inspector/flasher;1",
inFlasherConstructor },
{ "CSS Value Search",
IN_CSSVALUESEARCH_CID,
"@mozilla.org/inspector/search;1?type=cssvalue",
inCSSValueSearchConstructor },
{ "DOM Utils",
IN_DOMUTILS_CID,
"@mozilla.org/inspector/dom-utils;1",
inDOMUtilsConstructor },
#endif // MOZ_NO_INSPECTOR_APIS
{ "Namespace manager",
NS_NAMESPACEMANAGER_CID,
NS_NAMESPACEMANAGER_CONTRACTID,
CreateNameSpaceManager },
{ "Event listener manager",
NS_EVENTLISTENERMANAGER_CID,
nsnull,
CreateEventListenerManager },
{ "DOM Event group",
NS_DOMEVENTGROUP_CID,
nsnull,
CreateDOMEventGroup },
{ "Document Viewer",
NS_DOCUMENT_VIEWER_CID,
nsnull,
CreateDocumentViewer },
{ "HTML document",
NS_HTMLDOCUMENT_CID,
nsnull,
CreateHTMLDocument },
{ "DOM implementation",
NS_DOM_IMPLEMENTATION_CID,
nsnull,
CreateDOMImplementation },
{ "XML document",
NS_XMLDOCUMENT_CID,
"@mozilla.org/xml/xml-document;1",
CreateXMLDocument },
#ifdef MOZ_SVG
{ "SVG document",
NS_SVGDOCUMENT_CID,
"@mozilla.org/svg/svg-document;1",
CreateSVGDocument },
#endif
{ "Image document",
NS_IMAGEDOCUMENT_CID,
nsnull,
CreateImageDocument },
{ "Dom selection",
NS_DOMSELECTION_CID,
"@mozilla.org/content/dom-selection;1",
CreateDOMSelection },
{ "Frame selection",
NS_FRAMESELECTION_CID,
nsnull,
CreateSelection },
{ "Range",
NS_RANGE_CID,
"@mozilla.org/content/range;1",
CreateRange },
{ "Range Utils",
NS_RANGEUTILS_CID,
"@mozilla.org/content/range-utils;1",
CreateRangeUtils },
{ "Content iterator",
NS_CONTENTITERATOR_CID,
"@mozilla.org/content/post-content-iterator;1",
CreateContentIterator },
{ "Pre Content iterator",
NS_PRECONTENTITERATOR_CID,
"@mozilla.org/content/pre-content-iterator;1",
CreatePreContentIterator },
{ "Subtree iterator",
NS_SUBTREEITERATOR_CID,
"@mozilla.org/content/subtree-content-iterator;1",
CreateSubtreeIterator },
// Needed to support "new Option;", "new Image;" and "new Audio;" in JavaScript
{ "HTML img element",
NS_HTMLIMAGEELEMENT_CID,
NS_HTMLIMGELEMENT_CONTRACTID,
CreateHTMLImgElement,
RegisterHTMLImgElement,
UnregisterHTMLImgElement },
{ "HTML option element",
NS_HTMLOPTIONELEMENT_CID,
NS_HTMLOPTIONELEMENT_CONTRACTID,
CreateHTMLOptionElement,
RegisterHTMLOptionElement,
UnregisterHTMLOptionElement },
#ifdef MOZ_MEDIA
{ "HTML audio element",
NS_HTMLAUDIOELEMENT_CID,
NS_HTMLAUDIOELEMENT_CONTRACTID,
CreateHTMLAudioElement,
RegisterHTMLAudioElement,
UnregisterHTMLAudioElement },
#endif
{ "Canvas 2D Rendering Context",
NS_CANVASRENDERINGCONTEXT2D_CID,
"@mozilla.org/content/canvas-rendering-context;1?id=2d",
CreateCanvasRenderingContext2D },
{ "Canvas WebGL Rendering Context",
NS_CANVASRENDERINGCONTEXTWEBGL_CID,
"@mozilla.org/content/canvas-rendering-context;1?id=moz-webgl",
CreateCanvasRenderingContextWebGL },
{ "Canvas WebGL Rendering Context",
NS_CANVASRENDERINGCONTEXTWEBGL_CID,
"@mozilla.org/content/canvas-rendering-context;1?id=experimental-webgl",
CreateCanvasRenderingContextWebGL },
{ "XML document encoder",
NS_TEXT_ENCODER_CID,
NS_DOC_ENCODER_CONTRACTID_BASE "text/xml",
CreateTextEncoder },
{ "XML document encoder",
NS_TEXT_ENCODER_CID,
NS_DOC_ENCODER_CONTRACTID_BASE "application/xml",
CreateTextEncoder },
{ "XHTML document encoder",
NS_TEXT_ENCODER_CID,
NS_DOC_ENCODER_CONTRACTID_BASE "application/xhtml+xml",
CreateTextEncoder },
#ifdef MOZ_SVG
{ "SVG document encoder",
NS_TEXT_ENCODER_CID,
NS_DOC_ENCODER_CONTRACTID_BASE "image/svg+xml",
CreateTextEncoder },
#endif
{ "HTML document encoder",
NS_TEXT_ENCODER_CID,
NS_DOC_ENCODER_CONTRACTID_BASE "text/html",
CreateTextEncoder },
{ "Plaintext document encoder",
NS_TEXT_ENCODER_CID,
NS_DOC_ENCODER_CONTRACTID_BASE "text/plain",
CreateTextEncoder },
{ "HTML copy encoder",
NS_HTMLCOPY_TEXT_ENCODER_CID,
NS_HTMLCOPY_ENCODER_CONTRACTID,
CreateHTMLCopyTextEncoder },
{ "XML content serializer",
NS_XMLCONTENTSERIALIZER_CID,
NS_CONTENTSERIALIZER_CONTRACTID_PREFIX "text/xml",
CreateXMLContentSerializer },
{ "XML content serializer",
NS_XMLCONTENTSERIALIZER_CID,
NS_CONTENTSERIALIZER_CONTRACTID_PREFIX "application/xml",
CreateXMLContentSerializer },
{ "XHTML content serializer",
NS_XHTMLCONTENTSERIALIZER_CID,
NS_CONTENTSERIALIZER_CONTRACTID_PREFIX "application/xhtml+xml",
CreateXHTMLContentSerializer },
#ifdef MOZ_SVG
{ "SVG content serializer",
NS_XMLCONTENTSERIALIZER_CID,
NS_CONTENTSERIALIZER_CONTRACTID_PREFIX "image/svg+xml",
CreateXMLContentSerializer },
#endif
{ "HTML content serializer",
NS_HTMLCONTENTSERIALIZER_CID,
NS_CONTENTSERIALIZER_CONTRACTID_PREFIX "text/html",
CreateHTMLContentSerializer },
{ "XUL content serializer",
NS_XMLCONTENTSERIALIZER_CID,
NS_CONTENTSERIALIZER_CONTRACTID_PREFIX "application/vnd.mozilla.xul+xml",
CreateXMLContentSerializer },
{ "plaintext content serializer",
NS_PLAINTEXTSERIALIZER_CID,
NS_CONTENTSERIALIZER_CONTRACTID_PREFIX "text/plain",
CreatePlainTextSerializer },
{ "plaintext sink",
NS_PLAINTEXTSERIALIZER_CID,
NS_PLAINTEXTSINK_CONTRACTID,
CreatePlainTextSerializer },
{ "html fragment sink",
NS_HTMLFRAGMENTSINK_CID,
NS_HTMLFRAGMENTSINK_CONTRACTID,
CreateHTMLFragmentSink },
{ "html fragment sink 2",
NS_HTMLFRAGMENTSINK2_CID,
NS_HTMLFRAGMENTSINK2_CONTRACTID,
CreateHTMLFragmentSink2 },
{ "html paranoid fragment sink",
NS_HTMLPARANOIDFRAGMENTSINK_CID,
NS_HTMLPARANOIDFRAGMENTSINK_CONTRACTID,
CreateHTMLParanoidFragmentSink },
{ "HTML sanitizing content serializer",
MOZ_SANITIZINGHTMLSERIALIZER_CID,
MOZ_SANITIZINGHTMLSERIALIZER_CONTRACTID,
CreateSanitizingHTMLSerializer },
{ "xml fragment sink",
NS_XMLFRAGMENTSINK_CID,
NS_XMLFRAGMENTSINK_CONTRACTID,
CreateXMLFragmentSink },
{ "xml fragment sink 2",
NS_XMLFRAGMENTSINK2_CID,
NS_XMLFRAGMENTSINK2_CONTRACTID,
CreateXMLFragmentSink2 },
{ "xhtml paranoid fragment sink",
NS_XHTMLPARANOIDFRAGMENTSINK_CID,
NS_XHTMLPARANOIDFRAGMENTSINK_CONTRACTID,
CreateXHTMLParanoidFragmentSink },
{ "XBL Service",
NS_XBLSERVICE_CID,
"@mozilla.org/xbl;1",
CreateXBLService },
{ "Content policy service",
NS_CONTENTPOLICY_CID,
NS_CONTENTPOLICY_CONTRACTID,
CreateContentPolicy },
{ "Data document content policy",
NS_DATADOCUMENTCONTENTPOLICY_CID,
NS_DATADOCUMENTCONTENTPOLICY_CONTRACTID,
nsDataDocumentContentPolicyConstructor,
RegisterDataDocumentContentPolicy,
UnregisterDataDocumentContentPolicy },
{ "No data protocol content policy",
NS_NODATAPROTOCOLCONTENTPOLICY_CID,
NS_NODATAPROTOCOLCONTENTPOLICY_CONTRACTID,
nsNoDataProtocolContentPolicyConstructor,
RegisterNoDataProtocolContentPolicy,
UnregisterNoDataProtocolContentPolicy },
{ "XUL Controllers",
NS_XULCONTROLLERS_CID,
"@mozilla.org/xul/xul-controllers;1",
NS_NewXULControllers },
#ifdef MOZ_XUL
{ "XUL Sort Service",
NS_XULSORTSERVICE_CID,
"@mozilla.org/xul/xul-sort-service;1",
CreateXULSortService },
{ "XUL Template Builder",
NS_XULTEMPLATEBUILDER_CID,
"@mozilla.org/xul/xul-template-builder;1",
NS_NewXULContentBuilder },
{ "XUL Tree Builder",
NS_XULTREEBUILDER_CID,
"@mozilla.org/xul/xul-tree-builder;1",
NS_NewXULTreeBuilder },
{ "XUL Popup Manager",
NS_XULPOPUPMANAGER_CID,
"@mozilla.org/xul/xul-popup-manager;1",
CreateXULPopupManager },
{ "XUL Document",
NS_XULDOCUMENT_CID,
"@mozilla.org/xul/xul-document;1",
CreateXULDocument },
{ "XUL Prototype Cache",
NS_XULPROTOTYPECACHE_CID,
"@mozilla.org/xul/xul-prototype-cache;1",
NS_NewXULPrototypeCache },
#endif
#ifdef MOZ_XTF
{ "XTF Service",
NS_XTFSERVICE_CID,
NS_XTFSERVICE_CONTRACTID,
CreateXTFService },
{ "XML Content Builder",
NS_XMLCONTENTBUILDER_CID,
NS_XMLCONTENTBUILDER_CONTRACTID,
CreateXMLContentBuilder },
#endif
{ "Document Loader Factory",
NS_CONTENT_DOCUMENT_LOADER_FACTORY_CID,
"@mozilla.org/content/document-loader-factory;1",
CreateContentDLF,
nsContentDLF::RegisterDocumentFactories,
nsContentDLF::UnregisterDocumentFactories },
{ "Wyciwyg Handler",
NS_WYCIWYGPROTOCOLHANDLER_CID,
NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "wyciwyg",
nsWyciwygProtocolHandlerConstructor },
{ "Content Area DragDrop",
NS_CONTENTAREADRAGDROP_CID,
NS_CONTENTAREADRAGDROP_CONTRACTID,
nsContentAreaDragDropConstructor },
{ "SyncLoad DOM Service",
NS_SYNCLOADDOMSERVICE_CID,
NS_SYNCLOADDOMSERVICE_CONTRACTID,
nsSyncLoadServiceConstructor },
// DOM objects
{ "Script Object Factory",
NS_DOM_SCRIPT_OBJECT_FACTORY_CID,
nsnull,
nsDOMScriptObjectFactoryConstructor
},
{ "Base DOM Exception",
NS_BASE_DOM_EXCEPTION_CID,
nsnull,
nsBaseDOMExceptionConstructor
},
{ "JavaScript Protocol Handler",
NS_JSPROTOCOLHANDLER_CID,
NS_JSPROTOCOLHANDLER_CONTRACTID,
nsJSProtocolHandler::Create },
{ "JavaScript URI",
NS_JSURI_CID,
nsnull,
nsJSURIConstructor },
{ "Window Command Table",
NS_WINDOWCOMMANDTABLE_CID,
"",
CreateWindowCommandTableConstructor
},
{ "Window Command Controller",
NS_WINDOWCONTROLLER_CID,
NS_WINDOWCONTROLLER_CONTRACTID,
CreateWindowControllerWithSingletonCommandTable
},
// view stuff
{ "View Manager", NS_VIEW_MANAGER_CID, "@mozilla.org/view-manager;1",
nsViewManagerConstructor },
{ "Plugin Document Loader Factory",
NS_PLUGINDOCLOADERFACTORY_CID,
"@mozilla.org/content/plugin/document-loader-factory;1",
CreateContentDLF },
{ "Plugin Document",
NS_PLUGINDOCUMENT_CID,
nsnull,
CreatePluginDocument },
#ifdef MOZ_MEDIA
{ "Video Document",
NS_VIDEODOCUMENT_CID,
nsnull,
CreateVideoDocument },
#endif
{ "Style sheet service",
NS_STYLESHEETSERVICE_CID,
NS_STYLESHEETSERVICE_CONTRACTID,
nsStyleSheetServiceConstructor },
// transformiix
{ "XSLTProcessor",
TRANSFORMIIX_XSLT_PROCESSOR_CID,
TRANSFORMIIX_XSLT_PROCESSOR_CONTRACTID,
txMozillaXSLTProcessorConstructor },
{ "XPathEvaluator",
TRANSFORMIIX_XPATH_EVALUATOR_CID,
NS_XPATH_EVALUATOR_CONTRACTID,
nsXPathEvaluatorConstructor },
{ "XPath1 XPointer Scheme Processor",
TRANSFORMIIX_XPATH1_SCHEME_CID,
NS_XPOINTER_SCHEME_PROCESSOR_BASE "xpath1",
nsXPath1SchemeProcessorConstructor },
{ "Transformiix NodeSet",
TRANSFORMIIX_NODESET_CID,
TRANSFORMIIX_NODESET_CONTRACTID,
txNodeSetAdaptorConstructor },
{ "XML Serializer",
NS_XMLSERIALIZER_CID,
NS_XMLSERIALIZER_CONTRACTID,
nsDOMSerializerConstructor },
{ "FileReader",
NS_FILEREADER_CID,
NS_FILEREADER_CONTRACTID,
nsDOMFileReaderConstructor },
{ "FormData",
NS_FORMDATA_CID,
NS_FORMDATA_CONTRACTID,
nsFormDataConstructor },
{ "XMLHttpRequest",
NS_XMLHTTPREQUEST_CID,
NS_XMLHTTPREQUEST_CONTRACTID,
nsXMLHttpRequestConstructor },
{ "DOM Parser",
NS_DOMPARSER_CID,
NS_DOMPARSER_CONTRACTID,
nsDOMParserConstructor },
{ "DOM Storage",
NS_DOMSTORAGE_CID,
"@mozilla.org/dom/storage;1",
NS_NewDOMStorage },
{ "DOM Storage 2",
NS_DOMSTORAGE2_CID,
"@mozilla.org/dom/storage;2",
NS_NewDOMStorage2 },
{ "DOM Storage Manager",
NS_DOMSTORAGEMANAGER_CID,
"@mozilla.org/dom/storagemanager;1",
nsDOMStorageManagerConstructor },
{ "DOM JSON",
NS_DOMJSON_CID,
"@mozilla.org/dom/json;1",
NS_NewJSON },
{ "Text Editor",
NS_TEXTEDITOR_CID,
"@mozilla.org/editor/texteditor;1",
nsPlaintextEditorConstructor },
#ifndef MOZILLA_PLAINTEXT_EDITOR_ONLY
#ifdef ENABLE_EDITOR_API_LOG
{ "HTML Editor",
NS_HTMLEDITOR_CID,
"@mozilla.org/editor/htmleditor;1",
nsHTMLEditorLogConstructor },
#else
{ "HTML Editor",
NS_HTMLEDITOR_CID,
"@mozilla.org/editor/htmleditor;1",
nsHTMLEditorConstructor },
#endif
#endif
{ "Editor Controller",
NS_EDITORCONTROLLER_CID,
"@mozilla.org/editor/editorcontroller;1",
nsEditorControllerConstructor },
{ "Editor Command Table",
NS_EDITORCOMMANDTABLE_CID,
"", // no point in using a contract ID
nsEditorCommandTableConstructor },
#ifndef MOZILLA_PLAINTEXT_EDITOR_ONLY
{ NULL,
NS_TEXTSERVICESDOCUMENT_CID,
"@mozilla.org/textservices/textservicesdocument;1",
nsTextServicesDocumentConstructor },
#endif
{ "Geolocation Service",
NS_GEOLOCATION_SERVICE_CID,
"@mozilla.org/geolocation/service;1",
nsGeolocationServiceConstructor },
{ "Geolocation",
NS_GEOLOCATION_CID,
"@mozilla.org/geolocation;1",
nsGeolocationConstructor },
{ "Focus Manager",
NS_FOCUSMANAGER_CID,
"@mozilla.org/focus-manager;1",
CreateFocusManager },
{ "Content Security Policy Service",
CSPSERVICE_CID,
CSPSERVICE_CONTRACTID,
CSPServiceConstructor,
CSPServiceRegistration,
CSPServiceUnregistration },
{ "Event Listener Service",
NS_EVENTLISTENERSERVICE_CID,
NS_EVENTLISTENERSERVICE_CONTRACTID,
CreateEventListenerService }
};
NS_IMPL_NSGETMODULE_WITH_CTOR(nsLayoutModule, gComponents, Initialize)
Reference in New Issue View Git Blame Copy Permalink