layout/build/nsLayoutModule.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsLayoutModule.h"
   8
   9 #include "base/basictypes.h"
  10
  11 #include "XPCModule.h"
  12 #include "mozilla/Components.h"
  13 #include "mozilla/ModuleUtils.h"
  14 #include "nsImageModule.h"
  15 #include "nsLayoutStatics.h"
  16 #include "nsContentCID.h"
  17 #include "nsContentDLF.h"
  18 #include "nsContentPolicyUtils.h"
  19 #include "nsDataDocumentContentPolicy.h"
  20 #include "nsNoDataProtocolContentPolicy.h"
  21 #include "nsDOMCID.h"
  22 #include "nsFrameMessageManager.h"
  23 #include "nsHTMLContentSerializer.h"
  24 #include "nsHTMLParts.h"
  25 #include "nsIContentSerializer.h"
  26 #include "nsIContentViewer.h"
  27 #include "nsPlainTextSerializer.h"
  28 #include "nsXMLContentSerializer.h"
  29 #include "nsXHTMLContentSerializer.h"
  30 #include "nsIFrameTraversal.h"
  31 #include "nsLayoutCID.h"
  32 #include "nsFocusManager.h"
  33 #include "ThirdPartyUtil.h"
  34 #include "gfxPlatform.h"
  35 #include "mozilla/gfx/gfxVars.h"
  36 #include "mozilla/dom/quota/QuotaManagerService.h"
  37
  38 #include "nsIEventListenerService.h"
  39
  40 // view stuff
  41 #include "nsContentCreatorFunctions.h"
  42
  43 #include "mozilla/dom/LocalStorageCommon.h"
  44 #include "mozilla/dom/LocalStorageManager.h"
  45 #include "mozilla/dom/LocalStorageManager2.h"
  46 #include "mozilla/dom/SessionStorageManager.h"
  47
  48 #ifdef MOZ_WEBSPEECH
  49 #  include "mozilla/dom/nsSynthVoiceRegistry.h"
  50 #  include "mozilla/dom/OnlineSpeechRecognitionService.h"
  51 #endif
  52
  53 #include "mozilla/dom/PushNotifier.h"
  54 using mozilla::dom::PushNotifier;
  55 #define PUSHNOTIFIER_CID                             \
  56   {                                                  \
  57     0x2fc2d3e3, 0x020f, 0x404e, {                    \
  58       0xb0, 0x6a, 0x6e, 0xcf, 0x3e, 0xa2, 0x33, 0x4a \
  59     }                                                \
  60   }
  61
  62 #include "nsScriptSecurityManager.h"
  63 #include "nsNetCID.h"
  64 #if defined(MOZ_WIDGET_ANDROID)
  65 #  include "nsHapticFeedback.h"
  66 #endif
  67 #include "nsParserUtils.h"
  68
  69 class nsIDocumentLoaderFactory;
  70
  71 #define PRODUCT_NAME "Gecko"
  72
  73 #include "inDeepTreeWalker.h"
  74
  75 static void Shutdown();
  76
  77 #include "mozilla/dom/nsContentSecurityManager.h"
  78
  79 using namespace mozilla;
  80 using namespace mozilla::dom;
  81 using namespace mozilla::net;
  82
  83 //-----------------------------------------------------------------------------
  84
  85 static bool gInitialized = false;
  86
  87 // Perform our one-time intialization for this module
  88
  89 void nsLayoutModuleInitialize() {
  90   if (gInitialized) {
  91     MOZ_CRASH("Recursive layout module initialization");
  92   }
  93
  94   static_assert(sizeof(uintptr_t) == sizeof(void*),
  95                 "Eeek! You'll need to adjust the size of uintptr_t to the "
  96                 "size of a pointer on your platform.");
  97
  98   gInitialized = true;
  99
 100   if (NS_FAILED(xpcModuleCtor())) {
 101     MOZ_CRASH("xpcModuleCtor failed");
 102   }
 103
 104   if (NS_FAILED(nsLayoutStatics::Initialize())) {
 105     Shutdown();
 106     MOZ_CRASH("nsLayoutStatics::Initialize failed");
 107   }
 108 }
 109
 110 // Shutdown this module, releasing all of the module resources
 111
 112 // static
 113 void Shutdown() {
 114   MOZ_ASSERT(gInitialized, "module not initialized");
 115   if (!gInitialized) return;
 116
 117   gInitialized = false;
 118
 119   nsLayoutStatics::Release();
 120 }
 121
 122 nsresult NS_CreateFrameTraversal(nsIFrameTraversal** aResult);
 123
 124 already_AddRefed<nsIContentViewer> NS_NewContentViewer();
 125 nsresult NS_NewContentDocumentLoaderFactory(nsIDocumentLoaderFactory** aResult);
 126 nsresult NS_NewContentPolicy(nsIContentPolicy** aResult);
 127
 128 nsresult NS_NewEventListenerService(nsIEventListenerService** aResult);
 129 nsresult NS_NewGlobalMessageManager(nsISupports** aResult);
 130 nsresult NS_NewParentProcessMessageManager(nsISupports** aResult);
 131 nsresult NS_NewChildProcessMessageManager(nsISupports** aResult);
 132
 133 #define MAKE_CTOR(ctor_, iface_, func_)                                \
 134   nsresult ctor_(nsISupports* aOuter, REFNSIID aIID, void** aResult) { \
 135     *aResult = nullptr;                                                \
 136     if (aOuter) return NS_ERROR_NO_AGGREGATION;                        \
 137     iface_* inst;                                                      \
 138     nsresult rv = func_(&inst);                                        \
 139     if (NS_SUCCEEDED(rv)) {                                            \
 140       rv = inst->QueryInterface(aIID, aResult);                        \
 141       NS_RELEASE(inst);                                                \
 142     }                                                                  \
 143     return rv;                                                         \
 144   }
 145
 146 #define MAKE_GENERIC_CTOR(iface_, func_)             \
 147   NS_IMPL_COMPONENT_FACTORY(iface_) {                \
 148     nsCOMPtr<iface_> inst;                           \
 149     if (NS_SUCCEEDED(func_(getter_AddRefs(inst)))) { \
 150       return inst.forget();                          \
 151     }                                                \
 152     return nullptr;                                  \
 153   }
 154
 155 #define MAKE_GENERIC_CTOR2(iface_, func_) \
 156   NS_IMPL_COMPONENT_FACTORY(iface_) { return func_(); }
 157
 158 MAKE_GENERIC_CTOR(nsIFrameTraversal, NS_CreateFrameTraversal)
 159
 160 MAKE_GENERIC_CTOR2(nsIContentViewer, NS_NewContentViewer)
 161
 162 MAKE_CTOR(CreateXMLContentSerializer, nsIContentSerializer,
 163           NS_NewXMLContentSerializer)
 164 MAKE_CTOR(CreateHTMLContentSerializer, nsIContentSerializer,
 165           NS_NewHTMLContentSerializer)
 166 MAKE_CTOR(CreateXHTMLContentSerializer, nsIContentSerializer,
 167           NS_NewXHTMLContentSerializer)
 168 MAKE_CTOR(CreatePlainTextSerializer, nsIContentSerializer,
 169           NS_NewPlainTextSerializer)
 170 MAKE_CTOR(CreateContentPolicy, nsIContentPolicy, NS_NewContentPolicy)
 171
 172 MAKE_GENERIC_CTOR(nsIDocumentLoaderFactory, NS_NewContentDocumentLoaderFactory)
 173 MAKE_GENERIC_CTOR(nsIEventListenerService, NS_NewEventListenerService)
 174 MAKE_CTOR(CreateGlobalMessageManager, nsISupports, NS_NewGlobalMessageManager)
 175 MAKE_CTOR(CreateParentMessageManager, nsISupports,
 176           NS_NewParentProcessMessageManager)
 177 MAKE_CTOR(CreateChildMessageManager, nsISupports,
 178           NS_NewChildProcessMessageManager)
 179
 180 MAKE_GENERIC_CTOR(nsIFocusManager, NS_NewFocusManager)
 181
 182 // views are not refcounted, so this is the same as
 183 // NS_GENERIC_FACTORY_CONSTRUCTOR without the NS_ADDREF/NS_RELEASE
 184 #define NS_GENERIC_FACTORY_CONSTRUCTOR_NOREFS(_InstanceClass)                  \
 185   static nsresult _InstanceClass##Constructor(nsISupports* aOuter,             \
 186                                               REFNSIID aIID, void** aResult) { \
 187     nsresult rv;                                                               \
 188                                                                                \
 189     *aResult = nullptr;                                                        \
 190     if (nullptr != aOuter) {                                                   \
 191       rv = NS_ERROR_NO_AGGREGATION;                                            \
 192       return rv;                                                               \
 193     }                                                                          \
 194                                                                                \
 195     _InstanceClass* inst = new _InstanceClass();                               \
 196     if (nullptr == inst) {                                                     \
 197       rv = NS_ERROR_OUT_OF_MEMORY;                                             \
 198       return rv;                                                               \
 199     }                                                                          \
 200     rv = inst->QueryInterface(aIID, aResult);                                  \
 201                                                                                \
 202     return rv;                                                                 \
 203   }
 204
 205 #ifdef ACCESSIBILITY
 206 #  include "xpcAccessibilityService.h"
 207
 208 MAKE_GENERIC_CTOR(nsIAccessibilityService, NS_GetAccessibilityService)
 209 #endif
 210
 211 nsresult Construct_nsIScriptSecurityManager(nsISupports* aOuter, REFNSIID aIID,
 212                                             void** aResult) {
 213   if (!aResult) return NS_ERROR_NULL_POINTER;
 214   *aResult = nullptr;
 215   if (aOuter) return NS_ERROR_NO_AGGREGATION;
 216   nsScriptSecurityManager* obj =
 217       nsScriptSecurityManager::GetScriptSecurityManager();
 218   if (!obj) return NS_ERROR_OUT_OF_MEMORY;
 219   if (NS_FAILED(obj->QueryInterface(aIID, aResult))) return NS_ERROR_FAILURE;
 220   return NS_OK;
 221 }
 222
 223 nsresult LocalStorageManagerConstructor(nsISupports* aOuter, REFNSIID aIID,
 224                                         void** aResult) {
 225   if (NextGenLocalStorageEnabled()) {
 226     RefPtr<LocalStorageManager2> manager = new LocalStorageManager2();
 227     return manager->QueryInterface(aIID, aResult);
 228   }
 229
 230   RefPtr<LocalStorageManager> manager = new LocalStorageManager();
 231   return manager->QueryInterface(aIID, aResult);
 232 }
 233
 234 nsresult SessionStorageManagerConstructor(nsISupports* aOuter, REFNSIID aIID,
 235                                           void** aResult) {
 236   RefPtr<SessionStorageManager> manager = new SessionStorageManager(nullptr);
 237   return manager->QueryInterface(aIID, aResult);
 238 }
 239
 240 static const mozilla::Module::CategoryEntry kLayoutCategories[] = {
 241     // clang-format off
 242     {nullptr}
 243     // clang-format on
 244 };
 245
 246 void nsLayoutModuleDtor() {
 247   if (XRE_GetProcessType() == GeckoProcessType_GPU ||
 248       XRE_GetProcessType() == GeckoProcessType_VR ||
 249       XRE_GetProcessType() == GeckoProcessType_RDD) {
 250     return;
 251   }
 252
 253   Shutdown();
 254   nsContentUtils::XPCOMShutdown();
 255
 256   // Layout depends heavily on gfx and imagelib, so we want to make sure that
 257   // these modules are shut down after all the layout cleanup runs.
 258   mozilla::image::ShutdownModule();
 259   gfxPlatform::Shutdown();
 260   gfx::gfxVars::Shutdown();
 261
 262   nsScriptSecurityManager::Shutdown();
 263   xpcModuleDtor();
 264 }
 265
 266 extern const mozilla::Module kLayoutModule = {mozilla::Module::kVersion,
 267                                               nullptr,
 268                                               nullptr,
 269                                               kLayoutCategories,
 270                                               nullptr,
 271                                               nullptr,
 272                                               nullptr};