--- a/modules/libpref/nsPrefBranch.cpp
+++ b/modules/libpref/nsPrefBranch.cpp
@@ -1,40 +1,38 @@
/* -*- 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 "mozilla/dom/ContentChild.h"
-#include "nsXULAppAPI.h"
-
-#include "nsPrefBranch.h"
+#include "mozilla/Services.h"
+#include "nsCRT.h"
+#include "nsIConsoleService.h"
+#include "nsIDirectoryService.h"
#include "nsIFile.h"
#include "nsIObserverService.h"
-#include "nsXPCOM.h"
+#include "nsIStringBundle.h"
#include "nsISupportsPrimitives.h"
-#include "nsIDirectoryService.h"
-#include "nsString.h"
-#include "nsReadableUtils.h"
+#include "nsPrefBranch.h"
#include "nsPrintfCString.h"
-#include "nsIStringBundle.h"
-#include "prefapi.h"
+#include "nsReadableUtils.h"
+#include "nsString.h"
+#include "nsXPCOM.h"
+#include "nsXULAppAPI.h"
#include "PLDHashTable.h"
-
-#include "nsCRT.h"
-#include "mozilla/Services.h"
-
+#include "prefapi.h"
#include "prefapi_private_data.h"
#ifdef MOZ_CRASHREPORTER
#include "nsICrashReporter.h"
#endif
-#include "nsIConsoleService.h"
+using mozilla::dom::ContentChild;
#ifdef DEBUG
#define ENSURE_MAIN_PROCESS(message, pref) \
do { \
if (GetContentChild()) { \
nsPrintfCString msg("ENSURE_MAIN_PROCESS failed. %s %s", message, pref); \
NS_ERROR(msg.get()); \
return NS_ERROR_NOT_AVAILABLE; \
@@ -42,195 +40,201 @@
} while (0);
#else
#define ENSURE_MAIN_PROCESS(message, pref) \
if (GetContentChild()) { \
return NS_ERROR_NOT_AVAILABLE; \
}
#endif
-using mozilla::dom::ContentChild;
-
static ContentChild*
GetContentChild()
{
if (XRE_IsContentProcess()) {
ContentChild* cpc = ContentChild::GetSingleton();
if (!cpc) {
MOZ_CRASH("Content Protocol is NULL! We're going to crash!");
}
return cpc;
}
return nullptr;
}
-/*
- * Constructor/Destructor
- */
+//
+// Constructor/Destructor
+//
nsPrefBranch::nsPrefBranch(const char* aPrefRoot, bool aDefaultBranch)
: mPrefRoot(aPrefRoot)
, mIsDefault(aDefaultBranch)
, mFreeingObserverList(false)
, mObservers()
{
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
if (observerService) {
- ++mRefCnt; // Our refcnt must be > 0 when we call this, or we'll get deleted!
- // add weak so we don't have to clean up at shutdown
+ ++mRefCnt; // must be > 0 when we call this, or we'll get deleted!
+
+ // Add weakly so we don't have to clean up at shutdown.
observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true);
--mRefCnt;
}
}
nsPrefBranch::~nsPrefBranch()
{
freeObserverList();
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
- if (observerService)
+ if (observerService) {
observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
+ }
}
-/*
- * nsISupports Implementation
- */
+//
+// nsISupports Implementation
+//
NS_IMPL_ADDREF(nsPrefBranch)
NS_IMPL_RELEASE(nsPrefBranch)
NS_INTERFACE_MAP_BEGIN(nsPrefBranch)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIPrefBranch)
NS_INTERFACE_MAP_ENTRY(nsIPrefBranch)
NS_INTERFACE_MAP_ENTRY(nsIObserver)
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
NS_INTERFACE_MAP_END
-/*
- * nsIPrefBranch Implementation
- */
+//
+// nsIPrefBranch Implementation
+//
NS_IMETHODIMP
nsPrefBranch::GetRoot(char** aRoot)
{
NS_ENSURE_ARG_POINTER(aRoot);
+
*aRoot = ToNewCString(mPrefRoot);
return NS_OK;
}
NS_IMETHODIMP
-nsPrefBranch::GetPrefType(const char* aPrefName, int32_t* _retval)
+nsPrefBranch::GetPrefType(const char* aPrefName, int32_t* aRetVal)
{
NS_ENSURE_ARG(aPrefName);
const PrefName& pref = getPrefName(aPrefName);
switch (PREF_GetPrefType(pref.get())) {
case PrefType::String:
- *_retval = PREF_STRING;
+ *aRetVal = PREF_STRING;
break;
+
case PrefType::Int:
- *_retval = PREF_INT;
+ *aRetVal = PREF_INT;
break;
+
case PrefType::Bool:
- *_retval = PREF_BOOL;
+ *aRetVal = PREF_BOOL;
break;
+
case PrefType::Invalid:
default:
- *_retval = PREF_INVALID;
+ *aRetVal = PREF_INVALID;
break;
}
return NS_OK;
}
NS_IMETHODIMP
nsPrefBranch::GetBoolPrefWithDefault(const char* aPrefName,
bool aDefaultValue,
- uint8_t _argc,
- bool* _retval)
+ uint8_t aArgc,
+ bool* aRetVal)
{
- nsresult rv = GetBoolPref(aPrefName, _retval);
-
- if (NS_FAILED(rv) && _argc == 1) {
- *_retval = aDefaultValue;
+ nsresult rv = GetBoolPref(aPrefName, aRetVal);
+ if (NS_FAILED(rv) && aArgc == 1) {
+ *aRetVal = aDefaultValue;
return NS_OK;
}
return rv;
}
NS_IMETHODIMP
-nsPrefBranch::GetBoolPref(const char* aPrefName, bool* _retval)
+nsPrefBranch::GetBoolPref(const char* aPrefName, bool* aRetVal)
{
NS_ENSURE_ARG(aPrefName);
+
const PrefName& pref = getPrefName(aPrefName);
- return PREF_GetBoolPref(pref.get(), _retval, mIsDefault);
+ return PREF_GetBoolPref(pref.get(), aRetVal, mIsDefault);
}
NS_IMETHODIMP
nsPrefBranch::SetBoolPref(const char* aPrefName, bool aValue)
{
ENSURE_MAIN_PROCESS("Cannot SetBoolPref from content process:", aPrefName);
NS_ENSURE_ARG(aPrefName);
+
const PrefName& pref = getPrefName(aPrefName);
return PREF_SetBoolPref(pref.get(), aValue, mIsDefault);
}
NS_IMETHODIMP
nsPrefBranch::GetFloatPrefWithDefault(const char* aPrefName,
float aDefaultValue,
- uint8_t _argc,
- float* _retval)
+ uint8_t aArgc,
+ float* aRetVal)
{
- nsresult rv = GetFloatPref(aPrefName, _retval);
+ nsresult rv = GetFloatPref(aPrefName, aRetVal);
- if (NS_FAILED(rv) && _argc == 1) {
- *_retval = aDefaultValue;
+ if (NS_FAILED(rv) && aArgc == 1) {
+ *aRetVal = aDefaultValue;
return NS_OK;
}
return rv;
}
NS_IMETHODIMP
-nsPrefBranch::GetFloatPref(const char* aPrefName, float* _retval)
+nsPrefBranch::GetFloatPref(const char* aPrefName, float* aRetVal)
{
NS_ENSURE_ARG(aPrefName);
+
nsAutoCString stringVal;
nsresult rv = GetCharPref(aPrefName, getter_Copies(stringVal));
if (NS_SUCCEEDED(rv)) {
- *_retval = stringVal.ToFloat(&rv);
+ *aRetVal = stringVal.ToFloat(&rv);
}
return rv;
}
NS_IMETHODIMP
nsPrefBranch::GetCharPrefWithDefault(const char* aPrefName,
const char* aDefaultValue,
- uint8_t _argc,
- char** _retval)
+ uint8_t aArgc,
+ char** aRetVal)
{
- nsresult rv = GetCharPref(aPrefName, _retval);
+ nsresult rv = GetCharPref(aPrefName, aRetVal);
- if (NS_FAILED(rv) && _argc == 1) {
+ if (NS_FAILED(rv) && aArgc == 1) {
NS_ENSURE_ARG(aDefaultValue);
- *_retval = NS_strdup(aDefaultValue);
+ *aRetVal = NS_strdup(aDefaultValue);
return NS_OK;
}
return rv;
}
NS_IMETHODIMP
-nsPrefBranch::GetCharPref(const char* aPrefName, char** _retval)
+nsPrefBranch::GetCharPref(const char* aPrefName, char** aRetVal)
{
NS_ENSURE_ARG(aPrefName);
const PrefName& pref = getPrefName(aPrefName);
- return PREF_CopyCharPref(pref.get(), _retval, mIsDefault);
+ return PREF_CopyCharPref(pref.get(), aRetVal, mIsDefault);
}
NS_IMETHODIMP
nsPrefBranch::SetCharPref(const char* aPrefName, const char* aValue)
{
nsresult rv = CheckSanityOfStringLength(aPrefName, aValue);
if (NS_FAILED(rv)) {
return rv;
@@ -240,35 +244,36 @@ nsPrefBranch::SetCharPref(const char* aP
nsresult
nsPrefBranch::SetCharPrefInternal(const char* aPrefName, const char* aValue)
{
ENSURE_MAIN_PROCESS("Cannot SetCharPref from content process:", aPrefName);
NS_ENSURE_ARG(aPrefName);
NS_ENSURE_ARG(aValue);
+
const PrefName& pref = getPrefName(aPrefName);
return PREF_SetCharPref(pref.get(), aValue, mIsDefault);
}
NS_IMETHODIMP
nsPrefBranch::GetStringPref(const char* aPrefName,
const nsACString& aDefaultValue,
- uint8_t _argc,
- nsACString& _retval)
+ uint8_t aArgc,
+ nsACString& aRetVal)
{
nsCString utf8String;
nsresult rv = GetCharPref(aPrefName, getter_Copies(utf8String));
if (NS_SUCCEEDED(rv)) {
- _retval = utf8String;
+ aRetVal = utf8String;
return rv;
}
- if (_argc == 1) {
- _retval = aDefaultValue;
+ if (aArgc == 1) {
+ aRetVal = aDefaultValue;
return NS_OK;
}
return rv;
}
NS_IMETHODIMP
nsPrefBranch::SetStringPref(const char* aPrefName, const nsACString& aValue)
@@ -279,62 +284,63 @@ nsPrefBranch::SetStringPref(const char*
}
return SetCharPrefInternal(aPrefName, PromiseFlatCString(aValue).get());
}
NS_IMETHODIMP
nsPrefBranch::GetIntPrefWithDefault(const char* aPrefName,
int32_t aDefaultValue,
- uint8_t _argc,
- int32_t* _retval)
+ uint8_t aArgc,
+ int32_t* aRetVal)
{
- nsresult rv = GetIntPref(aPrefName, _retval);
+ nsresult rv = GetIntPref(aPrefName, aRetVal);
- if (NS_FAILED(rv) && _argc == 1) {
- *_retval = aDefaultValue;
+ if (NS_FAILED(rv) && aArgc == 1) {
+ *aRetVal = aDefaultValue;
return NS_OK;
}
return rv;
}
NS_IMETHODIMP
-nsPrefBranch::GetIntPref(const char* aPrefName, int32_t* _retval)
+nsPrefBranch::GetIntPref(const char* aPrefName, int32_t* aRetVal)
{
NS_ENSURE_ARG(aPrefName);
const PrefName& pref = getPrefName(aPrefName);
- return PREF_GetIntPref(pref.get(), _retval, mIsDefault);
+ return PREF_GetIntPref(pref.get(), aRetVal, mIsDefault);
}
NS_IMETHODIMP
nsPrefBranch::SetIntPref(const char* aPrefName, int32_t aValue)
{
ENSURE_MAIN_PROCESS("Cannot SetIntPref from content process:", aPrefName);
NS_ENSURE_ARG(aPrefName);
const PrefName& pref = getPrefName(aPrefName);
return PREF_SetIntPref(pref.get(), aValue, mIsDefault);
}
NS_IMETHODIMP
nsPrefBranch::GetComplexValue(const char* aPrefName,
const nsIID& aType,
- void** _retval)
+ void** aRetVal)
{
NS_ENSURE_ARG(aPrefName);
nsresult rv;
nsCString utf8String;
// we have to do this one first because it's different than all the rest
if (aType.Equals(NS_GET_IID(nsIPrefLocalizedString))) {
nsCOMPtr<nsIPrefLocalizedString> theString(
do_CreateInstance(NS_PREFLOCALIZEDSTRING_CONTRACTID, &rv));
- if (NS_FAILED(rv))
+ if (NS_FAILED(rv)) {
return rv;
+ }
const PrefName& pref = getPrefName(aPrefName);
bool bNeedDefault = false;
if (mIsDefault) {
bNeedDefault = true;
} else {
// if there is no user (or locked) value
@@ -354,17 +360,17 @@ nsPrefBranch::GetComplexValue(const char
} else {
rv = GetCharPref(aPrefName, getter_Copies(utf8String));
if (NS_SUCCEEDED(rv)) {
theString->SetData(NS_ConvertUTF8toUTF16(utf8String).get());
}
}
if (NS_SUCCEEDED(rv)) {
- theString.forget(reinterpret_cast<nsIPrefLocalizedString**>(_retval));
+ theString.forget(reinterpret_cast<nsIPrefLocalizedString**>(aRetVal));
}
return rv;
}
// if we can't get the pref, there's no point in being here
rv = GetCharPref(aPrefName, getter_Copies(utf8String));
if (NS_FAILED(rv)) {
@@ -377,17 +383,17 @@ nsPrefBranch::GetComplexValue(const char
return NS_ERROR_NOT_AVAILABLE;
}
nsCOMPtr<nsIFile> file(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv));
if (NS_SUCCEEDED(rv)) {
rv = file->SetPersistentDescriptor(utf8String);
if (NS_SUCCEEDED(rv)) {
- file.forget(reinterpret_cast<nsIFile**>(_retval));
+ file.forget(reinterpret_cast<nsIFile**>(aRetVal));
return NS_OK;
}
}
return rv;
}
if (aType.Equals(NS_GET_IID(nsIRelativeFilePref))) {
if (GetContentChild()) {
@@ -395,46 +401,58 @@ nsPrefBranch::GetComplexValue(const char
return NS_ERROR_NOT_AVAILABLE;
}
nsACString::const_iterator keyBegin, strEnd;
utf8String.BeginReading(keyBegin);
utf8String.EndReading(strEnd);
// The pref has the format: [fromKey]a/b/c
- if (*keyBegin++ != '[')
+ if (*keyBegin++ != '[') {
return NS_ERROR_FAILURE;
+ }
+
nsACString::const_iterator keyEnd(keyBegin);
- if (!FindCharInReadable(']', keyEnd, strEnd))
+ if (!FindCharInReadable(']', keyEnd, strEnd)) {
return NS_ERROR_FAILURE;
+ }
+
nsAutoCString key(Substring(keyBegin, keyEnd));
nsCOMPtr<nsIFile> fromFile;
nsCOMPtr<nsIProperties> directoryService(
do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv));
- if (NS_FAILED(rv))
+ if (NS_FAILED(rv)) {
return rv;
+ }
+
rv = directoryService->Get(
key.get(), NS_GET_IID(nsIFile), getter_AddRefs(fromFile));
- if (NS_FAILED(rv))
+ if (NS_FAILED(rv)) {
return rv;
+ }
nsCOMPtr<nsIFile> theFile;
rv = NS_NewNativeLocalFile(EmptyCString(), true, getter_AddRefs(theFile));
- if (NS_FAILED(rv))
+ if (NS_FAILED(rv)) {
return rv;
+ }
+
rv = theFile->SetRelativeDescriptor(fromFile, Substring(++keyEnd, strEnd));
- if (NS_FAILED(rv))
+ if (NS_FAILED(rv)) {
return rv;
+ }
+
nsCOMPtr<nsIRelativeFilePref> relativePref;
rv = NS_NewRelativeFilePref(theFile, key, getter_AddRefs(relativePref));
- if (NS_FAILED(rv))
+ if (NS_FAILED(rv)) {
return rv;
+ }
- relativePref.forget(reinterpret_cast<nsIRelativeFilePref**>(_retval));
+ relativePref.forget(reinterpret_cast<nsIRelativeFilePref**>(aRetVal));
return NS_OK;
}
if (aType.Equals(NS_GET_IID(nsISupportsString))) {
nsCOMPtr<nsISupportsString> theString(
do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv));
if (NS_SUCCEEDED(rv)) {
@@ -450,17 +468,17 @@ nsPrefBranch::GetComplexValue(const char
nsPrintfCString("%x", utf8String.Length()));
cr->RegisterAppMemory(uint64_t(utf8String.BeginReading()),
std::min(0x1000U, utf8String.Length()));
}
#endif
MOZ_CRASH("bug836263");
}
theString->SetData(wdata);
- theString.forget(reinterpret_cast<nsISupportsString**>(_retval));
+ theString.forget(reinterpret_cast<nsISupportsString**>(aRetVal));
}
return rv;
}
NS_WARNING("nsPrefBranch::GetComplexValue - Unsupported interface type");
return NS_NOINTERFACE;
}
@@ -493,46 +511,49 @@ nsPrefBranch::CheckSanityOfStringLength(
const uint32_t aLength)
{
if (aLength > MAX_PREF_LENGTH) {
return NS_ERROR_ILLEGAL_VALUE;
}
if (aLength <= MAX_ADVISABLE_PREF_LENGTH) {
return NS_OK;
}
+
nsresult rv;
nsCOMPtr<nsIConsoleService> console =
do_GetService("@mozilla.org/consoleservice;1", &rv);
if (NS_FAILED(rv)) {
return rv;
}
+
nsAutoCString message(nsPrintfCString(
"Warning: attempting to write %d bytes to preference %s. This is bad "
"for general performance and memory usage. Such an amount of data "
"should rather be written to an external file. This preference will "
"not be sent to any content processes.",
aLength,
getPrefName(aPrefName).get()));
+
rv = console->LogStringMessage(NS_ConvertUTF8toUTF16(message).get());
if (NS_FAILED(rv)) {
return rv;
}
return NS_OK;
}
-/*static*/
-void
+/* static */ void
nsPrefBranch::ReportToConsole(const nsAString& aMessage)
{
nsresult rv;
nsCOMPtr<nsIConsoleService> console =
do_GetService("@mozilla.org/consoleservice;1", &rv);
if (NS_FAILED(rv)) {
return;
}
+
nsAutoString message(aMessage);
console->LogStringMessage(message.get());
}
NS_IMETHODIMP
nsPrefBranch::SetComplexValue(const char* aPrefName,
const nsIID& aType,
nsISupports* aValue)
@@ -540,53 +561,61 @@ nsPrefBranch::SetComplexValue(const char
ENSURE_MAIN_PROCESS("Cannot SetComplexValue from content process:",
aPrefName);
NS_ENSURE_ARG(aPrefName);
nsresult rv = NS_NOINTERFACE;
if (aType.Equals(NS_GET_IID(nsIFile))) {
nsCOMPtr<nsIFile> file = do_QueryInterface(aValue);
- if (!file)
+ if (!file) {
return NS_NOINTERFACE;
+ }
+
nsAutoCString descriptorString;
-
rv = file->GetPersistentDescriptor(descriptorString);
if (NS_SUCCEEDED(rv)) {
rv = SetCharPrefInternal(aPrefName, descriptorString.get());
}
return rv;
}
if (aType.Equals(NS_GET_IID(nsIRelativeFilePref))) {
nsCOMPtr<nsIRelativeFilePref> relFilePref = do_QueryInterface(aValue);
- if (!relFilePref)
+ if (!relFilePref) {
return NS_NOINTERFACE;
+ }
nsCOMPtr<nsIFile> file;
relFilePref->GetFile(getter_AddRefs(file));
- if (!file)
+ if (!file) {
return NS_NOINTERFACE;
+ }
+
nsAutoCString relativeToKey;
(void)relFilePref->GetRelativeToKey(relativeToKey);
nsCOMPtr<nsIFile> relativeToFile;
nsCOMPtr<nsIProperties> directoryService(
do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv));
- if (NS_FAILED(rv))
+ if (NS_FAILED(rv)) {
return rv;
+ }
+
rv = directoryService->Get(
relativeToKey.get(), NS_GET_IID(nsIFile), getter_AddRefs(relativeToFile));
- if (NS_FAILED(rv))
+ if (NS_FAILED(rv)) {
return rv;
+ }
nsAutoCString relDescriptor;
rv = file->GetRelativeDescriptor(relativeToFile, relDescriptor);
- if (NS_FAILED(rv))
+ if (NS_FAILED(rv)) {
return rv;
+ }
nsAutoCString descriptorString;
descriptorString.Append('[');
descriptorString.Append(relativeToKey);
descriptorString.Append(']');
descriptorString.Append(relDescriptor);
return SetCharPrefInternal(aPrefName, descriptorString.get());
}
@@ -634,71 +663,77 @@ nsPrefBranch::SetComplexValue(const char
return NS_NOINTERFACE;
}
NS_IMETHODIMP
nsPrefBranch::ClearUserPref(const char* aPrefName)
{
ENSURE_MAIN_PROCESS("Cannot ClearUserPref from content process:", aPrefName);
NS_ENSURE_ARG(aPrefName);
+
const PrefName& pref = getPrefName(aPrefName);
return PREF_ClearUserPref(pref.get());
}
NS_IMETHODIMP
-nsPrefBranch::PrefHasUserValue(const char* aPrefName, bool* _retval)
+nsPrefBranch::PrefHasUserValue(const char* aPrefName, bool* aRetVal)
{
- NS_ENSURE_ARG_POINTER(_retval);
+ NS_ENSURE_ARG_POINTER(aRetVal);
NS_ENSURE_ARG(aPrefName);
+
const PrefName& pref = getPrefName(aPrefName);
- *_retval = PREF_HasUserPref(pref.get());
+ *aRetVal = PREF_HasUserPref(pref.get());
return NS_OK;
}
NS_IMETHODIMP
nsPrefBranch::LockPref(const char* aPrefName)
{
ENSURE_MAIN_PROCESS("Cannot LockPref from content process:", aPrefName);
NS_ENSURE_ARG(aPrefName);
+
const PrefName& pref = getPrefName(aPrefName);
return PREF_LockPref(pref.get(), true);
}
NS_IMETHODIMP
-nsPrefBranch::PrefIsLocked(const char* aPrefName, bool* _retval)
+nsPrefBranch::PrefIsLocked(const char* aPrefName, bool* aRetVal)
{
ENSURE_MAIN_PROCESS("Cannot check PrefIsLocked from content process:",
aPrefName);
- NS_ENSURE_ARG_POINTER(_retval);
+ NS_ENSURE_ARG_POINTER(aRetVal);
NS_ENSURE_ARG(aPrefName);
+
const PrefName& pref = getPrefName(aPrefName);
- *_retval = PREF_PrefIsLocked(pref.get());
+ *aRetVal = PREF_PrefIsLocked(pref.get());
return NS_OK;
}
NS_IMETHODIMP
nsPrefBranch::UnlockPref(const char* aPrefName)
{
ENSURE_MAIN_PROCESS("Cannot UnlockPref from content process:", aPrefName);
NS_ENSURE_ARG(aPrefName);
+
const PrefName& pref = getPrefName(aPrefName);
return PREF_LockPref(pref.get(), false);
}
NS_IMETHODIMP
nsPrefBranch::ResetBranch(const char* aStartingAt)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsPrefBranch::DeleteBranch(const char* aStartingAt)
{
ENSURE_MAIN_PROCESS("Cannot DeleteBranch from content process:", aStartingAt);
NS_ENSURE_ARG(aStartingAt);
+
const PrefName& pref = getPrefName(aStartingAt);
return PREF_DeleteBranch(pref.get());
}
NS_IMETHODIMP
nsPrefBranch::GetChildList(const char* aStartingAt,
uint32_t* aCount,
char*** aChildArray)
@@ -710,47 +745,48 @@ nsPrefBranch::GetChildList(const char* a
NS_ENSURE_ARG(aStartingAt);
NS_ENSURE_ARG_POINTER(aCount);
NS_ENSURE_ARG_POINTER(aChildArray);
*aChildArray = nullptr;
*aCount = 0;
- // this will contain a list of all the pref name strings
- // allocate on the stack for speed
+ // This will contain a list of all the pref name strings. Allocated on the
+ // stack for speed.
const PrefName& parent = getPrefName(aStartingAt);
size_t parentLen = parent.Length();
for (auto iter = gHashTable->Iter(); !iter.Done(); iter.Next()) {
auto entry = static_cast<PrefHashEntry*>(iter.Get());
if (strncmp(entry->key, parent.get(), parentLen) == 0) {
prefArray.AppendElement(entry->key);
}
}
- // now that we've built up the list, run the callback on
- // all the matching elements
+ // Now that we've built up the list, run the callback on all the matching
+ // elements.
numPrefs = prefArray.Length();
if (numPrefs) {
outArray = (char**)moz_xmalloc(numPrefs * sizeof(char*));
- if (!outArray)
+ if (!outArray) {
return NS_ERROR_OUT_OF_MEMORY;
+ }
for (dwIndex = 0; dwIndex < numPrefs; ++dwIndex) {
// we need to lop off mPrefRoot in case the user is planning to pass this
// back to us because if they do we are going to add mPrefRoot again.
const nsCString& element = prefArray[dwIndex];
outArray[dwIndex] =
(char*)nsMemory::Clone(element.get() + mPrefRoot.Length(),
element.Length() - mPrefRoot.Length() + 1);
if (!outArray[dwIndex]) {
- // we ran out of memory... this is annoying
+ // We ran out of memory... this is annoying.
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(dwIndex, outArray);
return NS_ERROR_OUT_OF_MEMORY;
}
}
*aChildArray = outArray;
}
*aCount = numPrefs;
@@ -762,22 +798,23 @@ nsPrefBranch::AddObserver(const char* aD
nsIObserver* aObserver,
bool aHoldWeak)
{
PrefCallback* pCallback;
NS_ENSURE_ARG(aDomain);
NS_ENSURE_ARG(aObserver);
- // hold a weak reference to the observer if so requested
+ // Hold a weak reference to the observer if so requested.
if (aHoldWeak) {
nsCOMPtr<nsISupportsWeakReference> weakRefFactory =
do_QueryInterface(aObserver);
if (!weakRefFactory) {
- // the caller didn't give us a object that supports weak reference... tell them
+ // The caller didn't give us a object that supports weak reference...
+ // tell them.
return NS_ERROR_INVALID_ARG;
}
// Construct a PrefCallback with a weak reference to the observer.
pCallback = new PrefCallback(aDomain, weakRefFactory, this);
} else {
// Construct a PrefCallback with a strong reference to the observer.
@@ -811,80 +848,81 @@ nsPrefBranch::RemoveObserver(const char*
// If we're in the middle of a call to freeObserverList, don't process this
// RemoveObserver call -- the observer in question will be removed soon, if
// it hasn't been already.
//
// It's important that we don't touch mObservers in any way -- even a Get()
// which returns null might cause the hashtable to resize itself, which will
// break the iteration in freeObserverList.
- if (mFreeingObserverList)
+ if (mFreeingObserverList) {
return NS_OK;
+ }
- // Remove the relevant PrefCallback from mObservers and get an owning
- // pointer to it. Unregister the callback first, and then let the owning
- // pointer go out of scope and destroy the callback.
+ // Remove the relevant PrefCallback from mObservers and get an owning pointer
+ // to it. Unregister the callback first, and then let the owning pointer go
+ // out of scope and destroy the callback.
PrefCallback key(aDomain, aObserver, this);
nsAutoPtr<PrefCallback> pCallback;
mObservers.Remove(&key, &pCallback);
if (pCallback) {
- // aDomain == nullptr is the only possible failure, trapped above
+ // aDomain == nullptr is the only possible failure, trapped above.
const PrefName& pref = getPrefName(aDomain);
rv = PREF_UnregisterCallback(pref.get(), NotifyObserver, pCallback);
}
return rv;
}
NS_IMETHODIMP
nsPrefBranch::Observe(nsISupports* aSubject,
const char* aTopic,
- const char16_t* someData)
+ const char16_t* aData)
{
- // watch for xpcom shutdown and free our observers to eliminate any cyclic references
+ // Watch for xpcom shutdown and free our observers to eliminate any cyclic
+ // references.
if (!nsCRT::strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
freeObserverList();
}
return NS_OK;
}
-/* static */
-void
-nsPrefBranch::NotifyObserver(const char* newpref, void* data)
+/* static */ void
+nsPrefBranch::NotifyObserver(const char* aNewPref, void* aData)
{
- PrefCallback* pCallback = (PrefCallback*)data;
+ PrefCallback* pCallback = (PrefCallback*)aData;
nsCOMPtr<nsIObserver> observer = pCallback->GetObserver();
if (!observer) {
// The observer has expired. Let's remove this callback.
pCallback->GetPrefBranch()->RemoveExpiredCallback(pCallback);
return;
}
- // remove any root this string may contain so as to not confuse the observer
- // by passing them something other than what they passed us as a topic
+ // Remove any root this string may contain so as to not confuse the observer
+ // by passing them something other than what they passed us as a topic.
uint32_t len = pCallback->GetPrefBranch()->GetRootLength();
- nsAutoCString suffix(newpref + len);
+ nsAutoCString suffix(aNewPref + len);
observer->Observe(static_cast<nsIPrefBranch*>(pCallback->GetPrefBranch()),
NS_PREFBRANCH_PREFCHANGE_TOPIC_ID,
NS_ConvertASCIItoUTF16(suffix).get());
}
size_t
nsPrefBranch::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)
{
size_t n = aMallocSizeOf(this);
n += mPrefRoot.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
n += mObservers.ShallowSizeOfExcludingThis(aMallocSizeOf);
return n;
}
void
-nsPrefBranch::freeObserverList(void)
+nsPrefBranch::freeObserverList()
{
// We need to prevent anyone from modifying mObservers while we're iterating
// over it. In particular, some clients will call RemoveObserver() when
// they're removed and destructed via the iterator; we set
// mFreeingObserverList to keep those calls from touching mObservers.
mFreeingObserverList = true;
for (auto iter = mObservers.Iter(); !iter.Done(); iter.Next()) {
nsAutoPtr<PrefCallback>& callback = iter.Data();
@@ -902,62 +940,65 @@ nsPrefBranch::RemoveExpiredCallback(Pref
NS_PRECONDITION(aCallback->IsExpired(), "Callback should be expired.");
mObservers.Remove(aCallback);
}
nsresult
nsPrefBranch::GetDefaultFromPropertiesFile(const char* aPrefName,
nsAString& aReturn)
{
- nsresult rv;
-
- // the default value contains a URL to a .properties file
+ // The default value contains a URL to a .properties file.
nsCString propertyFileURL;
- rv = PREF_CopyCharPref(aPrefName, getter_Copies(propertyFileURL), true);
- if (NS_FAILED(rv))
+ nsresult rv =
+ PREF_CopyCharPref(aPrefName, getter_Copies(propertyFileURL), true);
+ if (NS_FAILED(rv)) {
return rv;
+ }
nsCOMPtr<nsIStringBundleService> bundleService =
mozilla::services::GetStringBundleService();
- if (!bundleService)
+ if (!bundleService) {
return NS_ERROR_FAILURE;
+ }
nsCOMPtr<nsIStringBundle> bundle;
rv =
bundleService->CreateBundle(propertyFileURL.get(), getter_AddRefs(bundle));
- if (NS_FAILED(rv))
+ if (NS_FAILED(rv)) {
return rv;
+ }
return bundle->GetStringFromName(aPrefName, aReturn);
}
nsPrefBranch::PrefName
nsPrefBranch::getPrefName(const char* aPrefName) const
{
NS_ASSERTION(aPrefName, "null pref name!");
- // for speed, avoid strcpy if we can:
- if (mPrefRoot.IsEmpty())
+ // For speed, avoid strcpy if we can.
+ if (mPrefRoot.IsEmpty()) {
return PrefName(aPrefName);
+ }
return PrefName(mPrefRoot + nsDependentCString(aPrefName));
}
//----------------------------------------------------------------------------
// nsPrefLocalizedString
//----------------------------------------------------------------------------
nsPrefLocalizedString::nsPrefLocalizedString() {}
nsPrefLocalizedString::~nsPrefLocalizedString() {}
-/*
- * nsISupports Implementation
- */
+//
+// nsISupports Implementation
+//
NS_IMPL_ADDREF(nsPrefLocalizedString)
NS_IMPL_RELEASE(nsPrefLocalizedString)
NS_INTERFACE_MAP_BEGIN(nsPrefLocalizedString)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIPrefLocalizedString)
NS_INTERFACE_MAP_ENTRY(nsIPrefLocalizedString)
NS_INTERFACE_MAP_ENTRY(nsISupportsString)
@@ -968,45 +1009,49 @@ nsPrefLocalizedString::Init()
{
nsresult rv;
mUnicodeString = do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv);
return rv;
}
NS_IMETHODIMP
-nsPrefLocalizedString::GetData(char16_t** _retval)
+nsPrefLocalizedString::GetData(char16_t** aRetVal)
{
nsAutoString data;
nsresult rv = GetData(data);
- if (NS_FAILED(rv))
+ if (NS_FAILED(rv)) {
return rv;
+ }
- *_retval = ToNewUnicode(data);
- if (!*_retval)
+ *aRetVal = ToNewUnicode(data);
+ if (!*aRetVal) {
return NS_ERROR_OUT_OF_MEMORY;
+ }
return NS_OK;
}
NS_IMETHODIMP
nsPrefLocalizedString::SetData(const char16_t* aData)
{
- if (!aData)
+ if (!aData) {
return SetData(EmptyString());
+ }
return SetData(nsDependentString(aData));
}
NS_IMETHODIMP
nsPrefLocalizedString::SetDataWithLength(uint32_t aLength,
const char16_t* aData)
{
- if (!aData)
+ if (!aData) {
return SetData(EmptyString());
+ }
return SetData(Substring(aData, aLength));
}
//----------------------------------------------------------------------------
// nsRelativeFilePref
//----------------------------------------------------------------------------
NS_IMPL_ISUPPORTS(nsRelativeFilePref, nsIRelativeFilePref)