diff options
Diffstat (limited to '')
| -rw-r--r-- | layout/style/GlobalStyleSheetCache.cpp | 704 |
1 files changed, 704 insertions, 0 deletions
diff --git a/layout/style/GlobalStyleSheetCache.cpp b/layout/style/GlobalStyleSheetCache.cpp new file mode 100644 index 0000000000..51287a7689 --- /dev/null +++ b/layout/style/GlobalStyleSheetCache.cpp @@ -0,0 +1,704 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "GlobalStyleSheetCache.h" + +#include "nsAppDirectoryServiceDefs.h" +#include "nsExceptionHandler.h" +#include "mozilla/MemoryReporting.h" +#include "mozilla/Preferences.h" +#include "mozilla/StaticPrefs_layout.h" +#include "mozilla/StyleSheet.h" +#include "mozilla/StyleSheetInlines.h" +#include "mozilla/Telemetry.h" +#include "mozilla/css/Loader.h" +#include "mozilla/StaticPrefs_browser.h" +#include "mozilla/dom/ReferrerInfo.h" +#include "mozilla/dom/SRIMetadata.h" +#include "mozilla/ipc/SharedMemory.h" +#include "MainThreadUtils.h" +#include "nsColor.h" +#include "nsContentUtils.h" +#include "nsIConsoleService.h" +#include "nsIFile.h" +#include "nsIObserverService.h" +#include "nsIXULRuntime.h" +#include "nsNetUtil.h" +#include "nsPresContext.h" +#include "nsPrintfCString.h" +#include "nsServiceManagerUtils.h" +#include "nsXULAppAPI.h" + +#include <mozilla/ServoBindings.h> + +namespace mozilla { + +// The GlobalStyleSheetCache is responsible for sharing user agent style sheet +// contents across processes using shared memory. Here is a high level view of +// how that works: +// +// * In the parent process, in the GlobalStyleSheetCache constructor (which is +// called early on in a process' lifetime), we parse all UA style sheets into +// Gecko StyleSheet objects. +// +// * The constructor calls InitSharedSheetsInParent, which creates a shared +// memory segment that we know ahead of time will be big enough to store the +// UA sheets. +// +// * It then creates a Rust SharedMemoryBuilder object and passes it a pointer +// to the start of the shared memory. +// +// * For each UA sheet, we call Servo_SharedMemoryBuilder_AddStylesheet, which +// takes the StylesheetContents::rules (an Arc<Locked<CssRules>>), produces a +// deep clone of it, and writes that clone into the shared memory: +// +// * The deep clone isn't a clone() call, but a call to ToShmem::to_shmem. The +// ToShmem trait must be implemented on every type that is reachable under +// the Arc<Locked<CssRules>>. The to_shmem call for each type will clone the +// value, but any heap allocation will be cloned and placed into the shared +// memory buffer, rather than heap allocated. +// +// * For most types, the ToShmem implementation is simple, and we just +// #[derive(ToShmem)] it. For the types that need special handling due to +// having heap allocations (Vec<T>, Box<T>, Arc<T>, etc.) we have impls that +// call to_shmem on the heap allocated data, and then create a new container +// (e.g. using Box::from_raw) that points into the shared memory. +// +// * Arc<T> and Locked<T> want to perform atomic writes on data that needs to +// be in the shared memory buffer (the reference count for Arc<T>, and the +// SharedRwLock's AtomicRefCell for Locked<T>), so we add special modes to +// those objects that skip the writes. For Arc<T>, that means never +// dropping the object since we don't track the reference count. That's +// fine, since we want to just drop the entire shared memory buffer at +// shutdown. For Locked<T>, we just panic on attempting to take the lock +// for writing. That's also fine, since we don't want devtools being able +// to modify UA sheets. +// +// * For Atoms in Rust, static atoms are represented by an index into the +// static atom table. Then if we need to Deref the Atom we look up the +// table. We panic if any Atom we encounter in the UA style sheets is +// not a static atom. +// +// * For each UA sheet, we create a new C++ StyleSheet object using the shared +// memory clone of the sheet contents, and throw away the original heap +// allocated one. (We could avoid creating a new C++ StyleSheet object +// wrapping the shared contents, and update the original StyleSheet object's +// contents, but it's doubtful that matters.) +// +// * When we initially map the shared memory in the parent process in +// InitSharedSheetsInParent, we choose an address which is far away from the +// current extent of the heap. Although not too far, since we don't want to +// unnecessarily fragment the virtual address space. +// +// * In the child process, as early as possible (in +// ContentChild::InitSharedUASheets), we try to map the shared memory at that +// same address, then pass the shared memory buffer to +// GlobalStyleSheetCache::SetSharedMemory. Since we map at the same +// address, this means any internal pointers in the UA sheets back into the +// shared memory buffer that were written by the parent process are valid in +// the child process too. +// +// * In practice, mapping at the address we need in the child process this works +// nearly all the time. If we fail to map at the address we need, the child +// process falls back to parsing and allocating its own copy of the UA sheets. + +using namespace mozilla; +using namespace css; + +#define PREF_LEGACY_STYLESHEET_CUSTOMIZATION \ + "toolkit.legacyUserProfileCustomizations.stylesheets" + +NS_IMPL_ISUPPORTS(GlobalStyleSheetCache, nsIObserver, nsIMemoryReporter) + +nsresult GlobalStyleSheetCache::Observe(nsISupports* aSubject, + const char* aTopic, + const char16_t* aData) { + if (!strcmp(aTopic, "profile-before-change")) { + mUserContentSheet = nullptr; + mUserChromeSheet = nullptr; + } else if (!strcmp(aTopic, "profile-do-change")) { + InitFromProfile(); + } else { + MOZ_ASSERT_UNREACHABLE("Unexpected observer topic."); + } + return NS_OK; +} + +#define STYLE_SHEET(identifier_, url_, shared_) \ + NotNull<StyleSheet*> GlobalStyleSheetCache::identifier_##Sheet() { \ + if (!m##identifier_##Sheet) { \ + m##identifier_##Sheet = LoadSheetURL(url_, eAgentSheetFeatures, eCrash); \ + } \ + return WrapNotNull(m##identifier_##Sheet); \ + } +#include "mozilla/UserAgentStyleSheetList.h" +#undef STYLE_SHEET + +StyleSheet* GlobalStyleSheetCache::GetUserContentSheet() { + return mUserContentSheet; +} + +StyleSheet* GlobalStyleSheetCache::GetUserChromeSheet() { + return mUserChromeSheet; +} + +StyleSheet* GlobalStyleSheetCache::ChromePreferenceSheet() { + if (!mChromePreferenceSheet) { + BuildPreferenceSheet(&mChromePreferenceSheet, + PreferenceSheet::ChromePrefs()); + } + + return mChromePreferenceSheet; +} + +StyleSheet* GlobalStyleSheetCache::ContentPreferenceSheet() { + if (!mContentPreferenceSheet) { + BuildPreferenceSheet(&mContentPreferenceSheet, + PreferenceSheet::ContentPrefs()); + } + + return mContentPreferenceSheet; +} + +void GlobalStyleSheetCache::Shutdown() { + gCSSLoader = nullptr; + NS_WARNING_ASSERTION(!gStyleCache || !gUserContentSheetURL, + "Got the URL but never used?"); + gStyleCache = nullptr; + gUserContentSheetURL = nullptr; + for (auto& r : URLExtraData::sShared) { + r = nullptr; + } + // We want to leak the shared memory forever, rather than cleaning up all + // potential DOM references and such that chrome code may have created. +} + +void GlobalStyleSheetCache::SetUserContentCSSURL(nsIURI* aURI) { + MOZ_ASSERT(XRE_IsContentProcess(), "Only used in content processes."); + gUserContentSheetURL = aURI; +} + +MOZ_DEFINE_MALLOC_SIZE_OF(LayoutStylesheetCacheMallocSizeOf) + +NS_IMETHODIMP +GlobalStyleSheetCache::CollectReports(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, bool aAnonymize) { + MOZ_COLLECT_REPORT("explicit/layout/style-sheet-cache/unshared", KIND_HEAP, + UNITS_BYTES, + SizeOfIncludingThis(LayoutStylesheetCacheMallocSizeOf), + "Memory used for built-in style sheets that are not " + "shared between processes."); + + if (XRE_IsParentProcess()) { + MOZ_COLLECT_REPORT( + "explicit/layout/style-sheet-cache/shared", KIND_NONHEAP, UNITS_BYTES, + sSharedMemory ? sUsedSharedMemory : 0, + "Memory used for built-in style sheets that are shared to " + "child processes."); + } + + return NS_OK; +} + +size_t GlobalStyleSheetCache::SizeOfIncludingThis( + MallocSizeOf aMallocSizeOf) const { + size_t n = aMallocSizeOf(this); + +#define MEASURE(s) n += s ? s->SizeOfIncludingThis(aMallocSizeOf) : 0; + +#define STYLE_SHEET(identifier_, url_, shared_) MEASURE(m##identifier_##Sheet); +#include "mozilla/UserAgentStyleSheetList.h" +#undef STYLE_SHEET + + MEASURE(mChromePreferenceSheet); + MEASURE(mContentPreferenceSheet); + MEASURE(mUserChromeSheet); + MEASURE(mUserContentSheet); + + // Measurement of the following members may be added later if DMD finds it is + // worthwhile: + // - gCSSLoader + + return n; +} + +GlobalStyleSheetCache::GlobalStyleSheetCache() { + nsCOMPtr<nsIObserverService> obsSvc = services::GetObserverService(); + NS_ASSERTION(obsSvc, "No global observer service?"); + + if (obsSvc) { + obsSvc->AddObserver(this, "profile-before-change", false); + obsSvc->AddObserver(this, "profile-do-change", false); + } + + // Load user style sheets. + InitFromProfile(); + + if (XRE_IsParentProcess()) { + // We know we need xul.css for the UI, so load that now too: + XULSheet(); + } + + if (gUserContentSheetURL) { + MOZ_ASSERT(XRE_IsContentProcess(), "Only used in content processes."); + mUserContentSheet = + LoadSheet(gUserContentSheetURL, eUserSheetFeatures, eLogToConsole); + gUserContentSheetURL = nullptr; + } + + // If we are the in the parent process, then we load all of the UA sheets that + // are shareable and store them into shared memory. In both the parent and + // the content process, we load these sheets out of shared memory. + // + // The shared memory buffer's format is a Header object, which contains + // internal pointers to each of the shared style sheets, followed by the style + // sheets themselves. + if (StaticPrefs::layout_css_shared_memory_ua_sheets_enabled()) { + if (XRE_IsParentProcess()) { + // Load the style sheets and store them in a new shared memory buffer. + InitSharedSheetsInParent(); + } else if (sSharedMemory) { + // Use the shared memory handle that was given to us by a SetSharedMemory + // call under ContentChild::InitXPCOM. + MOZ_ASSERT(sSharedMemory->memory(), + "GlobalStyleSheetCache::SetSharedMemory should have mapped " + "the shared memory"); + } + } + + // If we get here and we don't have a shared memory handle, then it means + // either we failed to create the shared memory buffer in the parent process + // (unexpected), or we failed to map the shared memory buffer at the address + // we needed in the content process (might happen). + // + // If sSharedMemory is non-null, but it is not currently mapped, then it means + // we are in the parent process, and we failed to re-map the memory after + // freezing it. (We keep sSharedMemory around so that we can still share it + // to content processes.) + // + // In the parent process, this means we'll just leave our eagerly loaded + // non-shared sheets in the mFooSheet fields. In a content process, we'll + // lazily load our own copies of the sheets later. + if (sSharedMemory) { + if (auto* header = static_cast<Header*>(sSharedMemory->memory())) { + MOZ_RELEASE_ASSERT(header->mMagic == Header::kMagic); + +#define STYLE_SHEET(identifier_, url_, shared_) \ + if (shared_) { \ + LoadSheetFromSharedMemory(url_, &m##identifier_##Sheet, \ + eAgentSheetFeatures, header, \ + UserAgentStyleSheetID::identifier_); \ + } +#include "mozilla/UserAgentStyleSheetList.h" +#undef STYLE_SHEET + } + } +} + +void GlobalStyleSheetCache::LoadSheetFromSharedMemory( + const char* aURL, RefPtr<StyleSheet>* aSheet, SheetParsingMode aParsingMode, + Header* aHeader, UserAgentStyleSheetID aSheetID) { + auto i = size_t(aSheetID); + + auto sheet = + MakeRefPtr<StyleSheet>(aParsingMode, CORS_NONE, dom::SRIMetadata()); + + nsCOMPtr<nsIURI> uri; + MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(uri), aURL)); + + sheet->SetPrincipal(nsContentUtils::GetSystemPrincipal()); + sheet->SetURIs(uri, uri, uri); + sheet->SetSharedContents(aHeader->mSheets[i]); + sheet->SetComplete(); + + nsCOMPtr<nsIReferrerInfo> referrerInfo = + dom::ReferrerInfo::CreateForExternalCSSResources(sheet); + sheet->SetReferrerInfo(referrerInfo); + URLExtraData::sShared[i] = sheet->URLData(); + + *aSheet = std::move(sheet); +} + +void GlobalStyleSheetCache::InitSharedSheetsInParent() { + MOZ_ASSERT(XRE_IsParentProcess()); + MOZ_RELEASE_ASSERT(!sSharedMemory); + + auto shm = MakeUnique<base::SharedMemory>(); + if (NS_WARN_IF(!shm->CreateFreezeable(kSharedMemorySize))) { + return; + } + + // We need to choose an address to map the shared memory in the parent process + // that we'll also be able to use in content processes. There's no way to + // pick an address that is guaranteed to be free in future content processes, + // so instead we pick an address that is some distance away from current heap + // allocations and hope that by the time the content process maps the shared + // memory, that address will be free. + // + // On 64 bit, we have a large amount of address space, so we pick an address + // half way through the next 8 GiB of free space, and this has a very good + // chance of succeeding. On 32 bit, address space is more constrained. We + // only have 3 GiB of space to work with, and we don't want to pick a location + // right in the middle, since that could cause future large allocations to + // fail. So we pick an address half way through the next 512 MiB of free + // space. Experimentally this seems to work 9 times out of 10; this is good + // enough, as it means only 1 in 10 content processes will have its own unique + // copies of the UA style sheets, and we're still getting a significant + // overall memory saving. + // + // In theory ASLR could reduce the likelihood of the mapping succeeding in + // content processes, due to our expectations of where the heap is being + // wrong, but in practice this isn't an issue. +#ifdef HAVE_64BIT_BUILD + constexpr size_t kOffset = 0x200000000ULL; // 8 GiB +#else + constexpr size_t kOffset = 0x20000000; // 512 MiB +#endif + + void* address = nullptr; + if (void* p = base::SharedMemory::FindFreeAddressSpace(2 * kOffset)) { + address = reinterpret_cast<void*>(uintptr_t(p) + kOffset); + } + + if (!shm->Map(kSharedMemorySize, address)) { + // Failed to map at the address we computed for some reason. Fall back + // to just allocating at a location of the OS's choosing, and hope that + // it works in the content process. + if (NS_WARN_IF(!shm->Map(kSharedMemorySize))) { + return; + } + } + address = shm->memory(); + + auto* header = static_cast<Header*>(address); + header->mMagic = Header::kMagic; +#ifdef DEBUG + for (const auto* ptr : header->mSheets) { + MOZ_RELEASE_ASSERT(!ptr, "expected shared memory to have been zeroed"); + } +#endif + + UniquePtr<StyleSharedMemoryBuilder> builder(Servo_SharedMemoryBuilder_Create( + header->mBuffer, kSharedMemorySize - offsetof(Header, mBuffer))); + + nsCString message; + + // Copy each one into the shared memory, and record its pointer. + // + // Normally calling ToShared on UA sheets should not fail. It happens + // in practice in odd cases that seem like corrupted installations; see bug + // 1621773. On failure, return early and fall back to non-shared sheets. +#define STYLE_SHEET(identifier_, url_, shared_) \ + if (shared_) { \ + StyleSheet* sheet = identifier_##Sheet(); \ + size_t i = size_t(UserAgentStyleSheetID::identifier_); \ + URLExtraData::sShared[i] = sheet->URLData(); \ + header->mSheets[i] = sheet->ToShared(builder.get(), message); \ + if (!header->mSheets[i]) { \ + CrashReporter::AppendAppNotesToCrashReport("\n"_ns + message); \ + return; \ + } \ + } +#include "mozilla/UserAgentStyleSheetList.h" +#undef STYLE_SHEET + + // Finished writing into the shared memory. Freeze it, so that a process + // can't confuse other processes by changing the UA style sheet contents. + if (NS_WARN_IF(!shm->Freeze())) { + return; + } + + // The Freeze() call unmaps the shared memory. Re-map it again as read only. + // If this fails, due to something else being mapped into the same place + // between the Freeze() and Map() call, we can just fall back to keeping our + // own copy of the UA style sheets in the parent, and still try sending the + // shared memory to the content processes. + shm->Map(kSharedMemorySize, address); + + // Record how must of the shared memory we have used, for memory reporting + // later. We round up to the nearest page since the free space at the end + // of the page isn't really usable for anything else. + // + // TODO(heycam): This won't be true on Windows unless we allow creating the + // shared memory with SEC_RESERVE so that the pages are reserved but not + // committed. + size_t pageSize = ipc::SharedMemory::SystemPageSize(); + sUsedSharedMemory = + (Servo_SharedMemoryBuilder_GetLength(builder.get()) + pageSize - 1) & + ~(pageSize - 1); + + sSharedMemory = shm.release(); +} + +GlobalStyleSheetCache::~GlobalStyleSheetCache() { + UnregisterWeakMemoryReporter(this); +} + +void GlobalStyleSheetCache::InitMemoryReporter() { + RegisterWeakMemoryReporter(this); +} + +/* static */ +GlobalStyleSheetCache* GlobalStyleSheetCache::Singleton() { + MOZ_ASSERT(NS_IsMainThread()); + + if (!gStyleCache) { + gStyleCache = new GlobalStyleSheetCache; + gStyleCache->InitMemoryReporter(); + + // For each pref that controls a CSS feature that a UA style sheet depends + // on (such as a pref that enables a property that a UA style sheet uses), + // register DependentPrefChanged as a callback to ensure that the relevant + // style sheets will be re-parsed. + // Preferences::RegisterCallback(&DependentPrefChanged, + // "layout.css.example-pref.enabled"); + } + + return gStyleCache; +} + +void GlobalStyleSheetCache::InitFromProfile() { + if (!Preferences::GetBool(PREF_LEGACY_STYLESHEET_CUSTOMIZATION)) { + return; + } + + nsCOMPtr<nsIXULRuntime> appInfo = + do_GetService("@mozilla.org/xre/app-info;1"); + if (appInfo) { + bool inSafeMode = false; + appInfo->GetInSafeMode(&inSafeMode); + if (inSafeMode) return; + } + nsCOMPtr<nsIFile> contentFile; + nsCOMPtr<nsIFile> chromeFile; + + NS_GetSpecialDirectory(NS_APP_USER_CHROME_DIR, getter_AddRefs(contentFile)); + if (!contentFile) { + // if we don't have a profile yet, that's OK! + return; + } + + contentFile->Clone(getter_AddRefs(chromeFile)); + if (!chromeFile) return; + + contentFile->Append(u"userContent.css"_ns); + chromeFile->Append(u"userChrome.css"_ns); + + mUserContentSheet = LoadSheetFile(contentFile, eUserSheetFeatures); + mUserChromeSheet = LoadSheetFile(chromeFile, eUserSheetFeatures); +} + +RefPtr<StyleSheet> GlobalStyleSheetCache::LoadSheetURL( + const char* aURL, SheetParsingMode aParsingMode, + FailureAction aFailureAction) { + nsCOMPtr<nsIURI> uri; + NS_NewURI(getter_AddRefs(uri), aURL); + return LoadSheet(uri, aParsingMode, aFailureAction); +} + +RefPtr<StyleSheet> GlobalStyleSheetCache::LoadSheetFile( + nsIFile* aFile, SheetParsingMode aParsingMode) { + bool exists = false; + aFile->Exists(&exists); + if (!exists) { + return nullptr; + } + + nsCOMPtr<nsIURI> uri; + NS_NewFileURI(getter_AddRefs(uri), aFile); + return LoadSheet(uri, aParsingMode, eLogToConsole); +} + +static void ErrorLoadingSheet(nsIURI* aURI, const char* aMsg, + FailureAction aFailureAction) { + nsPrintfCString errorMessage("%s loading built-in stylesheet '%s'", aMsg, + aURI ? aURI->GetSpecOrDefault().get() : ""); + if (aFailureAction == eLogToConsole) { + nsCOMPtr<nsIConsoleService> cs = + do_GetService(NS_CONSOLESERVICE_CONTRACTID); + if (cs) { + cs->LogStringMessage(NS_ConvertUTF8toUTF16(errorMessage).get()); + return; + } + } + + MOZ_CRASH_UNSAFE(errorMessage.get()); +} + +RefPtr<StyleSheet> GlobalStyleSheetCache::LoadSheet( + nsIURI* aURI, SheetParsingMode aParsingMode, FailureAction aFailureAction) { + if (!aURI) { + ErrorLoadingSheet(aURI, "null URI", eCrash); + return nullptr; + } + + if (!gCSSLoader) { + gCSSLoader = new Loader; + } + + // Note: The parallel parsing code assume that UA sheets are always loaded + // synchronously like they are here, and thus that we'll never attempt + // parallel parsing on them. If that ever changes, we'll either need to find a + // different way to prohibit parallel parsing for UA sheets, or handle + // -moz-bool-pref and various other things in the parallel parsing code. + auto result = gCSSLoader->LoadSheetSync(aURI, aParsingMode, + css::Loader::UseSystemPrincipal::Yes); + if (MOZ_UNLIKELY(result.isErr())) { + ErrorLoadingSheet( + aURI, + nsPrintfCString("LoadSheetSync failed with error %" PRIx32, + static_cast<uint32_t>(result.unwrapErr())) + .get(), + aFailureAction); + } + return result.unwrapOr(nullptr); +} + +/* static */ +void GlobalStyleSheetCache::InvalidatePreferenceSheets() { + if (gStyleCache) { + gStyleCache->mContentPreferenceSheet = nullptr; + gStyleCache->mChromePreferenceSheet = nullptr; + } +} + +void GlobalStyleSheetCache::BuildPreferenceSheet( + RefPtr<StyleSheet>* aSheet, const PreferenceSheet::Prefs& aPrefs) { + *aSheet = new StyleSheet(eAgentSheetFeatures, CORS_NONE, dom::SRIMetadata()); + + StyleSheet* sheet = *aSheet; + + nsCOMPtr<nsIURI> uri; + NS_NewURI(getter_AddRefs(uri), "about:PreferenceStyleSheet"); + MOZ_ASSERT(uri, "URI creation shouldn't fail"); + + sheet->SetURIs(uri, uri, uri); + sheet->SetComplete(); + + static const uint32_t kPreallocSize = 1024; + + nsCString sheetText; + sheetText.SetCapacity(kPreallocSize); + +#define NS_GET_R_G_B(color_) \ + NS_GET_R(color_), NS_GET_G(color_), NS_GET_B(color_) + + sheetText.AppendLiteral( + "@namespace url(http://www.w3.org/1999/xhtml);\n" + "@namespace svg url(http://www.w3.org/2000/svg);\n"); + + // Rules for link styling. + const bool underlineLinks = StaticPrefs::browser_underline_anchors(); + sheetText.AppendPrintf("*|*:any-link%s { text-decoration: %s; }\n", + underlineLinks ? ":not(svg|a)" : "", + underlineLinks ? "underline" : "none"); + + // Rules for focus styling. + + const bool focusRingOnAnything = + StaticPrefs::browser_display_focus_ring_on_anything(); + uint8_t focusRingWidth = StaticPrefs::browser_display_focus_ring_width(); + uint8_t focusRingStyle = StaticPrefs::browser_display_focus_ring_style(); + + if ((focusRingWidth != 1 && focusRingWidth <= 4) || focusRingOnAnything) { + if (focusRingWidth != 1) { + // If the focus ring width is different from the default, fix buttons + // with rings. + sheetText.AppendPrintf( + "button::-moz-focus-inner, input[type=\"reset\"]::-moz-focus-inner, " + "input[type=\"button\"]::-moz-focus-inner, " + "input[type=\"submit\"]::-moz-focus-inner { " + "border: %dpx %s transparent !important; }\n", + focusRingWidth, focusRingStyle == 0 ? "solid" : "dotted"); + + sheetText.AppendLiteral( + "button:focus::-moz-focus-inner, " + "input[type=\"reset\"]:focus::-moz-focus-inner, " + "input[type=\"button\"]:focus::-moz-focus-inner, " + "input[type=\"submit\"]:focus::-moz-focus-inner { " + "border-color: ButtonText !important; }\n"); + } + + sheetText.AppendPrintf( + "%s { outline: %dpx %s !important; }\n", + focusRingOnAnything ? ":focus" : "*|*:link:focus, *|*:visited:focus", + focusRingWidth, + focusRingStyle == 0 ? "solid -moz-mac-focusring" : "dotted WindowText"); + } + + if (StaticPrefs::browser_display_use_focus_colors()) { + const auto& colors = aPrefs.mLightColors; + nscolor focusText = colors.mFocusText; + nscolor focusBG = colors.mFocusBackground; + sheetText.AppendPrintf( + "*:focus, *:focus > font { color: #%02x%02x%02x !important; " + "background-color: #%02x%02x%02x !important; }\n", + NS_GET_R_G_B(focusText), NS_GET_R_G_B(focusBG)); + } + + NS_ASSERTION(sheetText.Length() <= kPreallocSize, + "kPreallocSize should be big enough to build preference style " + "sheet without reallocation"); + + // NB: The pref sheet never has @import rules, thus no loader. + sheet->ParseSheetSync(nullptr, sheetText, + /* aLoadData = */ nullptr, + /* aLineNumber = */ 0); + +#undef NS_GET_R_G_B +} + +bool GlobalStyleSheetCache::AffectedByPref(const nsACString& aPref) { + const char* prefs[] = { + StaticPrefs::GetPrefName_browser_display_show_focus_rings(), + StaticPrefs::GetPrefName_browser_display_focus_ring_style(), + StaticPrefs::GetPrefName_browser_display_focus_ring_width(), + StaticPrefs::GetPrefName_browser_display_focus_ring_on_anything(), + StaticPrefs::GetPrefName_browser_display_use_focus_colors(), + StaticPrefs::GetPrefName_browser_underline_anchors(), + }; + + for (const char* pref : prefs) { + if (aPref.Equals(pref)) { + return true; + } + } + + return false; +} + +/* static */ void GlobalStyleSheetCache::SetSharedMemory( + base::SharedMemoryHandle aHandle, uintptr_t aAddress) { + MOZ_ASSERT(!XRE_IsParentProcess()); + MOZ_ASSERT(!gStyleCache, "Too late, GlobalStyleSheetCache already created!"); + MOZ_ASSERT(!sSharedMemory, "Shouldn't call this more than once"); + + auto shm = MakeUnique<base::SharedMemory>(); + if (!shm->SetHandle(std::move(aHandle), /* read_only */ true)) { + return; + } + + if (shm->Map(kSharedMemorySize, reinterpret_cast<void*>(aAddress))) { + sSharedMemory = shm.release(); + } +} + +base::SharedMemoryHandle GlobalStyleSheetCache::CloneHandle() { + MOZ_ASSERT(XRE_IsParentProcess()); + if (sSharedMemory) { + return sSharedMemory->CloneHandle(); + } + return nullptr; +} + +StaticRefPtr<GlobalStyleSheetCache> GlobalStyleSheetCache::gStyleCache; +StaticRefPtr<css::Loader> GlobalStyleSheetCache::gCSSLoader; +StaticRefPtr<nsIURI> GlobalStyleSheetCache::gUserContentSheetURL; + +StaticAutoPtr<base::SharedMemory> GlobalStyleSheetCache::sSharedMemory; +size_t GlobalStyleSheetCache::sUsedSharedMemory; + +} // namespace mozilla |