Bug 1144366 - Switch SpiderMonkey and XPConnect style from |T *t| to |T* t|. r=jorendorff
☠☠ backed out by 5b892d8ef453 ☠ ☠
authorJan de Mooij <jdemooij@mozilla.com>
Sat, 28 Mar 2015 12:08:37 +0100
changeset 266671 0c030f97a04f4e34c138b878c4352423f5e920f9
parent 266670 1715529498c80b2c12338949685487e573b4a51b
child 266672 764b057e1c3f32e5e29de1097fac25b65444f612
push id830
push userraliiev@mozilla.com
push dateFri, 19 Jun 2015 19:24:37 +0000
treeherdermozilla-release@932614382a68 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjorendorff
bugs1144366
milestone39.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1144366 - Switch SpiderMonkey and XPConnect style from |T *t| to |T* t|. r=jorendorff
js/ipc/CPOWTimer.cpp
js/ipc/CrossProcessObjectWrappers.h
js/ipc/JavaScriptBase.h
js/ipc/JavaScriptChild.cpp
js/ipc/JavaScriptChild.h
js/ipc/JavaScriptLogging.h
js/ipc/JavaScriptParent.cpp
js/ipc/JavaScriptParent.h
js/ipc/JavaScriptShared.cpp
js/ipc/JavaScriptShared.h
js/ipc/WrapperAnswer.cpp
js/ipc/WrapperAnswer.h
js/ipc/WrapperOwner.cpp
js/ipc/WrapperOwner.h
js/public/CallArgs.h
js/public/CallNonGenericMethod.h
js/public/CharacterEncoding.h
js/public/Class.h
js/public/Conversions.h
js/public/Debug.h
js/public/GCAPI.h
js/public/HashTable.h
js/public/HeapAPI.h
js/public/Id.h
js/public/MemoryMetrics.h
js/public/Principals.h
js/public/ProfilingFrameIterator.h
js/public/ProfilingStack.h
js/public/Proxy.h
js/public/RootingAPI.h
js/public/StructuredClone.h
js/public/TracingAPI.h
js/public/TrackedOptimizationInfo.h
js/public/UbiNode.h
js/public/UbiNodeTraverse.h
js/public/Utility.h
js/public/Value.h
js/public/Vector.h
js/public/WeakMapPtr.h
js/src/asmjs/AsmJSFrameIterator.cpp
js/src/asmjs/AsmJSFrameIterator.h
js/src/asmjs/AsmJSLink.cpp
js/src/asmjs/AsmJSLink.h
js/src/asmjs/AsmJSModule.cpp
js/src/asmjs/AsmJSModule.h
js/src/asmjs/AsmJSSignalHandlers.cpp
js/src/asmjs/AsmJSSignalHandlers.h
js/src/asmjs/AsmJSValidate.cpp
js/src/asmjs/AsmJSValidate.h
js/src/builtin/AtomicsObject.cpp
js/src/builtin/AtomicsObject.h
js/src/builtin/Eval.cpp
js/src/builtin/Eval.h
js/src/builtin/Intl.cpp
js/src/builtin/Intl.h
js/src/builtin/MapObject.cpp
js/src/builtin/MapObject.h
js/src/builtin/Object.cpp
js/src/builtin/Object.h
js/src/builtin/Profilers.cpp
js/src/builtin/Profilers.h
js/src/builtin/RegExp.cpp
js/src/builtin/RegExp.h
js/src/builtin/SIMD.cpp
js/src/builtin/SIMD.h
js/src/builtin/SymbolObject.cpp
js/src/builtin/SymbolObject.h
js/src/builtin/TestingFunctions.cpp
js/src/builtin/TestingFunctions.h
js/src/builtin/TypedObject.cpp
js/src/builtin/TypedObject.h
js/src/builtin/WeakSetObject.cpp
js/src/builtin/WeakSetObject.h
js/src/ctypes/CTypes.cpp
js/src/ctypes/CTypes.h
js/src/ctypes/Library.cpp
js/src/ctypes/Library.h
js/src/devtools/Instruments.cpp
js/src/devtools/gctrace/gcstats.cpp
js/src/devtools/sharkctl.cpp
js/src/ds/BitArray.h
js/src/ds/FixedSizeHash.h
js/src/ds/IdValuePair.h
js/src/ds/InlineMap.h
js/src/ds/LifoAlloc.cpp
js/src/ds/LifoAlloc.h
js/src/ds/PriorityQueue.h
js/src/ds/Sort.h
js/src/ds/SplayTree.h
js/src/editline/editline.h
js/src/frontend/BytecodeCompiler.cpp
js/src/frontend/BytecodeCompiler.h
js/src/frontend/BytecodeEmitter.cpp
js/src/frontend/BytecodeEmitter.h
js/src/frontend/FoldConstants.cpp
js/src/frontend/FoldConstants.h
js/src/frontend/FullParseHandler.h
js/src/frontend/NameFunctions.cpp
js/src/frontend/NameFunctions.h
js/src/frontend/ParseMaps-inl.h
js/src/frontend/ParseMaps.cpp
js/src/frontend/ParseMaps.h
js/src/frontend/ParseNode-inl.h
js/src/frontend/ParseNode.cpp
js/src/frontend/ParseNode.h
js/src/frontend/Parser-inl.h
js/src/frontend/Parser.cpp
js/src/frontend/Parser.h
js/src/frontend/SharedContext.h
js/src/frontend/SourceNotes.h
js/src/frontend/SyntaxParseHandler.h
js/src/frontend/TokenStream.cpp
js/src/frontend/TokenStream.h
js/src/gc/Allocator.cpp
js/src/gc/Allocator.h
js/src/gc/Barrier.cpp
js/src/gc/Barrier.h
js/src/gc/FindSCCs.h
js/src/gc/GCInternals.h
js/src/gc/GCRuntime.h
js/src/gc/GCTrace.cpp
js/src/gc/GCTrace.h
js/src/gc/Heap.h
js/src/gc/Iteration.cpp
js/src/gc/Marking.cpp
js/src/gc/Marking.h
js/src/gc/Memory.cpp
js/src/gc/Memory.h
js/src/gc/Nursery-inl.h
js/src/gc/Nursery.cpp
js/src/gc/Nursery.h
js/src/gc/RootMarking.cpp
js/src/gc/Statistics.cpp
js/src/gc/Statistics.h
js/src/gc/StoreBuffer.cpp
js/src/gc/StoreBuffer.h
js/src/gc/Tracer.cpp
js/src/gc/Tracer.h
js/src/gc/Verifier.cpp
js/src/gc/Zone.cpp
js/src/gc/Zone.h
js/src/gdb/gdb-tests.cpp
js/src/gdb/gdb-tests.h
js/src/gdb/tests/test-Interpreter.cpp
js/src/gdb/tests/test-JSObject.cpp
js/src/gdb/tests/test-JSString.cpp
js/src/gdb/tests/test-Root.cpp
js/src/gdb/tests/test-jsid.cpp
js/src/irregexp/NativeRegExpMacroAssembler.cpp
js/src/irregexp/NativeRegExpMacroAssembler.h
js/src/irregexp/RegExpAST.cpp
js/src/irregexp/RegExpAST.h
js/src/irregexp/RegExpEngine.cpp
js/src/irregexp/RegExpEngine.h
js/src/irregexp/RegExpInterpreter.cpp
js/src/irregexp/RegExpMacroAssembler.cpp
js/src/irregexp/RegExpMacroAssembler.h
js/src/irregexp/RegExpParser.cpp
js/src/irregexp/RegExpParser.h
js/src/irregexp/RegExpStack.cpp
js/src/irregexp/RegExpStack.h
js/src/jit/AliasAnalysis.cpp
js/src/jit/AliasAnalysis.h
js/src/jit/AlignmentMaskAnalysis.cpp
js/src/jit/AlignmentMaskAnalysis.h
js/src/jit/BacktrackingAllocator.cpp
js/src/jit/BacktrackingAllocator.h
js/src/jit/Bailouts.cpp
js/src/jit/Bailouts.h
js/src/jit/BaselineBailouts.cpp
js/src/jit/BaselineCompiler.cpp
js/src/jit/BaselineCompiler.h
js/src/jit/BaselineDebugModeOSR.cpp
js/src/jit/BaselineDebugModeOSR.h
js/src/jit/BaselineFrame-inl.h
js/src/jit/BaselineFrame.cpp
js/src/jit/BaselineFrame.h
js/src/jit/BaselineFrameInfo.cpp
js/src/jit/BaselineFrameInfo.h
js/src/jit/BaselineIC.cpp
js/src/jit/BaselineIC.h
js/src/jit/BaselineInspector.cpp
js/src/jit/BaselineInspector.h
js/src/jit/BaselineJIT.cpp
js/src/jit/BaselineJIT.h
js/src/jit/BitSet.cpp
js/src/jit/BitSet.h
js/src/jit/BytecodeAnalysis.cpp
js/src/jit/BytecodeAnalysis.h
js/src/jit/C1Spewer.cpp
js/src/jit/C1Spewer.h
js/src/jit/CodeGenerator.cpp
js/src/jit/CodeGenerator.h
js/src/jit/CompactBuffer.h
js/src/jit/CompileInfo-inl.h
js/src/jit/CompileInfo.h
js/src/jit/CompileWrappers.cpp
js/src/jit/CompileWrappers.h
js/src/jit/Disassembler.cpp
js/src/jit/Disassembler.h
js/src/jit/EagerSimdUnbox.cpp
js/src/jit/EagerSimdUnbox.h
js/src/jit/EdgeCaseAnalysis.cpp
js/src/jit/EdgeCaseAnalysis.h
js/src/jit/EffectiveAddressAnalysis.cpp
js/src/jit/EffectiveAddressAnalysis.h
js/src/jit/ExecutableAllocator.cpp
js/src/jit/ExecutableAllocator.h
js/src/jit/ExecutableAllocatorPosix.cpp
js/src/jit/ExecutableAllocatorWin.cpp
js/src/jit/FixedList.h
js/src/jit/InlineList.h
js/src/jit/Ion.cpp
js/src/jit/Ion.h
js/src/jit/IonAnalysis.cpp
js/src/jit/IonAnalysis.h
js/src/jit/IonBuilder.cpp
js/src/jit/IonBuilder.h
js/src/jit/IonCaches.cpp
js/src/jit/IonCaches.h
js/src/jit/IonCode.h
js/src/jit/IonInstrumentation.h
js/src/jit/IonOptimizationLevels.cpp
js/src/jit/IonOptimizationLevels.h
js/src/jit/IonTypes.h
js/src/jit/JSONSpewer.cpp
js/src/jit/JSONSpewer.h
js/src/jit/JitAllocPolicy.h
js/src/jit/JitCommon.h
js/src/jit/JitCompartment.h
js/src/jit/JitFrameIterator-inl.h
js/src/jit/JitFrameIterator.h
js/src/jit/JitFrames-inl.h
js/src/jit/JitFrames.cpp
js/src/jit/JitFrames.h
js/src/jit/JitOptions.cpp
js/src/jit/JitOptions.h
js/src/jit/JitSpewer.cpp
js/src/jit/JitSpewer.h
js/src/jit/JitcodeMap.cpp
js/src/jit/JitcodeMap.h
js/src/jit/LICM.cpp
js/src/jit/LICM.h
js/src/jit/LIR-Common.h
js/src/jit/LIR.cpp
js/src/jit/LIR.h
js/src/jit/Label.h
js/src/jit/LinearScan.cpp
js/src/jit/LinearScan.h
js/src/jit/Linker.h
js/src/jit/LiveRangeAllocator.cpp
js/src/jit/LiveRangeAllocator.h
js/src/jit/LoopUnroller.cpp
js/src/jit/LoopUnroller.h
js/src/jit/Lowering.cpp
js/src/jit/Lowering.h
js/src/jit/MCallOptimize.cpp
js/src/jit/MIR.cpp
js/src/jit/MIR.h
js/src/jit/MIRGenerator.h
js/src/jit/MIRGraph.cpp
js/src/jit/MIRGraph.h
js/src/jit/MOpcodes.h
js/src/jit/MacroAssembler.cpp
js/src/jit/MacroAssembler.h
js/src/jit/MoveResolver.cpp
js/src/jit/MoveResolver.h
js/src/jit/OptimizationTracking.cpp
js/src/jit/OptimizationTracking.h
js/src/jit/PcScriptCache.h
js/src/jit/PerfSpewer.cpp
js/src/jit/PerfSpewer.h
js/src/jit/RangeAnalysis.cpp
js/src/jit/RangeAnalysis.h
js/src/jit/Recover.cpp
js/src/jit/Recover.h
js/src/jit/RegisterAllocator.cpp
js/src/jit/RegisterAllocator.h
js/src/jit/RegisterSets.h
js/src/jit/Registers.h
js/src/jit/RematerializedFrame.cpp
js/src/jit/RematerializedFrame.h
js/src/jit/Safepoints.cpp
js/src/jit/Safepoints.h
js/src/jit/ScalarReplacement.cpp
js/src/jit/ScalarReplacement.h
js/src/jit/Sink.cpp
js/src/jit/Sink.h
js/src/jit/Snapshots.cpp
js/src/jit/Snapshots.h
js/src/jit/StupidAllocator.cpp
js/src/jit/StupidAllocator.h
js/src/jit/TypePolicy.cpp
js/src/jit/TypePolicy.h
js/src/jit/TypedObjectPrediction.cpp
js/src/jit/TypedObjectPrediction.h
js/src/jit/VMFunctions.cpp
js/src/jit/VMFunctions.h
js/src/jit/ValueNumbering.cpp
js/src/jit/ValueNumbering.h
js/src/jit/arm/Architecture-arm.cpp
js/src/jit/arm/Architecture-arm.h
js/src/jit/arm/Assembler-arm.cpp
js/src/jit/arm/Assembler-arm.h
js/src/jit/arm/Bailouts-arm.cpp
js/src/jit/arm/BaselineCompiler-arm.cpp
js/src/jit/arm/BaselineCompiler-arm.h
js/src/jit/arm/BaselineHelpers-arm.h
js/src/jit/arm/BaselineIC-arm.cpp
js/src/jit/arm/CodeGenerator-arm.cpp
js/src/jit/arm/CodeGenerator-arm.h
js/src/jit/arm/LIR-arm.h
js/src/jit/arm/Lowering-arm.cpp
js/src/jit/arm/Lowering-arm.h
js/src/jit/arm/MacroAssembler-arm.cpp
js/src/jit/arm/MacroAssembler-arm.h
js/src/jit/arm/MoveEmitter-arm.cpp
js/src/jit/arm/MoveEmitter-arm.h
js/src/jit/arm/Simulator-arm.cpp
js/src/jit/arm/Simulator-arm.h
js/src/jit/arm/Trampoline-arm.cpp
js/src/jit/mips/Architecture-mips.cpp
js/src/jit/mips/Architecture-mips.h
js/src/jit/mips/Assembler-mips.cpp
js/src/jit/mips/Assembler-mips.h
js/src/jit/mips/Bailouts-mips.cpp
js/src/jit/mips/Bailouts-mips.h
js/src/jit/mips/BaselineCompiler-mips.cpp
js/src/jit/mips/BaselineCompiler-mips.h
js/src/jit/mips/BaselineHelpers-mips.h
js/src/jit/mips/BaselineIC-mips.cpp
js/src/jit/mips/CodeGenerator-mips.cpp
js/src/jit/mips/CodeGenerator-mips.h
js/src/jit/mips/LIR-mips.h
js/src/jit/mips/Lowering-mips.cpp
js/src/jit/mips/Lowering-mips.h
js/src/jit/mips/MacroAssembler-mips.cpp
js/src/jit/mips/MacroAssembler-mips.h
js/src/jit/mips/MoveEmitter-mips.cpp
js/src/jit/mips/MoveEmitter-mips.h
js/src/jit/mips/Simulator-mips.cpp
js/src/jit/mips/Simulator-mips.h
js/src/jit/mips/Trampoline-mips.cpp
js/src/jit/none/Architecture-none.h
js/src/jit/none/BaselineCompiler-none.h
js/src/jit/none/BaselineHelpers-none.h
js/src/jit/none/CodeGenerator-none.h
js/src/jit/none/LIR-none.h
js/src/jit/none/Lowering-none.h
js/src/jit/none/MacroAssembler-none.h
js/src/jit/none/MoveEmitter-none.h
js/src/jit/none/Trampoline-none.cpp
js/src/jit/shared/Assembler-shared.h
js/src/jit/shared/Assembler-x86-shared.cpp
js/src/jit/shared/Assembler-x86-shared.h
js/src/jit/shared/AssemblerBuffer-x86-shared.cpp
js/src/jit/shared/AssemblerBuffer-x86-shared.h
js/src/jit/shared/BaseAssembler-x86-shared.h
js/src/jit/shared/BaselineCompiler-shared.cpp
js/src/jit/shared/BaselineCompiler-shared.h
js/src/jit/shared/BaselineCompiler-x86-shared.cpp
js/src/jit/shared/BaselineCompiler-x86-shared.h
js/src/jit/shared/BaselineIC-x86-shared.cpp
js/src/jit/shared/CodeGenerator-shared-inl.h
js/src/jit/shared/CodeGenerator-shared.cpp
js/src/jit/shared/CodeGenerator-shared.h
js/src/jit/shared/CodeGenerator-x86-shared.cpp
js/src/jit/shared/CodeGenerator-x86-shared.h
js/src/jit/shared/Constants-x86-shared.h
js/src/jit/shared/Disassembler-x86-shared.cpp
js/src/jit/shared/IonAssemblerBuffer.h
js/src/jit/shared/IonAssemblerBufferWithConstantPools.h
js/src/jit/shared/LIR-x86-shared.h
js/src/jit/shared/Lowering-shared-inl.h
js/src/jit/shared/Lowering-shared.cpp
js/src/jit/shared/Lowering-shared.h
js/src/jit/shared/Lowering-x86-shared.cpp
js/src/jit/shared/Lowering-x86-shared.h
js/src/jit/shared/MacroAssembler-x86-shared.cpp
js/src/jit/shared/MacroAssembler-x86-shared.h
js/src/jit/shared/MoveEmitter-x86-shared.cpp
js/src/jit/shared/MoveEmitter-x86-shared.h
js/src/jit/shared/Patching-x86-shared.h
js/src/jit/x64/Architecture-x64.h
js/src/jit/x64/Assembler-x64.cpp
js/src/jit/x64/Assembler-x64.h
js/src/jit/x64/Bailouts-x64.cpp
js/src/jit/x64/BaselineCompiler-x64.cpp
js/src/jit/x64/BaselineCompiler-x64.h
js/src/jit/x64/BaselineHelpers-x64.h
js/src/jit/x64/BaselineIC-x64.cpp
js/src/jit/x64/CodeGenerator-x64.cpp
js/src/jit/x64/CodeGenerator-x64.h
js/src/jit/x64/LIR-x64.h
js/src/jit/x64/Lowering-x64.cpp
js/src/jit/x64/Lowering-x64.h
js/src/jit/x64/MacroAssembler-x64.cpp
js/src/jit/x64/MacroAssembler-x64.h
js/src/jit/x64/Trampoline-x64.cpp
js/src/jit/x86/Architecture-x86.h
js/src/jit/x86/Assembler-x86.cpp
js/src/jit/x86/Assembler-x86.h
js/src/jit/x86/Bailouts-x86.cpp
js/src/jit/x86/BaselineCompiler-x86.cpp
js/src/jit/x86/BaselineCompiler-x86.h
js/src/jit/x86/BaselineHelpers-x86.h
js/src/jit/x86/BaselineIC-x86.cpp
js/src/jit/x86/CodeGenerator-x86.cpp
js/src/jit/x86/CodeGenerator-x86.h
js/src/jit/x86/LIR-x86.h
js/src/jit/x86/Lowering-x86.cpp
js/src/jit/x86/Lowering-x86.h
js/src/jit/x86/MacroAssembler-x86.cpp
js/src/jit/x86/MacroAssembler-x86.h
js/src/jit/x86/Trampoline-x86.cpp
js/src/jsalloc.cpp
js/src/jsalloc.h
js/src/jsapi-tests/testAddPropertyPropcache.cpp
js/src/jsapi-tests/testArgumentsObject.cpp
js/src/jsapi-tests/testArrayBuffer.cpp
js/src/jsapi-tests/testArrayBufferView.cpp
js/src/jsapi-tests/testBug604087.cpp
js/src/jsapi-tests/testCallNonGenericMethodOnProxy.cpp
js/src/jsapi-tests/testChromeBuffer.cpp
js/src/jsapi-tests/testClassGetter.cpp
js/src/jsapi-tests/testCloneScript.cpp
js/src/jsapi-tests/testContexts.cpp
js/src/jsapi-tests/testDebugger.cpp
js/src/jsapi-tests/testDefineGetterSetterNonEnumerable.cpp
js/src/jsapi-tests/testDefinePropertyIgnoredAttributes.cpp
js/src/jsapi-tests/testEnclosingFunction.cpp
js/src/jsapi-tests/testErrorCopying.cpp
js/src/jsapi-tests/testExternalStrings.cpp
js/src/jsapi-tests/testFindSCCs.cpp
js/src/jsapi-tests/testFreshGlobalEvalRedefinition.cpp
js/src/jsapi-tests/testGCAllocator.cpp
js/src/jsapi-tests/testGCCellPtr.cpp
js/src/jsapi-tests/testGCChunkPool.cpp
js/src/jsapi-tests/testGCFinalizeCallback.cpp
js/src/jsapi-tests/testGCHeapPostBarriers.cpp
js/src/jsapi-tests/testGCMarking.cpp
js/src/jsapi-tests/testGCNursery.cpp
js/src/jsapi-tests/testGCOutOfMemory.cpp
js/src/jsapi-tests/testGCStoreBufferRemoval.cpp
js/src/jsapi-tests/testHashTable.cpp
js/src/jsapi-tests/testIndexToString.cpp
js/src/jsapi-tests/testIntString.cpp
js/src/jsapi-tests/testIntern.cpp
js/src/jsapi-tests/testIsInsideNursery.cpp
js/src/jsapi-tests/testJitDCEinGVN.cpp
js/src/jsapi-tests/testJitFoldsTo.cpp
js/src/jsapi-tests/testJitGVN.cpp
js/src/jsapi-tests/testJitMinimalFunc.h
js/src/jsapi-tests/testJitMoveEmitterCycles-mips.cpp
js/src/jsapi-tests/testJitMoveEmitterCycles.cpp
js/src/jsapi-tests/testJitRValueAlloc.cpp
js/src/jsapi-tests/testJitRangeAnalysis.cpp
js/src/jsapi-tests/testLookup.cpp
js/src/jsapi-tests/testLooselyEqual.cpp
js/src/jsapi-tests/testMappedArrayBuffer.cpp
js/src/jsapi-tests/testMutedErrors.cpp
js/src/jsapi-tests/testNewObject.cpp
js/src/jsapi-tests/testOOM.cpp
js/src/jsapi-tests/testObjectEmulatingUndefined.cpp
js/src/jsapi-tests/testOps.cpp
js/src/jsapi-tests/testParseJSON.cpp
js/src/jsapi-tests/testPersistentRooted.cpp
js/src/jsapi-tests/testPreserveJitCode.cpp
js/src/jsapi-tests/testProfileStrings.cpp
js/src/jsapi-tests/testPropCache.cpp
js/src/jsapi-tests/testRegExp.cpp
js/src/jsapi-tests/testResolveRecursion.cpp
js/src/jsapi-tests/testSavedStacks.cpp
js/src/jsapi-tests/testScriptInfo.cpp
js/src/jsapi-tests/testScriptObject.cpp
js/src/jsapi-tests/testSetProperty.cpp
js/src/jsapi-tests/testSetPropertyIgnoringNamedGetter.cpp
js/src/jsapi-tests/testSlowScript.cpp
js/src/jsapi-tests/testSourcePolicy.cpp
js/src/jsapi-tests/testStringBuffer.cpp
js/src/jsapi-tests/testTypedArrays.cpp
js/src/jsapi-tests/testUTF8.cpp
js/src/jsapi-tests/testUncaughtError.cpp
js/src/jsapi-tests/testValueABI.cpp
js/src/jsapi-tests/testWeakMap.cpp
js/src/jsapi-tests/testXDR.cpp
js/src/jsapi-tests/tests.cpp
js/src/jsapi-tests/tests.h
js/src/jsapi.cpp
js/src/jsapi.h
js/src/jsarray.cpp
js/src/jsarray.h
js/src/jsatom.cpp
js/src/jsatom.h
js/src/jsatominlines.h
js/src/jsbool.cpp
js/src/jsbool.h
js/src/jsboolinlines.h
js/src/jsclist.h
js/src/jscntxt.cpp
js/src/jscntxt.h
js/src/jscntxtinlines.h
js/src/jscompartment.cpp
js/src/jscompartment.h
js/src/jscompartmentinlines.h
js/src/jsdate.cpp
js/src/jsdate.h
js/src/jsdtoa.cpp
js/src/jsdtoa.h
js/src/jsexn.cpp
js/src/jsexn.h
js/src/jsfriendapi.cpp
js/src/jsfriendapi.h
js/src/jsfun.cpp
js/src/jsfun.h
js/src/jsfuninlines.h
js/src/jsgc.cpp
js/src/jsgc.h
js/src/jsgcinlines.h
js/src/jshashutil.h
js/src/jsiter.cpp
js/src/jsiter.h
js/src/jskwgen.cpp
js/src/jsmath.cpp
js/src/jsmath.h
js/src/jsnativestack.cpp
js/src/jsnativestack.h
js/src/jsnum.cpp
js/src/jsnum.h
js/src/jsobj.cpp
js/src/jsobj.h
js/src/jsobjinlines.h
js/src/json.cpp
js/src/json.h
js/src/jsopcode.cpp
js/src/jsopcode.h
js/src/jsopcodeinlines.h
js/src/jsprf.cpp
js/src/jsprf.h
js/src/jspropertytree.cpp
js/src/jspropertytree.h
js/src/jspubtd.h
js/src/jsreflect.cpp
js/src/jsscript.cpp
js/src/jsscript.h
js/src/jsscriptinlines.h
js/src/jsstr.cpp
js/src/jsstr.h
js/src/jstypes.h
js/src/jsutil.cpp
js/src/jsutil.h
js/src/jswatchpoint.cpp
js/src/jswatchpoint.h
js/src/jsweakcache.h
js/src/jsweakmap.cpp
js/src/jsweakmap.h
js/src/jswrapper.h
js/src/perf/jsperf.cpp
js/src/perf/jsperf.h
js/src/perf/pm_linux.cpp
js/src/prmjtime.cpp
js/src/prmjtime.h
js/src/proxy/BaseProxyHandler.cpp
js/src/proxy/CrossCompartmentWrapper.cpp
js/src/proxy/DeadObjectProxy.cpp
js/src/proxy/DeadObjectProxy.h
js/src/proxy/DirectProxyHandler.cpp
js/src/proxy/Proxy.cpp
js/src/proxy/Proxy.h
js/src/proxy/ScriptedDirectProxyHandler.cpp
js/src/proxy/ScriptedDirectProxyHandler.h
js/src/proxy/ScriptedIndirectProxyHandler.cpp
js/src/proxy/ScriptedIndirectProxyHandler.h
js/src/proxy/SecurityWrapper.cpp
js/src/proxy/Wrapper.cpp
js/src/shell/OSObject.cpp
js/src/shell/OSObject.h
js/src/shell/js.cpp
js/src/shell/jsoptparse.cpp
js/src/shell/jsoptparse.h
js/src/vm/ArgumentsObject-inl.h
js/src/vm/ArgumentsObject.cpp
js/src/vm/ArgumentsObject.h
js/src/vm/ArrayBufferObject-inl.h
js/src/vm/ArrayBufferObject.cpp
js/src/vm/ArrayBufferObject.h
js/src/vm/ArrayObject-inl.h
js/src/vm/ArrayObject.h
js/src/vm/BooleanObject-inl.h
js/src/vm/BooleanObject.h
js/src/vm/CallNonGenericMethod.cpp
js/src/vm/CharacterEncoding.cpp
js/src/vm/Compression.cpp
js/src/vm/Compression.h
js/src/vm/DateObject.h
js/src/vm/DateTime.cpp
js/src/vm/Debugger-inl.h
js/src/vm/Debugger.cpp
js/src/vm/Debugger.h
js/src/vm/DebuggerMemory.cpp
js/src/vm/DebuggerMemory.h
js/src/vm/ErrorObject-inl.h
js/src/vm/ErrorObject.cpp
js/src/vm/ErrorObject.h
js/src/vm/ForOfIterator.cpp
js/src/vm/GeneratorObject.cpp
js/src/vm/GeneratorObject.h
js/src/vm/GlobalObject.cpp
js/src/vm/GlobalObject.h
js/src/vm/HelperThreads.cpp
js/src/vm/HelperThreads.h
js/src/vm/Interpreter-inl.h
js/src/vm/Interpreter.cpp
js/src/vm/Interpreter.h
js/src/vm/JSONParser.cpp
js/src/vm/JSONParser.h
js/src/vm/MallocProvider.h
js/src/vm/MatchPairs.h
js/src/vm/MemoryMetrics.cpp
js/src/vm/Monitor.h
js/src/vm/NativeObject-inl.h
js/src/vm/NativeObject.cpp
js/src/vm/NativeObject.h
js/src/vm/NumberObject-inl.h
js/src/vm/NumberObject.h
js/src/vm/ObjectGroup.cpp
js/src/vm/ObjectGroup.h
js/src/vm/PIC.cpp
js/src/vm/PIC.h
js/src/vm/PosixNSPR.cpp
js/src/vm/PosixNSPR.h
js/src/vm/Probes-inl.h
js/src/vm/Probes.cpp
js/src/vm/Probes.h
js/src/vm/ProxyObject.cpp
js/src/vm/ProxyObject.h
js/src/vm/RegExpObject.cpp
js/src/vm/RegExpObject.h
js/src/vm/RegExpStatics.cpp
js/src/vm/RegExpStatics.h
js/src/vm/Runtime-inl.h
js/src/vm/Runtime.cpp
js/src/vm/Runtime.h
js/src/vm/SPSProfiler.cpp
js/src/vm/SPSProfiler.h
js/src/vm/SavedStacks-inl.h
js/src/vm/SavedStacks.cpp
js/src/vm/SavedStacks.h
js/src/vm/ScopeObject-inl.h
js/src/vm/ScopeObject.cpp
js/src/vm/ScopeObject.h
js/src/vm/SelfHosting.cpp
js/src/vm/SelfHosting.h
js/src/vm/Shape-inl.h
js/src/vm/Shape.cpp
js/src/vm/Shape.h
js/src/vm/SharedArrayObject.cpp
js/src/vm/SharedArrayObject.h
js/src/vm/SharedTypedArrayObject.cpp
js/src/vm/SharedTypedArrayObject.h
js/src/vm/Stack-inl.h
js/src/vm/Stack.cpp
js/src/vm/Stack.h
js/src/vm/String-inl.h
js/src/vm/String.cpp
js/src/vm/String.h
js/src/vm/StringBuffer.cpp
js/src/vm/StringBuffer.h
js/src/vm/StringObject-inl.h
js/src/vm/StringObject.h
js/src/vm/StructuredClone.cpp
js/src/vm/Symbol.cpp
js/src/vm/Symbol.h
js/src/vm/TraceLogging.cpp
js/src/vm/TraceLogging.h
js/src/vm/TraceLoggingGraph.cpp
js/src/vm/TraceLoggingGraph.h
js/src/vm/TraceLoggingTypes.cpp
js/src/vm/TraceLoggingTypes.h
js/src/vm/TypeInference-inl.h
js/src/vm/TypeInference.cpp
js/src/vm/TypeInference.h
js/src/vm/TypedArrayCommon.h
js/src/vm/TypedArrayObject.cpp
js/src/vm/TypedArrayObject.h
js/src/vm/UbiNode.cpp
js/src/vm/UnboxedObject.cpp
js/src/vm/UnboxedObject.h
js/src/vm/Unicode.h
js/src/vm/WeakMapObject.h
js/src/vm/WeakMapPtr.cpp
js/src/vm/Xdr.cpp
js/src/vm/Xdr.h
js/src/vtune/ittnotify_config.h
js/src/vtune/jitprofiling.h
js/xpconnect/loader/mozJSComponentLoader.cpp
js/xpconnect/loader/mozJSComponentLoader.h
js/xpconnect/loader/mozJSLoaderUtils.cpp
js/xpconnect/loader/mozJSLoaderUtils.h
js/xpconnect/loader/mozJSSubScriptLoader.cpp
js/xpconnect/loader/mozJSSubScriptLoader.h
js/xpconnect/public/SandboxPrivate.h
js/xpconnect/public/nsAXPCNativeCallContext.h
js/xpconnect/public/xpc_map_end.h
js/xpconnect/src/BackstagePass.h
js/xpconnect/src/ExportHelpers.cpp
js/xpconnect/src/Sandbox.cpp
js/xpconnect/src/XPCCallContext.cpp
js/xpconnect/src/XPCComponents.cpp
js/xpconnect/src/XPCConvert.cpp
js/xpconnect/src/XPCDebug.cpp
js/xpconnect/src/XPCInlines.h
js/xpconnect/src/XPCJSContextStack.cpp
js/xpconnect/src/XPCJSID.cpp
js/xpconnect/src/XPCJSMemoryReporter.h
js/xpconnect/src/XPCJSRuntime.cpp
js/xpconnect/src/XPCLocale.cpp
js/xpconnect/src/XPCLog.cpp
js/xpconnect/src/XPCLog.h
js/xpconnect/src/XPCMaps.cpp
js/xpconnect/src/XPCMaps.h
js/xpconnect/src/XPCRuntimeService.cpp
js/xpconnect/src/XPCShellImpl.cpp
js/xpconnect/src/XPCString.cpp
js/xpconnect/src/XPCThrower.cpp
js/xpconnect/src/XPCVariant.cpp
js/xpconnect/src/XPCWrappedJS.cpp
js/xpconnect/src/XPCWrappedJSClass.cpp
js/xpconnect/src/XPCWrappedNative.cpp
js/xpconnect/src/XPCWrappedNativeInfo.cpp
js/xpconnect/src/XPCWrappedNativeJSOps.cpp
js/xpconnect/src/XPCWrappedNativeProto.cpp
js/xpconnect/src/XPCWrappedNativeScope.cpp
js/xpconnect/src/XPCWrapper.cpp
js/xpconnect/src/XPCWrapper.h
js/xpconnect/src/nsScriptError.cpp
js/xpconnect/src/nsXPConnect.cpp
js/xpconnect/src/qsObjectHelper.h
js/xpconnect/src/xpcObjectHelper.h
js/xpconnect/src/xpcprivate.h
js/xpconnect/src/xpcpublic.h
js/xpconnect/tests/components/native/xpctest_attributes.cpp
js/xpconnect/tests/components/native/xpctest_params.cpp
js/xpconnect/tests/components/native/xpctest_private.h
js/xpconnect/tests/components/native/xpctest_returncode.cpp
js/xpconnect/wrappers/AccessCheck.cpp
js/xpconnect/wrappers/AccessCheck.h
js/xpconnect/wrappers/AddonWrapper.cpp
js/xpconnect/wrappers/AddonWrapper.h
js/xpconnect/wrappers/ChromeObjectWrapper.cpp
js/xpconnect/wrappers/ChromeObjectWrapper.h
js/xpconnect/wrappers/FilteringWrapper.cpp
js/xpconnect/wrappers/FilteringWrapper.h
js/xpconnect/wrappers/WaiveXrayWrapper.cpp
js/xpconnect/wrappers/WaiveXrayWrapper.h
js/xpconnect/wrappers/WrapperFactory.cpp
js/xpconnect/wrappers/WrapperFactory.h
js/xpconnect/wrappers/XrayWrapper.cpp
js/xpconnect/wrappers/XrayWrapper.h
--- a/js/ipc/CPOWTimer.cpp
+++ b/js/ipc/CPOWTimer.cpp
@@ -7,21 +7,21 @@
 
 #include "jsfriendapi.h"
 #include "xpcprivate.h"
 #include "CPOWTimer.h"
 
 CPOWTimer::~CPOWTimer()
 {
     /* This is a best effort to find the compartment responsible for this CPOW call */
-    nsIGlobalObject *global = mozilla::dom::GetIncumbentGlobal();
+    nsIGlobalObject* global = mozilla::dom::GetIncumbentGlobal();
     if (!global)
         return;
-    JSObject *obj = global->GetGlobalJSObject();
+    JSObject* obj = global->GetGlobalJSObject();
     if (!obj)
         return;
-    JSCompartment *compartment = js::GetObjectCompartment(obj);
-    xpc::CompartmentPrivate *compartmentPrivate = xpc::CompartmentPrivate::Get(compartment);
+    JSCompartment* compartment = js::GetObjectCompartment(obj);
+    xpc::CompartmentPrivate* compartmentPrivate = xpc::CompartmentPrivate::Get(compartment);
     if (!compartmentPrivate)
         return;
     PRIntervalTime time = PR_IntervalNow() - startInterval;
     compartmentPrivate->CPOWTime += time;
 }
--- a/js/ipc/CrossProcessObjectWrappers.h
+++ b/js/ipc/CrossProcessObjectWrappers.h
@@ -29,67 +29,67 @@ class CPOWManagerGetter;
 namespace jsipc {
 
 class PJavaScriptParent;
 class PJavaScriptChild;
 
 class CPOWManager
 {
   public:
-    virtual bool Unwrap(JSContext *cx,
-                        const InfallibleTArray<CpowEntry> &aCpows,
+    virtual bool Unwrap(JSContext* cx,
+                        const InfallibleTArray<CpowEntry>& aCpows,
                         JS::MutableHandleObject objp) = 0;
 
-    virtual bool Wrap(JSContext *cx,
+    virtual bool Wrap(JSContext* cx,
                       JS::HandleObject aObj,
-                      InfallibleTArray<CpowEntry> *outCpows) = 0;
+                      InfallibleTArray<CpowEntry>* outCpows) = 0;
 };
 
 class CrossProcessCpowHolder : public CpowHolder
 {
   public:
-    CrossProcessCpowHolder(dom::CPOWManagerGetter *managerGetter,
-                           const InfallibleTArray<CpowEntry> &cpows);
+    CrossProcessCpowHolder(dom::CPOWManagerGetter* managerGetter,
+                           const InfallibleTArray<CpowEntry>& cpows);
 
-    bool ToObject(JSContext *cx, JS::MutableHandleObject objp);
+    bool ToObject(JSContext* cx, JS::MutableHandleObject objp);
 
   private:
-    CPOWManager *js_;
-    const InfallibleTArray<CpowEntry> &cpows_;
+    CPOWManager* js_;
+    const InfallibleTArray<CpowEntry>& cpows_;
 };
 
 CPOWManager*
 CPOWManagerFor(PJavaScriptParent* aParent);
 
 CPOWManager*
 CPOWManagerFor(PJavaScriptChild* aChild);
 
 bool
-IsCPOW(JSObject *obj);
+IsCPOW(JSObject* obj);
 
 bool
-IsWrappedCPOW(JSObject *obj);
+IsWrappedCPOW(JSObject* obj);
 
 nsresult
-InstanceOf(JSObject *obj, const nsID *id, bool *bp);
+InstanceOf(JSObject* obj, const nsID* id, bool* bp);
 
 bool
-DOMInstanceOf(JSContext *cx, JSObject *obj, int prototypeID, int depth, bool *bp);
+DOMInstanceOf(JSContext* cx, JSObject* obj, int prototypeID, int depth, bool* bp);
 
 void
-GetWrappedCPOWTag(JSObject *obj, nsACString &out);
+GetWrappedCPOWTag(JSObject* obj, nsACString& out);
 
-PJavaScriptParent *
-NewJavaScriptParent(JSRuntime *rt);
+PJavaScriptParent*
+NewJavaScriptParent(JSRuntime* rt);
 
 void
-ReleaseJavaScriptParent(PJavaScriptParent *parent);
+ReleaseJavaScriptParent(PJavaScriptParent* parent);
 
-PJavaScriptChild *
-NewJavaScriptChild(JSRuntime *rt);
+PJavaScriptChild*
+NewJavaScriptChild(JSRuntime* rt);
 
 void
-ReleaseJavaScriptChild(PJavaScriptChild *child);
+ReleaseJavaScriptChild(PJavaScriptChild* child);
 
 } // namespace jsipc
 } // namespace mozilla
 
 #endif // mozilla_jsipc_CrossProcessObjectWrappers_h__
--- a/js/ipc/JavaScriptBase.h
+++ b/js/ipc/JavaScriptBase.h
@@ -17,206 +17,206 @@ namespace mozilla {
 namespace jsipc {
 
 template<class Base>
 class JavaScriptBase : public WrapperOwner, public WrapperAnswer, public Base
 {
     typedef WrapperAnswer Answer;
 
   public:
-    explicit JavaScriptBase(JSRuntime *rt)
+    explicit JavaScriptBase(JSRuntime* rt)
       : JavaScriptShared(rt),
         WrapperOwner(rt),
         WrapperAnswer(rt)
     {}
     virtual ~JavaScriptBase() {}
 
     virtual void ActorDestroy(WrapperOwner::ActorDestroyReason why) {
         WrapperOwner::ActorDestroy(why);
     }
 
     /*** IPC handlers ***/
 
-    bool RecvPreventExtensions(const uint64_t &objId, ReturnStatus *rs) {
+    bool RecvPreventExtensions(const uint64_t& objId, ReturnStatus* rs) {
         return Answer::RecvPreventExtensions(ObjectId::deserialize(objId), rs);
     }
-    bool RecvGetPropertyDescriptor(const uint64_t &objId, const JSIDVariant &id,
-                                     ReturnStatus *rs,
-                                     PPropertyDescriptor *out) {
+    bool RecvGetPropertyDescriptor(const uint64_t& objId, const JSIDVariant& id,
+                                     ReturnStatus* rs,
+                                     PPropertyDescriptor* out) {
         return Answer::RecvGetPropertyDescriptor(ObjectId::deserialize(objId), id, rs, out);
     }
-    bool RecvGetOwnPropertyDescriptor(const uint64_t &objId,
-                                        const JSIDVariant &id,
-                                        ReturnStatus *rs,
-                                        PPropertyDescriptor *out) {
+    bool RecvGetOwnPropertyDescriptor(const uint64_t& objId,
+                                        const JSIDVariant& id,
+                                        ReturnStatus* rs,
+                                        PPropertyDescriptor* out) {
         return Answer::RecvGetOwnPropertyDescriptor(ObjectId::deserialize(objId), id, rs, out);
     }
-    bool RecvDefineProperty(const uint64_t &objId, const JSIDVariant &id,
-                            const PPropertyDescriptor &flags, ReturnStatus *rs) {
+    bool RecvDefineProperty(const uint64_t& objId, const JSIDVariant& id,
+                            const PPropertyDescriptor& flags, ReturnStatus* rs) {
         return Answer::RecvDefineProperty(ObjectId::deserialize(objId), id, flags, rs);
     }
-    bool RecvDelete(const uint64_t &objId, const JSIDVariant &id,
-                      ReturnStatus *rs) {
+    bool RecvDelete(const uint64_t& objId, const JSIDVariant& id,
+                      ReturnStatus* rs) {
         return Answer::RecvDelete(ObjectId::deserialize(objId), id, rs);
     }
 
-    bool RecvHas(const uint64_t &objId, const JSIDVariant &id,
-                   ReturnStatus *rs, bool *bp) {
+    bool RecvHas(const uint64_t& objId, const JSIDVariant& id,
+                   ReturnStatus* rs, bool* bp) {
         return Answer::RecvHas(ObjectId::deserialize(objId), id, rs, bp);
     }
-    bool RecvHasOwn(const uint64_t &objId, const JSIDVariant &id,
-                      ReturnStatus *rs, bool *bp) {
+    bool RecvHasOwn(const uint64_t& objId, const JSIDVariant& id,
+                      ReturnStatus* rs, bool* bp) {
         return Answer::RecvHasOwn(ObjectId::deserialize(objId), id, rs, bp);
     }
-    bool RecvGet(const uint64_t &objId, const ObjectVariant &receiverVar,
-                   const JSIDVariant &id,
-                   ReturnStatus *rs, JSVariant *result) {
+    bool RecvGet(const uint64_t& objId, const ObjectVariant& receiverVar,
+                   const JSIDVariant& id,
+                   ReturnStatus* rs, JSVariant* result) {
         return Answer::RecvGet(ObjectId::deserialize(objId), receiverVar, id, rs, result);
     }
-    bool RecvSet(const uint64_t &objId, const JSIDVariant &id, const JSVariant &value,
-                 const JSVariant &receiverVar, ReturnStatus *rs) {
+    bool RecvSet(const uint64_t& objId, const JSIDVariant& id, const JSVariant& value,
+                 const JSVariant& receiverVar, ReturnStatus* rs) {
         return Answer::RecvSet(ObjectId::deserialize(objId), id, value, receiverVar, rs);
     }
 
-    bool RecvIsExtensible(const uint64_t &objId, ReturnStatus *rs,
-                            bool *result) {
+    bool RecvIsExtensible(const uint64_t& objId, ReturnStatus* rs,
+                            bool* result) {
         return Answer::RecvIsExtensible(ObjectId::deserialize(objId), rs, result);
     }
-    bool RecvCallOrConstruct(const uint64_t &objId, InfallibleTArray<JSParam> &&argv,
-                             const bool &construct, ReturnStatus *rs, JSVariant *result,
-                             nsTArray<JSParam> *outparams) {
+    bool RecvCallOrConstruct(const uint64_t& objId, InfallibleTArray<JSParam>&& argv,
+                             const bool& construct, ReturnStatus* rs, JSVariant* result,
+                             nsTArray<JSParam>* outparams) {
         return Answer::RecvCallOrConstruct(ObjectId::deserialize(objId), Move(argv), construct, rs, result, outparams);
     }
-    bool RecvHasInstance(const uint64_t &objId, const JSVariant &v, ReturnStatus *rs, bool *bp) {
+    bool RecvHasInstance(const uint64_t& objId, const JSVariant& v, ReturnStatus* rs, bool* bp) {
         return Answer::RecvHasInstance(ObjectId::deserialize(objId), v, rs, bp);
     }
-    bool RecvObjectClassIs(const uint64_t &objId, const uint32_t &classValue,
-                             bool *result) {
+    bool RecvObjectClassIs(const uint64_t& objId, const uint32_t& classValue,
+                             bool* result) {
         return Answer::RecvObjectClassIs(ObjectId::deserialize(objId), classValue, result);
     }
-    bool RecvClassName(const uint64_t &objId, nsCString *result) {
+    bool RecvClassName(const uint64_t& objId, nsCString* result) {
         return Answer::RecvClassName(ObjectId::deserialize(objId), result);
     }
-    bool RecvGetPrototype(const uint64_t &objId, ReturnStatus *rs, ObjectOrNullVariant *result) {
+    bool RecvGetPrototype(const uint64_t& objId, ReturnStatus* rs, ObjectOrNullVariant* result) {
         return Answer::RecvGetPrototype(ObjectId::deserialize(objId), rs, result);
     }
-    bool RecvRegExpToShared(const uint64_t &objId, ReturnStatus *rs, nsString *source, uint32_t *flags) {
+    bool RecvRegExpToShared(const uint64_t& objId, ReturnStatus* rs, nsString* source, uint32_t* flags) {
         return Answer::RecvRegExpToShared(ObjectId::deserialize(objId), rs, source, flags);
     }
 
-    bool RecvGetPropertyKeys(const uint64_t &objId, const uint32_t &flags,
-                             ReturnStatus *rs, nsTArray<JSIDVariant> *ids) {
+    bool RecvGetPropertyKeys(const uint64_t& objId, const uint32_t& flags,
+                             ReturnStatus* rs, nsTArray<JSIDVariant>* ids) {
         return Answer::RecvGetPropertyKeys(ObjectId::deserialize(objId), flags, rs, ids);
     }
-    bool RecvInstanceOf(const uint64_t &objId, const JSIID &iid,
-                          ReturnStatus *rs, bool *instanceof) {
+    bool RecvInstanceOf(const uint64_t& objId, const JSIID& iid,
+                          ReturnStatus* rs, bool* instanceof) {
         return Answer::RecvInstanceOf(ObjectId::deserialize(objId), iid, rs, instanceof);
     }
-    bool RecvDOMInstanceOf(const uint64_t &objId, const int &prototypeID, const int &depth,
-                             ReturnStatus *rs, bool *instanceof) {
+    bool RecvDOMInstanceOf(const uint64_t& objId, const int& prototypeID, const int& depth,
+                             ReturnStatus* rs, bool* instanceof) {
         return Answer::RecvDOMInstanceOf(ObjectId::deserialize(objId), prototypeID, depth, rs, instanceof);
     }
 
-    bool RecvDropObject(const uint64_t &objId) {
+    bool RecvDropObject(const uint64_t& objId) {
         return Answer::RecvDropObject(ObjectId::deserialize(objId));
     }
 
     /*** Dummy call handlers ***/
 
-    bool SendDropObject(const ObjectId &objId) {
+    bool SendDropObject(const ObjectId& objId) {
         return Base::SendDropObject(objId.serialize());
     }
-    bool SendPreventExtensions(const ObjectId &objId, ReturnStatus *rs) {
+    bool SendPreventExtensions(const ObjectId& objId, ReturnStatus* rs) {
         return Base::SendPreventExtensions(objId.serialize(), rs);
     }
-    bool SendGetPropertyDescriptor(const ObjectId &objId, const JSIDVariant &id,
-                                     ReturnStatus *rs,
-                                     PPropertyDescriptor *out) {
+    bool SendGetPropertyDescriptor(const ObjectId& objId, const JSIDVariant& id,
+                                     ReturnStatus* rs,
+                                     PPropertyDescriptor* out) {
         return Base::SendGetPropertyDescriptor(objId.serialize(), id, rs, out);
     }
-    bool SendGetOwnPropertyDescriptor(const ObjectId &objId,
-                                      const JSIDVariant &id,
-                                      ReturnStatus *rs,
-                                      PPropertyDescriptor *out) {
+    bool SendGetOwnPropertyDescriptor(const ObjectId& objId,
+                                      const JSIDVariant& id,
+                                      ReturnStatus* rs,
+                                      PPropertyDescriptor* out) {
         return Base::SendGetOwnPropertyDescriptor(objId.serialize(), id, rs, out);
     }
-    bool SendDefineProperty(const ObjectId &objId, const JSIDVariant &id,
-                            const PPropertyDescriptor &flags,
-                            ReturnStatus *rs) {
+    bool SendDefineProperty(const ObjectId& objId, const JSIDVariant& id,
+                            const PPropertyDescriptor& flags,
+                            ReturnStatus* rs) {
         return Base::SendDefineProperty(objId.serialize(), id, flags, rs);
     }
-    bool SendDelete(const ObjectId &objId, const JSIDVariant &id, ReturnStatus *rs) {
+    bool SendDelete(const ObjectId& objId, const JSIDVariant& id, ReturnStatus* rs) {
         return Base::SendDelete(objId.serialize(), id, rs);
     }
 
-    bool SendHas(const ObjectId &objId, const JSIDVariant &id,
-                   ReturnStatus *rs, bool *bp) {
+    bool SendHas(const ObjectId& objId, const JSIDVariant& id,
+                   ReturnStatus* rs, bool* bp) {
         return Base::SendHas(objId.serialize(), id, rs, bp);
     }
-    bool SendHasOwn(const ObjectId &objId, const JSIDVariant &id,
-                    ReturnStatus *rs, bool *bp) {
+    bool SendHasOwn(const ObjectId& objId, const JSIDVariant& id,
+                    ReturnStatus* rs, bool* bp) {
         return Base::SendHasOwn(objId.serialize(), id, rs, bp);
     }
-    bool SendGet(const ObjectId &objId, const ObjectVariant &receiverVar,
-                 const JSIDVariant &id,
-                 ReturnStatus *rs, JSVariant *result) {
+    bool SendGet(const ObjectId& objId, const ObjectVariant& receiverVar,
+                 const JSIDVariant& id,
+                 ReturnStatus* rs, JSVariant* result) {
         return Base::SendGet(objId.serialize(), receiverVar, id, rs, result);
     }
-    bool SendSet(const ObjectId &objId, const JSIDVariant &id, const JSVariant &value,
-                 const JSVariant &receiverVar, ReturnStatus *rs) {
+    bool SendSet(const ObjectId& objId, const JSIDVariant& id, const JSVariant& value,
+                 const JSVariant& receiverVar, ReturnStatus* rs) {
         return Base::SendSet(objId.serialize(), id, value, receiverVar, rs);
     }
 
-    bool SendIsExtensible(const ObjectId &objId, ReturnStatus *rs,
-                          bool *result) {
+    bool SendIsExtensible(const ObjectId& objId, ReturnStatus* rs,
+                          bool* result) {
         return Base::SendIsExtensible(objId.serialize(), rs, result);
     }
-    bool SendCallOrConstruct(const ObjectId &objId, const nsTArray<JSParam> &argv,
-                             const bool &construct, ReturnStatus *rs, JSVariant *result,
-                             nsTArray<JSParam> *outparams) {
+    bool SendCallOrConstruct(const ObjectId& objId, const nsTArray<JSParam>& argv,
+                             const bool& construct, ReturnStatus* rs, JSVariant* result,
+                             nsTArray<JSParam>* outparams) {
         return Base::SendCallOrConstruct(objId.serialize(), argv, construct, rs, result, outparams);
     }
-    bool SendHasInstance(const ObjectId &objId, const JSVariant &v, ReturnStatus *rs, bool *bp) {
+    bool SendHasInstance(const ObjectId& objId, const JSVariant& v, ReturnStatus* rs, bool* bp) {
         return Base::SendHasInstance(objId.serialize(), v, rs, bp);
     }
-    bool SendObjectClassIs(const ObjectId &objId, const uint32_t &classValue,
-                           bool *result) {
+    bool SendObjectClassIs(const ObjectId& objId, const uint32_t& classValue,
+                           bool* result) {
         return Base::SendObjectClassIs(objId.serialize(), classValue, result);
     }
-    bool SendClassName(const ObjectId &objId, nsCString *result) {
+    bool SendClassName(const ObjectId& objId, nsCString* result) {
         return Base::SendClassName(objId.serialize(), result);
     }
-    bool SendGetPrototype(const ObjectId &objId, ReturnStatus *rs, ObjectOrNullVariant *result) {
+    bool SendGetPrototype(const ObjectId& objId, ReturnStatus* rs, ObjectOrNullVariant* result) {
         return Base::SendGetPrototype(objId.serialize(), rs, result);
     }
 
-    bool SendRegExpToShared(const ObjectId &objId, ReturnStatus *rs,
-                            nsString *source, uint32_t *flags) {
+    bool SendRegExpToShared(const ObjectId& objId, ReturnStatus* rs,
+                            nsString* source, uint32_t* flags) {
         return Base::SendRegExpToShared(objId.serialize(), rs, source, flags);
     }
 
-    bool SendGetPropertyKeys(const ObjectId &objId, const uint32_t &flags,
-                             ReturnStatus *rs, nsTArray<JSIDVariant> *ids) {
+    bool SendGetPropertyKeys(const ObjectId& objId, const uint32_t& flags,
+                             ReturnStatus* rs, nsTArray<JSIDVariant>* ids) {
         return Base::SendGetPropertyKeys(objId.serialize(), flags, rs, ids);
     }
-    bool SendInstanceOf(const ObjectId &objId, const JSIID &iid,
-                        ReturnStatus *rs, bool *instanceof) {
+    bool SendInstanceOf(const ObjectId& objId, const JSIID& iid,
+                        ReturnStatus* rs, bool* instanceof) {
         return Base::SendInstanceOf(objId.serialize(), iid, rs, instanceof);
     }
-    bool SendDOMInstanceOf(const ObjectId &objId, const int &prototypeID, const int &depth,
-                           ReturnStatus *rs, bool *instanceof) {
+    bool SendDOMInstanceOf(const ObjectId& objId, const int& prototypeID, const int& depth,
+                           ReturnStatus* rs, bool* instanceof) {
         return Base::SendDOMInstanceOf(objId.serialize(), prototypeID, depth, rs, instanceof);
     }
 
     /* The following code is needed to suppress a bogus MSVC warning (C4250). */
 
-    virtual bool toObjectVariant(JSContext *cx, JSObject *obj, ObjectVariant *objVarp) {
+    virtual bool toObjectVariant(JSContext* cx, JSObject* obj, ObjectVariant* objVarp) {
         return WrapperOwner::toObjectVariant(cx, obj, objVarp);
     }
-    virtual JSObject *fromObjectVariant(JSContext *cx, ObjectVariant objVar) {
+    virtual JSObject* fromObjectVariant(JSContext* cx, ObjectVariant objVar) {
         return WrapperOwner::fromObjectVariant(cx, objVar);
     }
 };
 
 } // namespace jsipc
 } // namespace mozilla
 
 #endif
--- a/js/ipc/JavaScriptChild.cpp
+++ b/js/ipc/JavaScriptChild.cpp
@@ -16,22 +16,22 @@
 
 using namespace JS;
 using namespace mozilla;
 using namespace mozilla::jsipc;
 
 using mozilla::AutoSafeJSContext;
 
 static void
-UpdateChildWeakPointersAfterGC(JSRuntime *rt, void *data)
+UpdateChildWeakPointersAfterGC(JSRuntime* rt, void* data)
 {
-    static_cast<JavaScriptChild *>(data)->updateWeakPointers();
+    static_cast<JavaScriptChild*>(data)->updateWeakPointers();
 }
 
-JavaScriptChild::JavaScriptChild(JSRuntime *rt)
+JavaScriptChild::JavaScriptChild(JSRuntime* rt)
   : JavaScriptShared(rt),
     JavaScriptBase<PJavaScriptChild>(rt)
 {
 }
 
 JavaScriptChild::~JavaScriptChild()
 {
     JS_RemoveWeakPointerCallback(rt_, UpdateChildWeakPointersAfterGC);
@@ -52,32 +52,32 @@ JavaScriptChild::init()
 void
 JavaScriptChild::updateWeakPointers()
 {
     objects_.sweep();
     unwaivedObjectIds_.sweep();
     waivedObjectIds_.sweep();
 }
 
-JSObject *
+JSObject*
 JavaScriptChild::scopeForTargetObjects()
 {
     // CPOWs from the parent need to point into the child's privileged junk
     // scope so that they can benefit from XrayWrappers in the child.
     return xpc::PrivilegedJunkScope();
 }
 
-PJavaScriptChild *
-mozilla::jsipc::NewJavaScriptChild(JSRuntime *rt)
+PJavaScriptChild*
+mozilla::jsipc::NewJavaScriptChild(JSRuntime* rt)
 {
-    JavaScriptChild *child = new JavaScriptChild(rt);
+    JavaScriptChild* child = new JavaScriptChild(rt);
     if (!child->init()) {
         delete child;
         return nullptr;
     }
     return child;
 }
 
 void
-mozilla::jsipc::ReleaseJavaScriptChild(PJavaScriptChild *child)
+mozilla::jsipc::ReleaseJavaScriptChild(PJavaScriptChild* child)
 {
-    static_cast<JavaScriptChild *>(child)->decref();
+    static_cast<JavaScriptChild*>(child)->decref();
 }
--- a/js/ipc/JavaScriptChild.h
+++ b/js/ipc/JavaScriptChild.h
@@ -12,29 +12,29 @@
 #include "mozilla/jsipc/PJavaScriptChild.h"
 
 namespace mozilla {
 namespace jsipc {
 
 class JavaScriptChild : public JavaScriptBase<PJavaScriptChild>
 {
   public:
-    explicit JavaScriptChild(JSRuntime *rt);
+    explicit JavaScriptChild(JSRuntime* rt);
     virtual ~JavaScriptChild();
 
     bool init();
     void updateWeakPointers();
 
-    void drop(JSObject *obj);
+    void drop(JSObject* obj);
 
   protected:
     virtual bool isParent() override { return false; }
-    virtual JSObject *scopeForTargetObjects() override;
+    virtual JSObject* scopeForTargetObjects() override;
 
   private:
-    bool fail(JSContext *cx, ReturnStatus *rs);
-    bool ok(ReturnStatus *rs);
+    bool fail(JSContext* cx, ReturnStatus* rs);
+    bool ok(ReturnStatus* rs);
 };
 
 } // mozilla
 } // jsipc
 
 #endif
--- a/js/ipc/JavaScriptLogging.h
+++ b/js/ipc/JavaScriptLogging.h
@@ -35,76 +35,76 @@ struct ReceiverObj
 {
     ObjectId id;
     explicit ReceiverObj(ObjectId id) : id(id) {}
 };
 
 struct InVariant
 {
     JSVariant variant;
-    explicit InVariant(const JSVariant &variant) : variant(variant) {}
+    explicit InVariant(const JSVariant& variant) : variant(variant) {}
 };
 
 struct OutVariant
 {
     JSVariant variant;
-    explicit OutVariant(const JSVariant &variant) : variant(variant) {}
+    explicit OutVariant(const JSVariant& variant) : variant(variant) {}
 };
 
 struct Identifier
 {
     JSIDVariant variant;
-    explicit Identifier(const JSIDVariant &variant) : variant(variant) {}
+    explicit Identifier(const JSIDVariant& variant) : variant(variant) {}
 };
 
 class Logging
 {
   public:
-    Logging(JavaScriptShared *shared, JSContext *cx) : shared(shared), cx(cx) {}
+    Logging(JavaScriptShared* shared, JSContext* cx) : shared(shared), cx(cx) {}
 
-    void print(const nsCString &str) {
-        const char *side = shared->isParent() ? "from child" : "from parent";
+    void print(const nsCString& str) {
+        const char* side = shared->isParent() ? "from child" : "from parent";
         printf("CPOW %s: %s\n", side, str.get());
     }
 
-    void print(const char *str) {
+    void print(const char* str) {
         print(nsCString(str));
     }
     template<typename T1>
-    void print(const char *fmt, const T1 &a1) {
+    void print(const char* fmt, const T1& a1) {
         nsAutoCString tmp1;
         format(a1, tmp1);
         print(nsPrintfCString(fmt, tmp1.get()));
     }
     template<typename T1, typename T2>
-    void print(const char *fmt, const T1 &a1, const T2 &a2) {
+    void print(const char* fmt, const T1& a1, const T2& a2) {
         nsAutoCString tmp1;
         nsAutoCString tmp2;
         format(a1, tmp1);
         format(a2, tmp2);
         print(nsPrintfCString(fmt, tmp1.get(), tmp2.get()));
     }
     template<typename T1, typename T2, typename T3>
-    void print(const char *fmt, const T1 &a1, const T2 &a2, const T3 &a3) {
+    void print(const char* fmt, const T1& a1, const T2& a2, const T3& a3) {
         nsAutoCString tmp1;
         nsAutoCString tmp2;
         nsAutoCString tmp3;
         format(a1, tmp1);
         format(a2, tmp2);
         format(a3, tmp3);
         print(nsPrintfCString(fmt, tmp1.get(), tmp2.get(), tmp3.get()));
     }
 
-    void format(const nsString &str, nsCString &out) {
+    void format(const nsString& str, nsCString& out) {
         out = NS_ConvertUTF16toUTF8(str);
     }
 
-    void formatObject(bool incoming, bool local, ObjectId id, nsCString &out) {
-        const char *side, *objDesc;
-        void *ptr;
+    void formatObject(bool incoming, bool local, ObjectId id, nsCString& out) {
+        const char* side, *objDesc;
+        void* ptr;
 
         if (local == incoming) {
             JS::RootedObject obj(cx);
             obj = shared->objects_.find(id);
             if (obj) {
                 JSAutoCompartment ac(cx, obj);
                 objDesc = js::ObjectClassName(cx, obj);
             } else {
@@ -117,61 +117,61 @@ class Logging
             objDesc = "<cpow>";
             side = shared->isParent() ? "child" : "parent";
             ptr = nullptr;
         }
 
         out = nsPrintfCString("<%s %s:%d:%p>", side, objDesc, id.serialNumber(), ptr);
     }
 
-    void format(const ReceiverObj &obj, nsCString &out) {
+    void format(const ReceiverObj& obj, nsCString& out) {
         formatObject(true, true, obj.id, out);
     }
 
-    void format(const nsTArray<JSParam> &values, nsCString &out) {
+    void format(const nsTArray<JSParam>& values, nsCString& out) {
         nsAutoCString tmp;
         out.Truncate();
         for (size_t i = 0; i < values.Length(); i++) {
             if (i)
                 out.AppendLiteral(", ");
             if (values[i].type() == JSParam::Tvoid_t) {
                 out.AppendLiteral("<void>");
             } else {
                 format(InVariant(values[i].get_JSVariant()), tmp);
                 out += tmp;
             }
         }
     }
 
-    void format(const InVariant &value, nsCString &out) {
+    void format(const InVariant& value, nsCString& out) {
         format(true, value.variant, out);
     }
 
-    void format(const OutVariant &value, nsCString &out) {
+    void format(const OutVariant& value, nsCString& out) {
         format(false, value.variant, out);
     }
 
-    void format(bool incoming, const JSVariant &value, nsCString &out) {
+    void format(bool incoming, const JSVariant& value, nsCString& out) {
         switch (value.type()) {
           case JSVariant::TUndefinedVariant: {
               out = "undefined";
               break;
           }
           case JSVariant::TNullVariant: {
               out = "null";
               break;
           }
           case JSVariant::TnsString: {
               nsAutoCString tmp;
               format(value.get_nsString(), tmp);
               out = nsPrintfCString("\"%s\"", tmp.get());
               break;
           }
           case JSVariant::TObjectVariant: {
-              const ObjectVariant &ovar = value.get_ObjectVariant();
+              const ObjectVariant& ovar = value.get_ObjectVariant();
               if (ovar.type() == ObjectVariant::TLocalObject)
                   formatObject(incoming, true, ObjectId::deserialize(ovar.get_LocalObject().serializedId()), out);
               else
                   formatObject(incoming, false, ObjectId::deserialize(ovar.get_RemoteObject().serializedId()), out);
               break;
           }
           case JSVariant::TSymbolVariant: {
               out = "<Symbol>";
@@ -191,17 +191,17 @@ class Logging
           }
           default: {
               out = "<JSIID>";
               break;
           }
         }
     }
 
-    void format(const Identifier &id, nsCString &out) {
+    void format(const Identifier& id, nsCString& out) {
         switch (id.variant.type()) {
           case JSIDVariant::TSymbolVariant: {
               out = "<Symbol>";
               break;
           }
           case JSIDVariant::TnsString: {
               nsAutoCString tmp;
               format(id.variant.get_nsString(), tmp);
@@ -215,16 +215,16 @@ class Logging
           default: {
               out = "Unknown";
               break;
           }
       }
     }
 
   private:
-    JavaScriptShared *shared;
-    JSContext *cx;
+    JavaScriptShared* shared;
+    JSContext* cx;
 };
 
 }
 }
 
 #endif
--- a/js/ipc/JavaScriptParent.cpp
+++ b/js/ipc/JavaScriptParent.cpp
@@ -17,22 +17,22 @@
 
 using namespace js;
 using namespace JS;
 using namespace mozilla;
 using namespace mozilla::jsipc;
 using namespace mozilla::dom;
 
 static void
-TraceParent(JSTracer *trc, void *data)
+TraceParent(JSTracer* trc, void* data)
 {
-    static_cast<JavaScriptParent *>(data)->trace(trc);
+    static_cast<JavaScriptParent*>(data)->trace(trc);
 }
 
-JavaScriptParent::JavaScriptParent(JSRuntime *rt)
+JavaScriptParent::JavaScriptParent(JSRuntime* rt)
   : JavaScriptShared(rt),
     JavaScriptBase<PJavaScriptParent>(rt)
 {
 }
 
 JavaScriptParent::~JavaScriptParent()
 {
     JS_RemoveExtraGCRootsTracer(rt_, TraceParent, this);
@@ -44,52 +44,52 @@ JavaScriptParent::init()
     if (!WrapperOwner::init())
         return false;
 
     JS_AddExtraGCRootsTracer(rt_, TraceParent, this);
     return true;
 }
 
 void
-JavaScriptParent::trace(JSTracer *trc)
+JavaScriptParent::trace(JSTracer* trc)
 {
     objects_.trace(trc);
     unwaivedObjectIds_.trace(trc);
     waivedObjectIds_.trace(trc);
 }
 
-JSObject *
+JSObject*
 JavaScriptParent::scopeForTargetObjects()
 {
     // CPWOWs from the child need to point into the parent's unprivileged junk
     // scope so that a compromised child cannot compromise the parent. In
     // practice, this means that a child process can only (a) hold parent
     // objects alive and (b) invoke them if they are callable.
     return xpc::UnprivilegedJunkScope();
 }
 
 mozilla::ipc::IProtocol*
 JavaScriptParent::CloneProtocol(Channel* aChannel, ProtocolCloneContext* aCtx)
 {
-    ContentParent *contentParent = aCtx->GetContentParent();
+    ContentParent* contentParent = aCtx->GetContentParent();
     nsAutoPtr<PJavaScriptParent> actor(contentParent->AllocPJavaScriptParent());
     if (!actor || !contentParent->RecvPJavaScriptConstructor(actor)) {
         return nullptr;
     }
     return actor.forget();
 }
 
-PJavaScriptParent *
-mozilla::jsipc::NewJavaScriptParent(JSRuntime *rt)
+PJavaScriptParent*
+mozilla::jsipc::NewJavaScriptParent(JSRuntime* rt)
 {
-    JavaScriptParent *parent = new JavaScriptParent(rt);
+    JavaScriptParent* parent = new JavaScriptParent(rt);
     if (!parent->init()) {
         delete parent;
         return nullptr;
     }
     return parent;
 }
 
 void
-mozilla::jsipc::ReleaseJavaScriptParent(PJavaScriptParent *parent)
+mozilla::jsipc::ReleaseJavaScriptParent(PJavaScriptParent* parent)
 {
-    static_cast<JavaScriptParent *>(parent)->decref();
+    static_cast<JavaScriptParent*>(parent)->decref();
 }
--- a/js/ipc/JavaScriptParent.h
+++ b/js/ipc/JavaScriptParent.h
@@ -12,29 +12,29 @@
 #include "mozilla/jsipc/PJavaScriptParent.h"
 
 namespace mozilla {
 namespace jsipc {
 
 class JavaScriptParent : public JavaScriptBase<PJavaScriptParent>
 {
   public:
-    explicit JavaScriptParent(JSRuntime *rt);
+    explicit JavaScriptParent(JSRuntime* rt);
     virtual ~JavaScriptParent();
 
     bool init();
-    void trace(JSTracer *trc);
+    void trace(JSTracer* trc);
 
-    void drop(JSObject *obj);
+    void drop(JSObject* obj);
 
     mozilla::ipc::IProtocol*
     CloneProtocol(Channel* aChannel, ProtocolCloneContext* aCtx) override;
 
   protected:
     virtual bool isParent() override { return true; }
-    virtual JSObject *scopeForTargetObjects() override;
+    virtual JSObject* scopeForTargetObjects() override;
 };
 
 } // jsipc
 } // mozilla
 
 #endif // mozilla_jsipc_JavaScriptWrapper_h__
 
--- a/js/ipc/JavaScriptShared.cpp
+++ b/js/ipc/JavaScriptShared.cpp
@@ -28,46 +28,46 @@ bool
 IdToObjectMap::init()
 {
     if (table_.initialized())
         return true;
     return table_.init(32);
 }
 
 void
-IdToObjectMap::trace(JSTracer *trc)
+IdToObjectMap::trace(JSTracer* trc)
 {
     for (Table::Range r(table_.all()); !r.empty(); r.popFront()) {
-        DebugOnly<JSObject *> prior = r.front().value().get();
+        DebugOnly<JSObject*> prior = r.front().value().get();
         JS_CallObjectTracer(trc, &r.front().value(), "ipc-object");
     }
 }
 
 void
 IdToObjectMap::sweep()
 {
     for (Table::Enum e(table_); !e.empty(); e.popFront()) {
-        JS::Heap<JSObject *> *objp = &e.front().value();
+        JS::Heap<JSObject*>* objp = &e.front().value();
         JS_UpdateWeakPointerAfterGC(objp);
         if (!*objp)
             e.removeFront();
     }
 }
 
-JSObject *
+JSObject*
 IdToObjectMap::find(ObjectId id)
 {
     Table::Ptr p = table_.lookup(id);
     if (!p)
         return nullptr;
     return p->value();
 }
 
 bool
-IdToObjectMap::add(ObjectId id, JSObject *obj)
+IdToObjectMap::add(ObjectId id, JSObject* obj)
 {
     return table_.put(id, obj);
 }
 
 void
 IdToObjectMap::remove(ObjectId id)
 {
     table_.remove(id);
@@ -104,87 +104,87 @@ ObjectToIdMap::init()
     if (table_)
         return true;
 
     table_ = new Table(SystemAllocPolicy());
     return table_ && table_->init(32);
 }
 
 void
-ObjectToIdMap::trace(JSTracer *trc)
+ObjectToIdMap::trace(JSTracer* trc)
 {
     for (Table::Enum e(*table_); !e.empty(); e.popFront()) {
-        JSObject *obj = e.front().key();
+        JSObject* obj = e.front().key();
         JS_CallUnbarrieredObjectTracer(trc, &obj, "ipc-object");
         if (obj != e.front().key())
             e.rekeyFront(obj);
     }
 }
 
 void
 ObjectToIdMap::sweep()
 {
     for (Table::Enum e(*table_); !e.empty(); e.popFront()) {
-        JSObject *obj = e.front().key();
+        JSObject* obj = e.front().key();
         JS_UpdateWeakPointerAfterGCUnbarriered(&obj);
         if (!obj)
             e.removeFront();
         else if (obj != e.front().key())
             e.rekeyFront(obj);
     }
 }
 
 ObjectId
-ObjectToIdMap::find(JSObject *obj)
+ObjectToIdMap::find(JSObject* obj)
 {
     Table::Ptr p = table_->lookup(obj);
     if (!p)
         return ObjectId::nullId();
     return p->value();
 }
 
 bool
-ObjectToIdMap::add(JSContext *cx, JSObject *obj, ObjectId id)
+ObjectToIdMap::add(JSContext* cx, JSObject* obj, ObjectId id)
 {
     if (!table_->put(obj, id))
         return false;
     JS_StoreObjectPostBarrierCallback(cx, keyMarkCallback, obj, table_);
     return true;
 }
 
 /*
  * This function is called during minor GCs for each key in the HashMap that has
  * been moved.
  */
 /* static */ void
-ObjectToIdMap::keyMarkCallback(JSTracer *trc, JSObject *key, void *data)
+ObjectToIdMap::keyMarkCallback(JSTracer* trc, JSObject* key, void* data)
 {
-    Table *table = static_cast<Table*>(data);
-    JSObject *prior = key;
+    Table* table = static_cast<Table*>(data);
+    JSObject* prior = key;
     JS_CallUnbarrieredObjectTracer(trc, &key, "ObjectIdCache::table_ key");
     table->rekeyIfMoved(prior, key);
 }
 
 void
-ObjectToIdMap::remove(JSObject *obj)
+ObjectToIdMap::remove(JSObject* obj)
 {
     table_->remove(obj);
 }
 
 void
 ObjectToIdMap::clear()
 {
     table_->clear();
 }
 
 bool JavaScriptShared::sLoggingInitialized;
 bool JavaScriptShared::sLoggingEnabled;
 bool JavaScriptShared::sStackLoggingEnabled;
 
-JavaScriptShared::JavaScriptShared(JSRuntime *rt)
+JavaScriptShared::JavaScriptShared(JSRuntime* rt)
   : rt_(rt),
     refcount_(1),
     nextSerialNumber_(1)
 {
     if (!sLoggingInitialized) {
         sLoggingInitialized = true;
 
         if (PR_GetEnv("MOZ_CPOW_LOG")) {
@@ -229,41 +229,41 @@ JavaScriptShared::decref()
 
 void
 JavaScriptShared::incref()
 {
     refcount_++;
 }
 
 bool
-JavaScriptShared::convertIdToGeckoString(JSContext *cx, JS::HandleId id, nsString *to)
+JavaScriptShared::convertIdToGeckoString(JSContext* cx, JS::HandleId id, nsString* to)
 {
     RootedValue idval(cx);
     if (!JS_IdToValue(cx, id, &idval))
         return false;
 
     RootedString str(cx, ToString(cx, idval));
     if (!str)
         return false;
 
     return AssignJSString(cx, *to, str);
 }
 
 bool
-JavaScriptShared::convertGeckoStringToId(JSContext *cx, const nsString &from, JS::MutableHandleId to)
+JavaScriptShared::convertGeckoStringToId(JSContext* cx, const nsString& from, JS::MutableHandleId to)
 {
     RootedString str(cx, JS_NewUCStringCopyN(cx, from.BeginReading(), from.Length()));
     if (!str)
         return false;
 
     return JS_StringToId(cx, str, to);
 }
 
 bool
-JavaScriptShared::toVariant(JSContext *cx, JS::HandleValue from, JSVariant *to)
+JavaScriptShared::toVariant(JSContext* cx, JS::HandleValue from, JSVariant* to)
 {
     switch (JS_TypeOfValue(cx, from)) {
       case JSTYPE_VOID:
         *to = UndefinedVariant();
         return true;
 
       case JSTYPE_OBJECT:
       case JSTYPE_FUNCTION:
@@ -272,17 +272,17 @@ JavaScriptShared::toVariant(JSContext *c
         if (!obj) {
             MOZ_ASSERT(from == JSVAL_NULL);
             *to = NullVariant();
             return true;
         }
 
         if (xpc_JSObjectIsID(cx, obj)) {
             JSIID iid;
-            const nsID *id = xpc_JSObjectToID(cx, obj);
+            const nsID* id = xpc_JSObjectToID(cx, obj);
             ConvertID(*id, &iid);
             *to = iid;
             return true;
         }
 
         ObjectVariant objVar;
         if (!toObjectVariant(cx, obj, &objVar))
             return false;
@@ -323,86 +323,86 @@ JavaScriptShared::toVariant(JSContext *c
 
       default:
         MOZ_ASSERT(false);
         return false;
     }
 }
 
 bool
-JavaScriptShared::fromVariant(JSContext *cx, const JSVariant &from, MutableHandleValue to)
+JavaScriptShared::fromVariant(JSContext* cx, const JSVariant& from, MutableHandleValue to)
 {
     switch (from.type()) {
         case JSVariant::TUndefinedVariant:
           to.set(UndefinedValue());
           return true;
 
         case JSVariant::TNullVariant:
           to.set(NullValue());
           return true;
 
         case JSVariant::TObjectVariant:
         {
-          JSObject *obj = fromObjectVariant(cx, from.get_ObjectVariant());
+          JSObject* obj = fromObjectVariant(cx, from.get_ObjectVariant());
           if (!obj)
               return false;
           to.set(ObjectValue(*obj));
           return true;
         }
 
         case JSVariant::TSymbolVariant:
         {
-          Symbol *sym = fromSymbolVariant(cx, from.get_SymbolVariant());
+          Symbol* sym = fromSymbolVariant(cx, from.get_SymbolVariant());
           if (!sym)
               return false;
           to.setSymbol(sym);
           return true;
         }
 
         case JSVariant::Tdouble:
           to.set(JS_NumberValue(from.get_double()));
           return true;
 
         case JSVariant::Tbool:
           to.set(BOOLEAN_TO_JSVAL(from.get_bool()));
           return true;
 
         case JSVariant::TnsString:
         {
-          const nsString &old = from.get_nsString();
-          JSString *str = JS_NewUCStringCopyN(cx, old.BeginReading(), old.Length());
+          const nsString& old = from.get_nsString();
+          JSString* str = JS_NewUCStringCopyN(cx, old.BeginReading(), old.Length());
           if (!str)
               return false;
           to.set(StringValue(str));
           return true;
         }
 
         case JSVariant::TJSIID:
         {
           nsID iid;
-          const JSIID &id = from.get_JSIID();
+          const JSIID& id = from.get_JSIID();
           ConvertID(id, &iid);
 
-          JSCompartment *compartment = GetContextCompartment(cx);
+          JSCompartment* compartment = GetContextCompartment(cx);
           RootedObject global(cx, JS_GetGlobalForCompartmentOrNull(cx, compartment));
-          JSObject *obj = xpc_NewIDObject(cx, global, iid);
+          JSObject* obj = xpc_NewIDObject(cx, global, iid);
           if (!obj)
               return false;
           to.set(ObjectValue(*obj));
           return true;
         }
 
         default:
           MOZ_CRASH("NYI");
           return false;
     }
 }
 
 bool
-JavaScriptShared::toJSIDVariant(JSContext *cx, HandleId from, JSIDVariant *to)
+JavaScriptShared::toJSIDVariant(JSContext* cx, HandleId from, JSIDVariant* to)
 {
     if (JSID_IS_STRING(from)) {
         nsAutoJSString autoStr;
         if (!autoStr.init(cx, JSID_TO_STRING(from)))
             return false;
         *to = autoStr;
         return true;
     }
@@ -417,21 +417,21 @@ JavaScriptShared::toJSIDVariant(JSContex
         *to = symVar;
         return true;
     }
     MOZ_ASSERT(false);
     return false;
 }
 
 bool
-JavaScriptShared::fromJSIDVariant(JSContext *cx, const JSIDVariant &from, MutableHandleId to)
+JavaScriptShared::fromJSIDVariant(JSContext* cx, const JSIDVariant& from, MutableHandleId to)
 {
     switch (from.type()) {
       case JSIDVariant::TSymbolVariant: {
-        Symbol *sym = fromSymbolVariant(cx, from.get_SymbolVariant());
+        Symbol* sym = fromSymbolVariant(cx, from.get_SymbolVariant());
         if (!sym)
             return false;
         to.set(SYMBOL_TO_JSID(sym));
         return true;
       }
 
       case JSIDVariant::TnsString:
         return convertGeckoStringToId(cx, from.get_nsString(), to);
@@ -441,17 +441,17 @@ JavaScriptShared::fromJSIDVariant(JSCont
         return true;
 
       default:
         return false;
     }
 }
 
 bool
-JavaScriptShared::toSymbolVariant(JSContext *cx, JS::Symbol *symArg, SymbolVariant *symVarp)
+JavaScriptShared::toSymbolVariant(JSContext* cx, JS::Symbol* symArg, SymbolVariant* symVarp)
 {
     RootedSymbol sym(cx, symArg);
     MOZ_ASSERT(sym);
 
     SymbolCode code = GetSymbolCode(sym);
     if (static_cast<uint32_t>(code) < WellKnownSymbolLimit) {
         *symVarp = WellKnownSymbol(static_cast<uint32_t>(code));
         return true;
@@ -463,18 +463,18 @@ JavaScriptShared::toSymbolVariant(JSCont
         *symVarp = RegisteredSymbol(autoStr);
         return true;
     }
 
     JS_ReportError(cx, "unique symbol can't be used with CPOW");
     return false;
 }
 
-JS::Symbol *
-JavaScriptShared::fromSymbolVariant(JSContext *cx, SymbolVariant symVar)
+JS::Symbol*
+JavaScriptShared::fromSymbolVariant(JSContext* cx, SymbolVariant symVar)
 {
     switch (symVar.type()) {
       case SymbolVariant::TWellKnownSymbol: {
         uint32_t which = symVar.get_WellKnownSymbol().which();
         if (which < WellKnownSymbolLimit)
             return GetWellKnownSymbol(cx, static_cast<SymbolCode>(which));
         MOZ_ASSERT(false, "bad child data");
         return nullptr;
@@ -489,49 +489,49 @@ JavaScriptShared::fromSymbolVariant(JSCo
       }
 
       default:
         return nullptr;
     }
 }
 
 /* static */ void
-JavaScriptShared::ConvertID(const nsID &from, JSIID *to)
+JavaScriptShared::ConvertID(const nsID& from, JSIID* to)
 {
     to->m0() = from.m0;
     to->m1() = from.m1;
     to->m2() = from.m2;
     to->m3_0() = from.m3[0];
     to->m3_1() = from.m3[1];
     to->m3_2() = from.m3[2];
     to->m3_3() = from.m3[3];
     to->m3_4() = from.m3[4];
     to->m3_5() = from.m3[5];
     to->m3_6() = from.m3[6];
     to->m3_7() = from.m3[7];
 }
 
 /* static */ void
-JavaScriptShared::ConvertID(const JSIID &from, nsID *to)
+JavaScriptShared::ConvertID(const JSIID& from, nsID* to)
 {
     to->m0 = from.m0();
     to->m1 = from.m1();
     to->m2 = from.m2();
     to->m3[0] = from.m3_0();
     to->m3[1] = from.m3_1();
     to->m3[2] = from.m3_2();
     to->m3[3] = from.m3_3();
     to->m3[4] = from.m3_4();
     to->m3[5] = from.m3_5();
     to->m3[6] = from.m3_6();
     to->m3[7] = from.m3_7();
 }
 
-JSObject *
-JavaScriptShared::findObjectById(JSContext *cx, const ObjectId &objId)
+JSObject*
+JavaScriptShared::findObjectById(JSContext* cx, const ObjectId& objId)
 {
     RootedObject obj(cx, objects_.find(objId));
     if (!obj) {
         JS_ReportError(cx, "operation not possible on dead CPOW");
         return nullptr;
     }
 
     // Each process has a dedicated compartment for CPOW targets. All CPOWs
@@ -553,72 +553,72 @@ JavaScriptShared::findObjectById(JSConte
             return nullptr;
     }
     return obj;
 }
 
 static const uint64_t UnknownPropertyOp = 1;
 
 bool
-JavaScriptShared::fromDescriptor(JSContext *cx, Handle<JSPropertyDescriptor> desc,
-                                 PPropertyDescriptor *out)
+JavaScriptShared::fromDescriptor(JSContext* cx, Handle<JSPropertyDescriptor> desc,
+                                 PPropertyDescriptor* out)
 {
     out->attrs() = desc.attributes();
     if (!toVariant(cx, desc.value(), &out->value()))
         return false;
 
     if (!toObjectOrNullVariant(cx, desc.object(), &out->obj()))
         return false;
 
     if (!desc.getter()) {
         out->getter() = 0;
     } else if (desc.hasGetterObject()) {
-        JSObject *getter = desc.getterObject();
+        JSObject* getter = desc.getterObject();
         ObjectVariant objVar;
         if (!toObjectVariant(cx, getter, &objVar))
             return false;
         out->getter() = objVar;
     } else {
         MOZ_ASSERT(desc.getter() != JS_PropertyStub);
         out->getter() = UnknownPropertyOp;
     }
 
     if (!desc.setter()) {
         out->setter() = 0;
     } else if (desc.hasSetterObject()) {
-        JSObject *setter = desc.setterObject();
+        JSObject* setter = desc.setterObject();
         ObjectVariant objVar;
         if (!toObjectVariant(cx, setter, &objVar))
             return false;
         out->setter() = objVar;
     } else {
         MOZ_ASSERT(desc.setter() != JS_StrictPropertyStub);
         out->setter() = UnknownPropertyOp;
     }
 
     return true;
 }
 
 bool
-UnknownPropertyStub(JSContext *cx, HandleObject obj, HandleId id, MutableHandleValue vp)
+UnknownPropertyStub(JSContext* cx, HandleObject obj, HandleId id, MutableHandleValue vp)
 {
     JS_ReportError(cx, "getter could not be wrapped via CPOWs");
     return false;
 }
 
 bool
-UnknownStrictPropertyStub(JSContext *cx, HandleObject obj, HandleId id, MutableHandleValue vp,
-                          ObjectOpResult &result)
+UnknownStrictPropertyStub(JSContext* cx, HandleObject obj, HandleId id, MutableHandleValue vp,
+                          ObjectOpResult& result)
 {
     JS_ReportError(cx, "setter could not be wrapped via CPOWs");
     return false;
 }
 
 bool
-JavaScriptShared::toDescriptor(JSContext *cx, const PPropertyDescriptor &in,
+JavaScriptShared::toDescriptor(JSContext* cx, const PPropertyDescriptor& in,
                                MutableHandle<JSPropertyDescriptor> out)
 {
     out.setAttributes(in.attrs());
     if (!fromVariant(cx, in.value(), out.value()))
         return false;
     out.object().set(fromObjectOrNullVariant(cx, in.obj()));
 
     if (in.getter().type() == GetterSetter::Tuint64_t && !in.getter().get_uint64_t()) {
@@ -644,76 +644,76 @@ JavaScriptShared::toDescriptor(JSContext
     } else {
         out.setSetter(UnknownStrictPropertyStub);
     }
 
     return true;
 }
 
 bool
-JavaScriptShared::toObjectOrNullVariant(JSContext *cx, JSObject *obj, ObjectOrNullVariant *objVarp)
+JavaScriptShared::toObjectOrNullVariant(JSContext* cx, JSObject* obj, ObjectOrNullVariant* objVarp)
 {
     if (!obj) {
         *objVarp = NullVariant();
         return true;
     }
 
     ObjectVariant objVar;
     if (!toObjectVariant(cx, obj, &objVar))
         return false;
 
     *objVarp = objVar;
     return true;
 }
 
-JSObject *
-JavaScriptShared::fromObjectOrNullVariant(JSContext *cx, ObjectOrNullVariant objVar)
+JSObject*
+JavaScriptShared::fromObjectOrNullVariant(JSContext* cx, ObjectOrNullVariant objVar)
 {
     if (objVar.type() == ObjectOrNullVariant::TNullVariant)
         return nullptr;
 
     return fromObjectVariant(cx, objVar.get_ObjectVariant());
 }
 
-CrossProcessCpowHolder::CrossProcessCpowHolder(dom::CPOWManagerGetter *managerGetter,
-                                               const InfallibleTArray<CpowEntry> &cpows)
+CrossProcessCpowHolder::CrossProcessCpowHolder(dom::CPOWManagerGetter* managerGetter,
+                                               const InfallibleTArray<CpowEntry>& cpows)
   : js_(nullptr),
     cpows_(cpows)
 {
     // Only instantiate the CPOW manager if we might need it later.
     if (cpows.Length())
         js_ = managerGetter->GetCPOWManager();
 }
 
 bool
-CrossProcessCpowHolder::ToObject(JSContext *cx, JS::MutableHandleObject objp)
+CrossProcessCpowHolder::ToObject(JSContext* cx, JS::MutableHandleObject objp)
 {
     if (!cpows_.Length())
         return true;
 
     return js_->Unwrap(cx, cpows_, objp);
 }
 
 bool
-JavaScriptShared::Unwrap(JSContext *cx, const InfallibleTArray<CpowEntry> &aCpows,
+JavaScriptShared::Unwrap(JSContext* cx, const InfallibleTArray<CpowEntry>& aCpows,
                          JS::MutableHandleObject objp)
 {
     objp.set(nullptr);
 
     if (!aCpows.Length())
         return true;
 
     RootedObject obj(cx, JS_NewPlainObject(cx));
     if (!obj)
         return false;
 
     RootedValue v(cx);
     RootedString str(cx);
     for (size_t i = 0; i < aCpows.Length(); i++) {
-        const nsString &name = aCpows[i].name();
+        const nsString& name = aCpows[i].name();
 
         if (!fromVariant(cx, aCpows[i].value(), &v))
             return false;
 
         if (!JS_DefineUCProperty(cx,
                                  obj,
                                  name.BeginReading(),
                                  name.Length(),
@@ -724,17 +724,17 @@ JavaScriptShared::Unwrap(JSContext *cx, 
         }
     }
 
     objp.set(obj);
     return true;
 }
 
 bool
-JavaScriptShared::Wrap(JSContext *cx, HandleObject aObj, InfallibleTArray<CpowEntry> *outCpows)
+JavaScriptShared::Wrap(JSContext* cx, HandleObject aObj, InfallibleTArray<CpowEntry>* outCpows)
 {
     if (!aObj)
         return true;
 
     AutoIdArray ids(cx, JS_Enumerate(cx, aObj));
     if (!ids)
         return false;
 
@@ -758,16 +758,16 @@ JavaScriptShared::Wrap(JSContext *cx, Ha
     }
 
     return true;
 }
 
 CPOWManager*
 mozilla::jsipc::CPOWManagerFor(PJavaScriptParent* aParent)
 {
-    return static_cast<JavaScriptParent *>(aParent);
+    return static_cast<JavaScriptParent*>(aParent);
 }
 
 CPOWManager*
 mozilla::jsipc::CPOWManagerFor(PJavaScriptChild* aChild)
 {
-    return static_cast<JavaScriptChild *>(aChild);
+    return static_cast<JavaScriptChild*>(aChild);
 }
--- a/js/ipc/JavaScriptShared.h
+++ b/js/ipc/JavaScriptShared.h
@@ -31,17 +31,17 @@ class ObjectId {
 
     explicit ObjectId(uint64_t serialNumber, bool hasXrayWaiver)
       : serialNumber_(serialNumber), hasXrayWaiver_(hasXrayWaiver)
     {
         if (MOZ_UNLIKELY(serialNumber == 0 || serialNumber > SERIAL_NUMBER_MAX))
             MOZ_CRASH("Bad CPOW Id");
     }
 
-    bool operator==(const ObjectId &other) const {
+    bool operator==(const ObjectId& other) const {
         bool equal = serialNumber() == other.serialNumber();
         MOZ_ASSERT_IF(equal, hasXrayWaiver() == other.hasXrayWaiver());
         return equal;
     }
 
     bool isNull() { return !serialNumber_; }
 
     uint64_t serialNumber() const { return serialNumber_; }
@@ -66,134 +66,134 @@ class ObjectId {
 class JavaScriptShared;
 
 // DefaultHasher<T> requires that T coerce to an integral type. We could make
 // ObjectId do that, but doing so would weaken our type invariants, so we just
 // reimplement it manually.
 struct ObjectIdHasher
 {
     typedef ObjectId Lookup;
-    static js::HashNumber hash(const Lookup &l) {
+    static js::HashNumber hash(const Lookup& l) {
         return l.serialize();
     }
-    static bool match(const ObjectId &k, const ObjectId &l) {
+    static bool match(const ObjectId& k, const ObjectId& l) {
         return k == l;
     }
-    static void rekey(ObjectId &k, const ObjectId& newKey) {
+    static void rekey(ObjectId& k, const ObjectId& newKey) {
         k = newKey;
     }
 };
 
 // Map ids -> JSObjects
 class IdToObjectMap
 {
-    typedef js::HashMap<ObjectId, JS::Heap<JSObject *>, ObjectIdHasher, js::SystemAllocPolicy> Table;
+    typedef js::HashMap<ObjectId, JS::Heap<JSObject*>, ObjectIdHasher, js::SystemAllocPolicy> Table;
 
   public:
     IdToObjectMap();
 
     bool init();
-    void trace(JSTracer *trc);
+    void trace(JSTracer* trc);
     void sweep();
 
-    bool add(ObjectId id, JSObject *obj);
-    JSObject *find(ObjectId id);
+    bool add(ObjectId id, JSObject* obj);
+    JSObject* find(ObjectId id);
     void remove(ObjectId id);
 
     void clear();
     bool empty() const;
 
   private:
     Table table_;
 };
 
 // Map JSObjects -> ids
 class ObjectToIdMap
 {
-    typedef js::PointerHasher<JSObject *, 3> Hasher;
-    typedef js::HashMap<JSObject *, ObjectId, Hasher, js::SystemAllocPolicy> Table;
+    typedef js::PointerHasher<JSObject*, 3> Hasher;
+    typedef js::HashMap<JSObject*, ObjectId, Hasher, js::SystemAllocPolicy> Table;
 
   public:
     ObjectToIdMap();
     ~ObjectToIdMap();
 
     bool init();
-    void trace(JSTracer *trc);
+    void trace(JSTracer* trc);
     void sweep();
 
-    bool add(JSContext *cx, JSObject *obj, ObjectId id);
-    ObjectId find(JSObject *obj);
-    void remove(JSObject *obj);
+    bool add(JSContext* cx, JSObject* obj, ObjectId id);
+    ObjectId find(JSObject* obj);
+    void remove(JSObject* obj);
     void clear();
 
   private:
-    static void keyMarkCallback(JSTracer *trc, JSObject *key, void *data);
+    static void keyMarkCallback(JSTracer* trc, JSObject* key, void* data);
 
-    Table *table_;
+    Table* table_;
 };
 
 class Logging;
 
 class JavaScriptShared : public CPOWManager
 {
   public:
-    explicit JavaScriptShared(JSRuntime *rt);
+    explicit JavaScriptShared(JSRuntime* rt);
     virtual ~JavaScriptShared();
 
     bool init();
 
     void decref();
     void incref();
 
-    bool Unwrap(JSContext *cx, const InfallibleTArray<CpowEntry> &aCpows, JS::MutableHandleObject objp);
-    bool Wrap(JSContext *cx, JS::HandleObject aObj, InfallibleTArray<CpowEntry> *outCpows);
+    bool Unwrap(JSContext* cx, const InfallibleTArray<CpowEntry>& aCpows, JS::MutableHandleObject objp);
+    bool Wrap(JSContext* cx, JS::HandleObject aObj, InfallibleTArray<CpowEntry>* outCpows);
 
   protected:
-    bool toVariant(JSContext *cx, JS::HandleValue from, JSVariant *to);
-    bool fromVariant(JSContext *cx, const JSVariant &from, JS::MutableHandleValue to);
+    bool toVariant(JSContext* cx, JS::HandleValue from, JSVariant* to);
+    bool fromVariant(JSContext* cx, const JSVariant& from, JS::MutableHandleValue to);
 
-    bool toJSIDVariant(JSContext *cx, JS::HandleId from, JSIDVariant *to);
-    bool fromJSIDVariant(JSContext *cx, const JSIDVariant &from, JS::MutableHandleId to);
+    bool toJSIDVariant(JSContext* cx, JS::HandleId from, JSIDVariant* to);
+    bool fromJSIDVariant(JSContext* cx, const JSIDVariant& from, JS::MutableHandleId to);
 
-    bool toSymbolVariant(JSContext *cx, JS::Symbol *sym, SymbolVariant *symVarp);
-    JS::Symbol *fromSymbolVariant(JSContext *cx, SymbolVariant symVar);
+    bool toSymbolVariant(JSContext* cx, JS::Symbol* sym, SymbolVariant* symVarp);
+    JS::Symbol* fromSymbolVariant(JSContext* cx, SymbolVariant symVar);
 
-    bool fromDescriptor(JSContext *cx, JS::Handle<JSPropertyDescriptor> desc,
-                        PPropertyDescriptor *out);
-    bool toDescriptor(JSContext *cx, const PPropertyDescriptor &in,
+    bool fromDescriptor(JSContext* cx, JS::Handle<JSPropertyDescriptor> desc,
+                        PPropertyDescriptor* out);
+    bool toDescriptor(JSContext* cx, const PPropertyDescriptor& in,
                       JS::MutableHandle<JSPropertyDescriptor> out);
 
-    bool toObjectOrNullVariant(JSContext *cx, JSObject *obj, ObjectOrNullVariant *objVarp);
-    JSObject *fromObjectOrNullVariant(JSContext *cx, ObjectOrNullVariant objVar);
+    bool toObjectOrNullVariant(JSContext* cx, JSObject* obj, ObjectOrNullVariant* objVarp);
+    JSObject* fromObjectOrNullVariant(JSContext* cx, ObjectOrNullVariant objVar);
 
-    bool convertIdToGeckoString(JSContext *cx, JS::HandleId id, nsString *to);
-    bool convertGeckoStringToId(JSContext *cx, const nsString &from, JS::MutableHandleId id);
+    bool convertIdToGeckoString(JSContext* cx, JS::HandleId id, nsString* to);
+    bool convertGeckoStringToId(JSContext* cx, const nsString& from, JS::MutableHandleId id);
 
-    virtual bool toObjectVariant(JSContext *cx, JSObject *obj, ObjectVariant *objVarp) = 0;
-    virtual JSObject *fromObjectVariant(JSContext *cx, ObjectVariant objVar) = 0;
+    virtual bool toObjectVariant(JSContext* cx, JSObject* obj, ObjectVariant* objVarp) = 0;
+    virtual JSObject* fromObjectVariant(JSContext* cx, ObjectVariant objVar) = 0;
 
-    static void ConvertID(const nsID &from, JSIID *to);
-    static void ConvertID(const JSIID &from, nsID *to);
+    static void ConvertID(const nsID& from, JSIID* to);
+    static void ConvertID(const JSIID& from, nsID* to);
 
-    JSObject *findCPOWById(const ObjectId &objId) {
+    JSObject* findCPOWById(const ObjectId& objId) {
         return cpows_.find(objId);
     }
-    JSObject *findObjectById(JSContext *cx, const ObjectId &objId);
+    JSObject* findObjectById(JSContext* cx, const ObjectId& objId);
 
     static bool LoggingEnabled() { return sLoggingEnabled; }
     static bool StackLoggingEnabled() { return sStackLoggingEnabled; }
 
     friend class Logging;
 
     virtual bool isParent() = 0;
 
-    virtual JSObject *scopeForTargetObjects() = 0;
+    virtual JSObject* scopeForTargetObjects() = 0;
 
   protected:
-    JSRuntime *rt_;
+    JSRuntime* rt_;
     uintptr_t refcount_;
 
     IdToObjectMap objects_;
     IdToObjectMap cpows_;
 
     uint64_t nextSerialNumber_;
 
     // CPOW references can be weak, and any object we store in a map may be
@@ -208,17 +208,17 @@ class JavaScriptShared : public CPOWMana
     // need a way of distinguishing them at lookup-time.
     //
     // For the id-to-object map, we encode waiver-or-not information into the id
     // itself, which lets us do the right thing when accessing the object.
     //
     // For the object-to-id map, we just keep two maps, one for each type.
     ObjectToIdMap unwaivedObjectIds_;
     ObjectToIdMap waivedObjectIds_;
-    ObjectToIdMap &objectIdMap(bool waiver) {
+    ObjectToIdMap& objectIdMap(bool waiver) {
         return waiver ? waivedObjectIds_ : unwaivedObjectIds_;
     }
 
     static bool sLoggingInitialized;
     static bool sLoggingEnabled;
     static bool sStackLoggingEnabled;
 };
 
--- a/js/ipc/WrapperAnswer.cpp
+++ b/js/ipc/WrapperAnswer.cpp
@@ -22,17 +22,17 @@ using namespace mozilla::jsipc;
 // happen if the target is a scripted proxy, which is probably something that we
 // don't want to support over CPOWs. When enough code is fixed up, the long-term
 // plan is to have the JS engine throw if it encounters script when it isn't
 // expecting it.
 using mozilla::dom::AutoJSAPI;
 using mozilla::dom::AutoEntryScript;
 
 bool
-WrapperAnswer::fail(JSContext *cx, ReturnStatus *rs)
+WrapperAnswer::fail(JSContext* cx, ReturnStatus* rs)
 {
     // By default, we set |undefined| unless we can get a more meaningful
     // exception.
     *rs = ReturnStatus(ReturnException(JSVariant(UndefinedVariant())));
 
     // Note we always return true from this function, since this propagates
     // to the IPC code, and we don't want a JS failure to cause the death
     // of the child process.
@@ -53,69 +53,69 @@ WrapperAnswer::fail(JSContext *cx, Retur
 
     // If this fails, we still don't want to exit. Just return an invalid
     // exception.
     (void) toVariant(cx, exn, &rs->get_ReturnException().exn());
     return true;
 }
 
 bool
-WrapperAnswer::ok(ReturnStatus *rs)
+WrapperAnswer::ok(ReturnStatus* rs)
 {
     *rs = ReturnStatus(ReturnSuccess());
     return true;
 }
 
 bool
-WrapperAnswer::ok(ReturnStatus *rs, const JS::ObjectOpResult &result)
+WrapperAnswer::ok(ReturnStatus* rs, const JS::ObjectOpResult& result)
 {
     *rs = result
           ? ReturnStatus(ReturnSuccess())
           : ReturnStatus(ReturnObjectOpResult(result.failureCode()));
     return true;
 }
 
 bool
-WrapperAnswer::RecvPreventExtensions(const ObjectId &objId, ReturnStatus *rs)
+WrapperAnswer::RecvPreventExtensions(const ObjectId& objId, ReturnStatus* rs)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     ObjectOpResult success;
     if (!JS_PreventExtensions(cx, obj, success))
         return fail(cx, rs);
 
     LOG("%s.preventExtensions()", ReceiverObj(objId));
     return ok(rs, success);
 }
 
 static void
-EmptyDesc(PPropertyDescriptor *desc)
+EmptyDesc(PPropertyDescriptor* desc)
 {
     desc->obj() = LocalObject(0);
     desc->attrs() = 0;
     desc->value() = UndefinedVariant();
     desc->getter() = 0;
     desc->setter() = 0;
 }
 
 bool
-WrapperAnswer::RecvGetPropertyDescriptor(const ObjectId &objId, const JSIDVariant &idVar,
-                                         ReturnStatus *rs, PPropertyDescriptor *out)
+WrapperAnswer::RecvGetPropertyDescriptor(const ObjectId& objId, const JSIDVariant& idVar,
+                                         ReturnStatus* rs, PPropertyDescriptor* out)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
     EmptyDesc(out);
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     LOG("%s.getPropertyDescriptor(%s)", ReceiverObj(objId), Identifier(idVar));
 
@@ -129,23 +129,23 @@ WrapperAnswer::RecvGetPropertyDescriptor
 
     if (!fromDescriptor(cx, desc, out))
         return fail(cx, rs);
 
     return ok(rs);
 }
 
 bool
-WrapperAnswer::RecvGetOwnPropertyDescriptor(const ObjectId &objId, const JSIDVariant &idVar,
-                                            ReturnStatus *rs, PPropertyDescriptor *out)
+WrapperAnswer::RecvGetOwnPropertyDescriptor(const ObjectId& objId, const JSIDVariant& idVar,
+                                            ReturnStatus* rs, PPropertyDescriptor* out)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
     EmptyDesc(out);
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     LOG("%s.getOwnPropertyDescriptor(%s)", ReceiverObj(objId), Identifier(idVar));
 
@@ -159,23 +159,23 @@ WrapperAnswer::RecvGetOwnPropertyDescrip
 
     if (!fromDescriptor(cx, desc, out))
         return fail(cx, rs);
 
     return ok(rs);
 }
 
 bool
-WrapperAnswer::RecvDefineProperty(const ObjectId &objId, const JSIDVariant &idVar,
-                                  const PPropertyDescriptor &descriptor, ReturnStatus *rs)
+WrapperAnswer::RecvDefineProperty(const ObjectId& objId, const JSIDVariant& idVar,
+                                  const PPropertyDescriptor& descriptor, ReturnStatus* rs)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     LOG("define %s[%s]", ReceiverObj(objId), Identifier(idVar));
 
     RootedId id(cx);
@@ -188,22 +188,22 @@ WrapperAnswer::RecvDefineProperty(const 
 
     ObjectOpResult success;
     if (!js::DefineOwnProperty(cx, obj, id, desc, success))
         return fail(cx, rs);
     return ok(rs, success);
 }
 
 bool
-WrapperAnswer::RecvDelete(const ObjectId &objId, const JSIDVariant &idVar, ReturnStatus *rs)
+WrapperAnswer::RecvDelete(const ObjectId& objId, const JSIDVariant& idVar, ReturnStatus* rs)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     LOG("delete %s[%s]", ReceiverObj(objId), Identifier(idVar));
 
     RootedId id(cx);
@@ -212,22 +212,22 @@ WrapperAnswer::RecvDelete(const ObjectId
 
     ObjectOpResult success;
     if (!JS_DeletePropertyById(cx, obj, id, success))
         return fail(cx, rs);
     return ok(rs, success);
 }
 
 bool
-WrapperAnswer::RecvHas(const ObjectId &objId, const JSIDVariant &idVar, ReturnStatus *rs, bool *bp)
+WrapperAnswer::RecvHas(const ObjectId& objId, const JSIDVariant& idVar, ReturnStatus* rs, bool* bp)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
     *bp = false;
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     LOG("%s.has(%s)", ReceiverObj(objId), Identifier(idVar));
 
@@ -239,23 +239,23 @@ WrapperAnswer::RecvHas(const ObjectId &o
     if (!JS_HasPropertyById(cx, obj, id, &found))
         return fail(cx, rs);
     *bp = !!found;
 
     return ok(rs);
 }
 
 bool
-WrapperAnswer::RecvHasOwn(const ObjectId &objId, const JSIDVariant &idVar, ReturnStatus *rs,
-                          bool *bp)
+WrapperAnswer::RecvHasOwn(const ObjectId& objId, const JSIDVariant& idVar, ReturnStatus* rs,
+                          bool* bp)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
     *bp = false;
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     LOG("%s.hasOwn(%s)", ReceiverObj(objId), Identifier(idVar));
 
@@ -267,22 +267,22 @@ WrapperAnswer::RecvHasOwn(const ObjectId
     if (!JS_GetPropertyDescriptorById(cx, obj, id, &desc))
         return fail(cx, rs);
     *bp = (desc.object() == obj);
 
     return ok(rs);
 }
 
 bool
-WrapperAnswer::RecvGet(const ObjectId &objId, const ObjectVariant &receiverVar,
-                       const JSIDVariant &idVar, ReturnStatus *rs, JSVariant *result)
+WrapperAnswer::RecvGet(const ObjectId& objId, const ObjectVariant& receiverVar,
+                       const JSIDVariant& idVar, ReturnStatus* rs, JSVariant* result)
 {
     // We may run scripted getters.
     AutoEntryScript aes(xpc::NativeGlobal(scopeForTargetObjects()));
-    JSContext *cx = aes.cx();
+    JSContext* cx = aes.cx();
 
     // The outparam will be written to the buffer, so it must be set even if
     // the parent won't read it.
     *result = UndefinedVariant();
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
@@ -303,22 +303,22 @@ WrapperAnswer::RecvGet(const ObjectId &o
         return fail(cx, rs);
 
     LOG("get %s.%s = %s", ReceiverObj(objId), Identifier(idVar), OutVariant(*result));
 
     return ok(rs);
 }
 
 bool
-WrapperAnswer::RecvSet(const ObjectId &objId, const JSIDVariant &idVar, const JSVariant &value,
-                       const JSVariant &receiverVar, ReturnStatus *rs)
+WrapperAnswer::RecvSet(const ObjectId& objId, const JSIDVariant& idVar, const JSVariant& value,
+                       const JSVariant& receiverVar, ReturnStatus* rs)
 {
     // We may run scripted setters.
     AutoEntryScript aes(xpc::NativeGlobal(scopeForTargetObjects()));
-    JSContext *cx = aes.cx();
+    JSContext* cx = aes.cx();
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     LOG("set %s[%s] = %s", ReceiverObj(objId), Identifier(idVar), InVariant(value));
 
     RootedId id(cx);
@@ -336,22 +336,22 @@ WrapperAnswer::RecvSet(const ObjectId &o
     ObjectOpResult result;
     if (!JS_ForwardSetPropertyTo(cx, obj, id, val, receiver, result))
         return fail(cx, rs);
 
     return ok(rs, result);
 }
 
 bool
-WrapperAnswer::RecvIsExtensible(const ObjectId &objId, ReturnStatus *rs, bool *result)
+WrapperAnswer::RecvIsExtensible(const ObjectId& objId, ReturnStatus* rs, bool* result)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
     *result = false;
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     LOG("%s.isExtensible()", ReceiverObj(objId));
 
@@ -359,25 +359,25 @@ WrapperAnswer::RecvIsExtensible(const Ob
     if (!JS_IsExtensible(cx, obj, &extensible))
         return fail(cx, rs);
 
     *result = !!extensible;
     return ok(rs);
 }
 
 bool
-WrapperAnswer::RecvCallOrConstruct(const ObjectId &objId,
-                                   InfallibleTArray<JSParam> &&argv,
-                                   const bool &construct,
-                                   ReturnStatus *rs,
-                                   JSVariant *result,
-                                   nsTArray<JSParam> *outparams)
+WrapperAnswer::RecvCallOrConstruct(const ObjectId& objId,
+                                   InfallibleTArray<JSParam>&& argv,
+                                   const bool& construct,
+                                   ReturnStatus* rs,
+                                   JSVariant* result,
+                                   nsTArray<JSParam>* outparams)
 {
     AutoEntryScript aes(xpc::NativeGlobal(scopeForTargetObjects()));
-    JSContext *cx = aes.cx();
+    JSContext* cx = aes.cx();
 
     // The outparam will be written to the buffer, so it must be set even if
     // the parent won't read it.
     *result = UndefinedVariant();
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
@@ -462,22 +462,22 @@ WrapperAnswer::RecvCallOrConstruct(const
     }
 
     LOG("%s.call(%s) = %s", ReceiverObj(objId), argv, OutVariant(*result));
 
     return ok(rs);
 }
 
 bool
-WrapperAnswer::RecvHasInstance(const ObjectId &objId, const JSVariant &vVar, ReturnStatus *rs, bool *bp)
+WrapperAnswer::RecvHasInstance(const ObjectId& objId, const JSVariant& vVar, ReturnStatus* rs, bool* bp)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     LOG("%s.hasInstance(%s)", ReceiverObj(objId), InVariant(vVar));
 
     RootedValue val(cx);
@@ -486,66 +486,66 @@ WrapperAnswer::RecvHasInstance(const Obj
 
     if (!JS_HasInstance(cx, obj, val, bp))
         return fail(cx, rs);
 
     return ok(rs);
 }
 
 bool
-WrapperAnswer::RecvObjectClassIs(const ObjectId &objId, const uint32_t &classValue,
-                                 bool *result)
+WrapperAnswer::RecvObjectClassIs(const ObjectId& objId, const uint32_t& classValue,
+                                 bool* result)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj) {
         // This is very unfortunate, but we have no choice.
         *result = false;
         return true;
     }
 
     LOG("%s.objectClassIs()", ReceiverObj(objId));
 
     *result = js::ObjectClassIs(cx, obj, (js::ESClassValue)classValue);
     return true;
 }
 
 bool
-WrapperAnswer::RecvClassName(const ObjectId &objId, nsCString *name)
+WrapperAnswer::RecvClassName(const ObjectId& objId, nsCString* name)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj) {
         // This is very unfortunate, but we have no choice.
         return "<dead CPOW>";
     }
 
     LOG("%s.className()", ReceiverObj(objId));
 
     *name = js::ObjectClassName(cx, obj);
     return true;
 }
 
 bool
-WrapperAnswer::RecvGetPrototype(const ObjectId &objId, ReturnStatus *rs, ObjectOrNullVariant *result)
+WrapperAnswer::RecvGetPrototype(const ObjectId& objId, ReturnStatus* rs, ObjectOrNullVariant* result)
 {
     *result = NullVariant();
 
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     JS::RootedObject proto(cx);
     if (!JS_GetPrototype(cx, obj, &proto))
         return fail(cx, rs);
@@ -554,23 +554,23 @@ WrapperAnswer::RecvGetPrototype(const Ob
         return fail(cx, rs);
 
     LOG("getPrototype(%s)", ReceiverObj(objId));
 
     return ok(rs);
 }
 
 bool
-WrapperAnswer::RecvRegExpToShared(const ObjectId &objId, ReturnStatus *rs,
-                                  nsString *source, uint32_t *flags)
+WrapperAnswer::RecvRegExpToShared(const ObjectId& objId, ReturnStatus* rs,
+                                  nsString* source, uint32_t* flags)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     MOZ_RELEASE_ASSERT(JS_ObjectIsRegExp(cx, obj));
     RootedString sourceJSStr(cx, JS_GetRegExpSource(cx, obj));
     if (!sourceJSStr)
@@ -581,23 +581,23 @@ WrapperAnswer::RecvRegExpToShared(const 
     source->Assign(sourceStr);
 
     *flags = JS_GetRegExpFlags(cx, obj);
 
     return ok(rs);
 }
 
 bool
-WrapperAnswer::RecvGetPropertyKeys(const ObjectId &objId, const uint32_t &flags,
-                                   ReturnStatus *rs, nsTArray<JSIDVariant> *ids)
+WrapperAnswer::RecvGetPropertyKeys(const ObjectId& objId, const uint32_t& flags,
+                                   ReturnStatus* rs, nsTArray<JSIDVariant>* ids)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     LOG("%s.getPropertyKeys()", ReceiverObj(objId));
 
     AutoIdVector props(cx);
@@ -611,23 +611,23 @@ WrapperAnswer::RecvGetPropertyKeys(const
 
         ids->AppendElement(id);
     }
 
     return ok(rs);
 }
 
 bool
-WrapperAnswer::RecvInstanceOf(const ObjectId &objId, const JSIID &iid, ReturnStatus *rs,
-                              bool *instanceof)
+WrapperAnswer::RecvInstanceOf(const ObjectId& objId, const JSIID& iid, ReturnStatus* rs,
+                              bool* instanceof)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
 
     *instanceof = false;
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     LOG("%s.instanceOf()", ReceiverObj(objId));
@@ -638,23 +638,23 @@ WrapperAnswer::RecvInstanceOf(const Obje
     nsresult rv = xpc::HasInstance(cx, obj, &nsiid, instanceof);
     if (rv != NS_OK)
         return fail(cx, rs);
 
     return ok(rs);
 }
 
 bool
-WrapperAnswer::RecvDOMInstanceOf(const ObjectId &objId, const int &prototypeID,
-                                 const int &depth, ReturnStatus *rs, bool *instanceof)
+WrapperAnswer::RecvDOMInstanceOf(const ObjectId& objId, const int& prototypeID,
+                                 const int& depth, ReturnStatus* rs, bool* instanceof)
 {
     AutoJSAPI jsapi;
     if (NS_WARN_IF(!jsapi.Init(scopeForTargetObjects())))
         return false;
-    JSContext *cx = jsapi.cx();
+    JSContext* cx = jsapi.cx();
     *instanceof = false;
 
     RootedObject obj(cx, findObjectById(cx, objId));
     if (!obj)
         return fail(cx, rs);
 
     LOG("%s.domInstanceOf()", ReceiverObj(objId));
 
@@ -662,17 +662,17 @@ WrapperAnswer::RecvDOMInstanceOf(const O
     if (!mozilla::dom::InterfaceHasInstance(cx, prototypeID, depth, obj, &tmp))
         return fail(cx, rs);
     *instanceof = tmp;
 
     return ok(rs);
 }
 
 bool
-WrapperAnswer::RecvDropObject(const ObjectId &objId)
+WrapperAnswer::RecvDropObject(const ObjectId& objId)
 {
-    JSObject *obj = objects_.find(objId);
+    JSObject* obj = objects_.find(objId);
     if (obj) {
         objectIdMap(objId.hasXrayWaiver()).remove(obj);
         objects_.remove(objId);
     }
     return true;
 }
--- a/js/ipc/WrapperAnswer.h
+++ b/js/ipc/WrapperAnswer.h
@@ -11,63 +11,63 @@
 #include "JavaScriptShared.h"
 
 namespace mozilla {
 namespace jsipc {
 
 class WrapperAnswer : public virtual JavaScriptShared
 {
   public:
-    explicit WrapperAnswer(JSRuntime *rt) : JavaScriptShared(rt) {}
+    explicit WrapperAnswer(JSRuntime* rt) : JavaScriptShared(rt) {}
 
-    bool RecvPreventExtensions(const ObjectId &objId, ReturnStatus *rs);
-    bool RecvGetPropertyDescriptor(const ObjectId &objId, const JSIDVariant &id,
-                                   ReturnStatus *rs,
-                                   PPropertyDescriptor *out);
-    bool RecvGetOwnPropertyDescriptor(const ObjectId &objId,
-                                      const JSIDVariant &id,
-                                      ReturnStatus *rs,
-                                      PPropertyDescriptor *out);
-    bool RecvDefineProperty(const ObjectId &objId, const JSIDVariant &id,
-                            const PPropertyDescriptor &flags, ReturnStatus *rs);
-    bool RecvDelete(const ObjectId &objId, const JSIDVariant &id, ReturnStatus *rs);
+    bool RecvPreventExtensions(const ObjectId& objId, ReturnStatus* rs);
+    bool RecvGetPropertyDescriptor(const ObjectId& objId, const JSIDVariant& id,
+                                   ReturnStatus* rs,
+                                   PPropertyDescriptor* out);
+    bool RecvGetOwnPropertyDescriptor(const ObjectId& objId,
+                                      const JSIDVariant& id,
+                                      ReturnStatus* rs,
+                                      PPropertyDescriptor* out);
+    bool RecvDefineProperty(const ObjectId& objId, const JSIDVariant& id,
+                            const PPropertyDescriptor& flags, ReturnStatus* rs);
+    bool RecvDelete(const ObjectId& objId, const JSIDVariant& id, ReturnStatus* rs);
 
-    bool RecvHas(const ObjectId &objId, const JSIDVariant &id,
-                 ReturnStatus *rs, bool *bp);
-    bool RecvHasOwn(const ObjectId &objId, const JSIDVariant &id,
-                    ReturnStatus *rs, bool *bp);
-    bool RecvGet(const ObjectId &objId, const ObjectVariant &receiverVar,
-                 const JSIDVariant &id,
-                 ReturnStatus *rs, JSVariant *result);
-    bool RecvSet(const ObjectId &objId, const JSIDVariant &id, const JSVariant &value,
-                 const JSVariant &receiverVar, ReturnStatus *rs);
+    bool RecvHas(const ObjectId& objId, const JSIDVariant& id,
+                 ReturnStatus* rs, bool* bp);
+    bool RecvHasOwn(const ObjectId& objId, const JSIDVariant& id,
+                    ReturnStatus* rs, bool* bp);
+    bool RecvGet(const ObjectId& objId, const ObjectVariant& receiverVar,
+                 const JSIDVariant& id,
+                 ReturnStatus* rs, JSVariant* result);
+    bool RecvSet(const ObjectId& objId, const JSIDVariant& id, const JSVariant& value,
+                 const JSVariant& receiverVar, ReturnStatus* rs);
 
-    bool RecvIsExtensible(const ObjectId &objId, ReturnStatus *rs,
-                          bool *result);
-    bool RecvCallOrConstruct(const ObjectId &objId, InfallibleTArray<JSParam> &&argv,
-                             const bool &construct, ReturnStatus *rs, JSVariant *result,
-                             nsTArray<JSParam> *outparams);
-    bool RecvHasInstance(const ObjectId &objId, const JSVariant &v, ReturnStatus *rs, bool *bp);
-    bool RecvObjectClassIs(const ObjectId &objId, const uint32_t &classValue,
-                           bool *result);
-    bool RecvClassName(const ObjectId &objId, nsCString *result);
-    bool RecvGetPrototype(const ObjectId &objId, ReturnStatus *rs, ObjectOrNullVariant *result);
-    bool RecvRegExpToShared(const ObjectId &objId, ReturnStatus *rs, nsString *source, uint32_t *flags);
+    bool RecvIsExtensible(const ObjectId& objId, ReturnStatus* rs,
+                          bool* result);
+    bool RecvCallOrConstruct(const ObjectId& objId, InfallibleTArray<JSParam>&& argv,
+                             const bool& construct, ReturnStatus* rs, JSVariant* result,
+                             nsTArray<JSParam>* outparams);
+    bool RecvHasInstance(const ObjectId& objId, const JSVariant& v, ReturnStatus* rs, bool* bp);
+    bool RecvObjectClassIs(const ObjectId& objId, const uint32_t& classValue,
+                           bool* result);
+    bool RecvClassName(const ObjectId& objId, nsCString* result);
+    bool RecvGetPrototype(const ObjectId& objId, ReturnStatus* rs, ObjectOrNullVariant* result);
+    bool RecvRegExpToShared(const ObjectId& objId, ReturnStatus* rs, nsString* source, uint32_t* flags);
 
-    bool RecvGetPropertyKeys(const ObjectId &objId, const uint32_t &flags,
-                             ReturnStatus *rs, nsTArray<JSIDVariant> *ids);
-    bool RecvInstanceOf(const ObjectId &objId, const JSIID &iid,
-                        ReturnStatus *rs, bool *instanceof);
-    bool RecvDOMInstanceOf(const ObjectId &objId, const int &prototypeID, const int &depth,
-                           ReturnStatus *rs, bool *instanceof);
+    bool RecvGetPropertyKeys(const ObjectId& objId, const uint32_t& flags,
+                             ReturnStatus* rs, nsTArray<JSIDVariant>* ids);
+    bool RecvInstanceOf(const ObjectId& objId, const JSIID& iid,
+                        ReturnStatus* rs, bool* instanceof);
+    bool RecvDOMInstanceOf(const ObjectId& objId, const int& prototypeID, const int& depth,
+                           ReturnStatus* rs, bool* instanceof);
 
-    bool RecvDropObject(const ObjectId &objId);
+    bool RecvDropObject(const ObjectId& objId);
 
   private:
-    bool fail(JSContext *cx, ReturnStatus *rs);
-    bool ok(ReturnStatus *rs);
-    bool ok(ReturnStatus *rs, const JS::ObjectOpResult &result);
+    bool fail(JSContext* cx, ReturnStatus* rs);
+    bool ok(ReturnStatus* rs);
+    bool ok(ReturnStatus* rs, const JS::ObjectOpResult& result);
 };
 
 } // mozilla
 } // jsipc
 
 #endif
--- a/js/ipc/WrapperOwner.cpp
+++ b/js/ipc/WrapperOwner.cpp
@@ -35,138 +35,138 @@ struct AuxCPOWData
 
     // The class name for WrapperOwner::className, below.
     nsCString className;
 
     AuxCPOWData(ObjectId id,
                 bool isCallable,
                 bool isConstructor,
                 bool isDOMObject,
-                const nsACString &objectTag)
+                const nsACString& objectTag)
       : id(id),
         isCallable(isCallable),
         isConstructor(isConstructor),
         isDOMObject(isDOMObject),
         objectTag(objectTag)
     {}
 };
 
-WrapperOwner::WrapperOwner(JSRuntime *rt)
+WrapperOwner::WrapperOwner(JSRuntime* rt)
   : JavaScriptShared(rt),
     inactive_(false)
 {
 }
 
-static inline AuxCPOWData *
-AuxCPOWDataOf(JSObject *obj)
+static inline AuxCPOWData*
+AuxCPOWDataOf(JSObject* obj)
 {
     MOZ_ASSERT(IsCPOW(obj));
-    return static_cast<AuxCPOWData *>(GetProxyExtra(obj, 1).toPrivate());
+    return static_cast<AuxCPOWData*>(GetProxyExtra(obj, 1).toPrivate());
 }
 
-static inline WrapperOwner *
-OwnerOf(JSObject *obj)
+static inline WrapperOwner*
+OwnerOf(JSObject* obj)
 {
     MOZ_ASSERT(IsCPOW(obj));
-    return reinterpret_cast<WrapperOwner *>(GetProxyExtra(obj, 0).toPrivate());
+    return reinterpret_cast<WrapperOwner*>(GetProxyExtra(obj, 0).toPrivate());
 }
 
 ObjectId
-WrapperOwner::idOfUnchecked(JSObject *obj)
+WrapperOwner::idOfUnchecked(JSObject* obj)
 {
     MOZ_ASSERT(IsCPOW(obj));
 
-    AuxCPOWData *aux = AuxCPOWDataOf(obj);
+    AuxCPOWData* aux = AuxCPOWDataOf(obj);
     MOZ_ASSERT(!aux->id.isNull());
     return aux->id;
 }
 
 ObjectId
-WrapperOwner::idOf(JSObject *obj)
+WrapperOwner::idOf(JSObject* obj)
 {
     ObjectId objId = idOfUnchecked(obj);
     MOZ_ASSERT(findCPOWById(objId) == obj);
     return objId;
 }
 
 class CPOWProxyHandler : public BaseProxyHandler
 {
   public:
     MOZ_CONSTEXPR CPOWProxyHandler()
       : BaseProxyHandler(&family) {}
 
     virtual bool finalizeInBackground(Value priv) const override {
         return false;
     }
 
-    virtual bool getOwnPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
+    virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
                                           MutableHandle<JSPropertyDescriptor> desc) const override;
-    virtual bool defineProperty(JSContext *cx, HandleObject proxy, HandleId id,
+    virtual bool defineProperty(JSContext* cx, HandleObject proxy, HandleId id,
                                 Handle<JSPropertyDescriptor> desc,
-                                ObjectOpResult &result) const override;
-    virtual bool ownPropertyKeys(JSContext *cx, HandleObject proxy,
-                                 AutoIdVector &props) const override;
-    virtual bool delete_(JSContext *cx, HandleObject proxy, HandleId id,
-                         ObjectOpResult &result) const override;
-    virtual bool enumerate(JSContext *cx, HandleObject proxy, MutableHandleObject objp) const override;
-    virtual bool preventExtensions(JSContext *cx, HandleObject proxy,
-                                   ObjectOpResult &result) const override;
-    virtual bool isExtensible(JSContext *cx, HandleObject proxy, bool *extensible) const override;
-    virtual bool has(JSContext *cx, HandleObject proxy, HandleId id, bool *bp) const override;
-    virtual bool get(JSContext *cx, HandleObject proxy, HandleObject receiver,
+                                ObjectOpResult& result) const override;
+    virtual bool ownPropertyKeys(JSContext* cx, HandleObject proxy,
+                                 AutoIdVector& props) const override;
+    virtual bool delete_(JSContext* cx, HandleObject proxy, HandleId id,
+                         ObjectOpResult& result) const override;
+    virtual bool enumerate(JSContext* cx, HandleObject proxy, MutableHandleObject objp) const override;
+    virtual bool preventExtensions(JSContext* cx, HandleObject proxy,
+                                   ObjectOpResult& result) const override;
+    virtual bool isExtensible(JSContext* cx, HandleObject proxy, bool* extensible) const override;
+    virtual bool has(JSContext* cx, HandleObject proxy, HandleId id, bool* bp) const override;
+    virtual bool get(JSContext* cx, HandleObject proxy, HandleObject receiver,
                      HandleId id, MutableHandleValue vp) const override;
-    virtual bool set(JSContext *cx, JS::HandleObject proxy, JS::HandleId id, JS::HandleValue v,
-                     JS::HandleValue receiver, JS::ObjectOpResult &result) const override;
-    virtual bool call(JSContext *cx, HandleObject proxy, const CallArgs &args) const override;
-    virtual bool construct(JSContext *cx, HandleObject proxy, const CallArgs &args) const override;
+    virtual bool set(JSContext* cx, JS::HandleObject proxy, JS::HandleId id, JS::HandleValue v,
+                     JS::HandleValue receiver, JS::ObjectOpResult& result) const override;
+    virtual bool call(JSContext* cx, HandleObject proxy, const CallArgs& args) const override;
+    virtual bool construct(JSContext* cx, HandleObject proxy, const CallArgs& args) const override;
 
-    virtual bool getPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
+    virtual bool getPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
                                        MutableHandle<JSPropertyDescriptor> desc) const override;
-    virtual bool hasOwn(JSContext *cx, HandleObject proxy, HandleId id, bool *bp) const override;
-    virtual bool getOwnEnumerablePropertyKeys(JSContext *cx, HandleObject proxy,
-                                              AutoIdVector &props) const override;
-    virtual bool hasInstance(JSContext *cx, HandleObject proxy,
-                             MutableHandleValue v, bool *bp) const override;
+    virtual bool hasOwn(JSContext* cx, HandleObject proxy, HandleId id, bool* bp) const override;
+    virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject proxy,
+                                              AutoIdVector& props) const override;
+    virtual bool hasInstance(JSContext* cx, HandleObject proxy,
+                             MutableHandleValue v, bool* bp) const override;
     virtual bool objectClassIs(HandleObject obj, js::ESClassValue classValue,
-                               JSContext *cx) const override;
-    virtual const char* className(JSContext *cx, HandleObject proxy) const override;
-    virtual bool regexp_toShared(JSContext *cx, HandleObject proxy, RegExpGuard *g) const override;
-    virtual void finalize(JSFreeOp *fop, JSObject *proxy) const override;
-    virtual void objectMoved(JSObject *proxy, const JSObject *old) const override;
-    virtual bool isCallable(JSObject *obj) const override;
-    virtual bool isConstructor(JSObject *obj) const override;
-    virtual bool getPrototype(JSContext *cx, HandleObject proxy, MutableHandleObject protop) const override;
+                               JSContext* cx) const override;
+    virtual const char* className(JSContext* cx, HandleObject proxy) const override;
+    virtual bool regexp_toShared(JSContext* cx, HandleObject proxy, RegExpGuard* g) const override;
+    virtual void finalize(JSFreeOp* fop, JSObject* proxy) const override;
+    virtual void objectMoved(JSObject* proxy, const JSObject* old) const override;
+    virtual bool isCallable(JSObject* obj) const override;
+    virtual bool isConstructor(JSObject* obj) const override;
+    virtual bool getPrototype(JSContext* cx, HandleObject proxy, MutableHandleObject protop) const override;
 
     static const char family;
     static const CPOWProxyHandler singleton;
 };
 
 const char CPOWProxyHandler::family = 0;
 const CPOWProxyHandler CPOWProxyHandler::singleton;
 
 #define FORWARD(call, args)                                             \
-    WrapperOwner *owner = OwnerOf(proxy);                               \
+    WrapperOwner* owner = OwnerOf(proxy);                               \
     if (!owner->active()) {                                             \
         JS_ReportError(cx, "cannot use a CPOW whose process is gone");  \
         return false;                                                   \
     }                                                                   \
     {                                                                   \
         CPOWTimer timer;                                                \
         return owner->call args;                                        \
     }
 
 bool
-CPOWProxyHandler::getPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
+CPOWProxyHandler::getPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
                                         MutableHandle<JSPropertyDescriptor> desc) const
 {
     FORWARD(getPropertyDescriptor, (cx, proxy, id, desc));
 }
 
 bool
-WrapperOwner::getPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
+WrapperOwner::getPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
                                     MutableHandle<JSPropertyDescriptor> desc)
 {
     ObjectId objId = idOf(proxy);
 
     JSIDVariant idVar;
     if (!toJSIDVariant(cx, id, &idVar))
         return false;
 
@@ -179,24 +179,24 @@ WrapperOwner::getPropertyDescriptor(JSCo
 
     if (!ok(cx, status))
         return false;
 
     return toDescriptor(cx, result, desc);
 }
 
 bool
-CPOWProxyHandler::getOwnPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
+CPOWProxyHandler::getOwnPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
                                            MutableHandle<JSPropertyDescriptor> desc) const
 {
     FORWARD(getOwnPropertyDescriptor, (cx, proxy, id, desc));
 }
 
 bool
-WrapperOwner::getOwnPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
+WrapperOwner::getOwnPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
                                        MutableHandle<JSPropertyDescriptor> desc)
 {
     ObjectId objId = idOf(proxy);
 
     JSIDVariant idVar;
     if (!toJSIDVariant(cx, id, &idVar))
         return false;
 
@@ -209,27 +209,27 @@ WrapperOwner::getOwnPropertyDescriptor(J
 
     if (!ok(cx, status))
         return false;
 
     return toDescriptor(cx, result, desc);
 }
 
 bool
-CPOWProxyHandler::defineProperty(JSContext *cx, HandleObject proxy, HandleId id,
+CPOWProxyHandler::defineProperty(JSContext* cx, HandleObject proxy, HandleId id,
                                  Handle<JSPropertyDescriptor> desc,
-                                 ObjectOpResult &result) const
+                                 ObjectOpResult& result) const
 {
     FORWARD(defineProperty, (cx, proxy, id, desc, result));
 }
 
 bool
-WrapperOwner::defineProperty(JSContext *cx, HandleObject proxy, HandleId id,
+WrapperOwner::defineProperty(JSContext* cx, HandleObject proxy, HandleId id,
                              Handle<JSPropertyDescriptor> desc,
-                             ObjectOpResult &result)
+                             ObjectOpResult& result)
 {
     ObjectId objId = idOf(proxy);
 
     JSIDVariant idVar;
     if (!toJSIDVariant(cx, id, &idVar))
         return false;
 
     PPropertyDescriptor descriptor;
@@ -241,37 +241,37 @@ WrapperOwner::defineProperty(JSContext *
         return ipcfail(cx);
 
     LOG_STACK();
 
     return ok(cx, status, result);
 }
 
 bool
-CPOWProxyHandler::ownPropertyKeys(JSContext *cx, HandleObject proxy,
-                                  AutoIdVector &props) const
+CPOWProxyHandler::ownPropertyKeys(JSContext* cx, HandleObject proxy,
+                                  AutoIdVector& props) const
 {
     FORWARD(ownPropertyKeys, (cx, proxy, props));
 }
 
 bool
-WrapperOwner::ownPropertyKeys(JSContext *cx, HandleObject proxy, AutoIdVector &props)
+WrapperOwner::ownPropertyKeys(JSContext* cx, HandleObject proxy, AutoIdVector& props)
 {
     return getPropertyKeys(cx, proxy, JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS, props);
 }
 
 bool
-CPOWProxyHandler::delete_(JSContext *cx, HandleObject proxy, HandleId id,
-                          ObjectOpResult &result) const
+CPOWProxyHandler::delete_(JSContext* cx, HandleObject proxy, HandleId id,
+                          ObjectOpResult& result) const
 {
     FORWARD(delete_, (cx, proxy, id, result));
 }
 
 bool
-WrapperOwner::delete_(JSContext *cx, HandleObject proxy, HandleId id, ObjectOpResult &result)
+WrapperOwner::delete_(JSContext* cx, HandleObject proxy, HandleId id, ObjectOpResult& result)
 {
     ObjectId objId = idOf(proxy);
 
     JSIDVariant idVar;
     if (!toJSIDVariant(cx, id, &idVar))
         return false;
 
     ReturnStatus status;
@@ -279,32 +279,32 @@ WrapperOwner::delete_(JSContext *cx, Han
         return ipcfail(cx);
 
     LOG_STACK();
 
     return ok(cx, status, result);
 }
 
 bool
-CPOWProxyHandler::enumerate(JSContext *cx, HandleObject proxy, MutableHandleObject objp) const
+CPOWProxyHandler::enumerate(JSContext* cx, HandleObject proxy, MutableHandleObject objp) const
 {
     // Using a CPOW for the Iterator would slow down for .. in performance, instead
     // call the base hook, that will use our implementation of getOwnEnumerablePropertyKeys
     // and follow the proto chain.
     return BaseProxyHandler::enumerate(cx, proxy, objp);
 }
 
 bool
-CPOWProxyHandler::has(JSContext *cx, HandleObject proxy, HandleId id, bool *bp) const
+CPOWProxyHandler::has(JSContext* cx, HandleObject proxy, HandleId id, bool* bp) const
 {
     FORWARD(has, (cx, proxy, id, bp));
 }
 
 bool
-WrapperOwner::has(JSContext *cx, HandleObject proxy, HandleId id, bool *bp)
+WrapperOwner::has(JSContext* cx, HandleObject proxy, HandleId id, bool* bp)
 {
     ObjectId objId = idOf(proxy);
 
     JSIDVariant idVar;
     if (!toJSIDVariant(cx, id, &idVar))
         return false;
 
     ReturnStatus status;
@@ -312,23 +312,23 @@ WrapperOwner::has(JSContext *cx, HandleO
         return ipcfail(cx);
 
     LOG_STACK();
 
     return ok(cx, status);
 }
 
 bool
-CPOWProxyHandler::hasOwn(JSContext *cx, HandleObject proxy, HandleId id, bool *bp) const
+CPOWProxyHandler::hasOwn(JSContext* cx, HandleObject proxy, HandleId id, bool* bp) const
 {
     FORWARD(hasOwn, (cx, proxy, id, bp));
 }
 
 bool
-WrapperOwner::hasOwn(JSContext *cx, HandleObject proxy, HandleId id, bool *bp)
+WrapperOwner::hasOwn(JSContext* cx, HandleObject proxy, HandleId id, bool* bp)
 {
     ObjectId objId = idOf(proxy);
 
     JSIDVariant idVar;
     if (!toJSIDVariant(cx, id, &idVar))
         return false;
 
     ReturnStatus status;
@@ -336,37 +336,37 @@ WrapperOwner::hasOwn(JSContext *cx, Hand
         return ipcfail(cx);
 
     LOG_STACK();
 
     return !!ok(cx, status);
 }
 
 bool
-CPOWProxyHandler::get(JSContext *cx, HandleObject proxy, HandleObject receiver,
+CPOWProxyHandler::get(JSContext* cx, HandleObject proxy, HandleObject receiver,
                       HandleId id, MutableHandleValue vp) const
 {
     FORWARD(get, (cx, proxy, receiver, id, vp));
 }
 
 static bool
-CPOWDOMQI(JSContext *cx, unsigned argc, Value *vp)
+CPOWDOMQI(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
     if (!args.thisv().isObject() || !IsCPOW(&args.thisv().toObject())) {
         JS_ReportError(cx, "bad this object passed to special QI");
         return false;
     }
 
     RootedObject proxy(cx, &args.thisv().toObject());
     FORWARD(DOMQI, (cx, proxy, args));
 }
 
 static bool
-CPOWToString(JSContext *cx, unsigned argc, Value *vp)
+CPOWToString(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
     RootedObject callee(cx, &args.callee());
     RootedValue cpowValue(cx);
     if (!JS_GetProperty(cx, callee, "__cpow__", &cpowValue))
         return false;
 
     if (!cpowValue.isObject() || !IsCPOW(&cpowValue.toObject())) {
@@ -374,17 +374,17 @@ CPOWToString(JSContext *cx, unsigned arg
         return false;
     }
 
     RootedObject proxy(cx, &cpowValue.toObject());
     FORWARD(toString, (cx, proxy, args));
 }
 
 bool
-WrapperOwner::toString(JSContext *cx, HandleObject cpow, JS::CallArgs &args)
+WrapperOwner::toString(JSContext* cx, HandleObject cpow, JS::CallArgs& args)
 {
     // Ask the other side to call its toString method. Update the callee so that
     // it points to the CPOW and not to the synthesized CPOWToString function.
     args.setCallee(ObjectValue(*cpow));
     if (!callOrConstruct(cx, cpow, args, false))
         return false;
 
     if (!args.rval().isString())
@@ -401,38 +401,38 @@ WrapperOwner::toString(JSContext *cx, Ha
     if (toStringResult[0] == '[') {
         result.AppendLiteral("[object CPOW ");
         result += toStringResult;
         result.AppendLiteral("]");
     } else {
         result += toStringResult;
     }
 
-    JSString *str = JS_NewUCStringCopyN(cx, result.get(), result.Length());
+    JSString* str = JS_NewUCStringCopyN(cx, result.get(), result.Length());
     if (!str)
         return false;
 
     args.rval().setString(str);
     return true;
 }
 
 bool
-WrapperOwner::DOMQI(JSContext *cx, JS::HandleObject proxy, JS::CallArgs &args)
+WrapperOwner::DOMQI(JSContext* cx, JS::HandleObject proxy, JS::CallArgs& args)
 {
     // Someone's calling us, handle nsISupports specially to avoid unnecessary
     // CPOW traffic.
     HandleValue id = args[0];
     if (id.isObject()) {
         RootedObject idobj(cx, &id.toObject());
         nsCOMPtr<nsIJSID> jsid;
 
         nsresult rv = UnwrapArg<nsIJSID>(idobj, getter_AddRefs(jsid));
         if (NS_SUCCEEDED(rv)) {
             MOZ_ASSERT(jsid, "bad wrapJS");
-            const nsID *idptr = jsid->GetID();
+            const nsID* idptr = jsid->GetID();
             if (idptr->Equals(NS_GET_IID(nsISupports))) {
                 args.rval().set(args.thisv());
                 return true;
             }
 
             // Webidl-implemented DOM objects never have nsIClassInfo.
             if (idptr->Equals(NS_GET_IID(nsIClassInfo)))
                 return Throw(cx, NS_ERROR_NO_INTERFACE);
@@ -453,30 +453,30 @@ WrapperOwner::DOMQI(JSContext *cx, JS::H
     if (!propDesc.value().isObject()) {
         MOZ_ASSERT_UNREACHABLE("We didn't get QueryInterface off a node");
         return Throw(cx, NS_ERROR_UNEXPECTED);
     }
     return JS_CallFunctionValue(cx, proxy, propDesc.value(), args, args.rval());
 }
 
 bool
-WrapperOwner::get(JSContext *cx, HandleObject proxy, HandleObject receiver,
+WrapperOwner::get(JSContext* cx, HandleObject proxy, HandleObject receiver,
                   HandleId id, MutableHandleValue vp)
 {
     ObjectId objId = idOf(proxy);
 
     ObjectVariant receiverVar;
     if (!toObjectVariant(cx, receiver, &receiverVar))
         return false;
 
     JSIDVariant idVar;
     if (!toJSIDVariant(cx, id, &idVar))
         return false;
 
-    AuxCPOWData *data = AuxCPOWDataOf(proxy);
+    AuxCPOWData* data = AuxCPOWDataOf(proxy);
     if (data->isDOMObject &&
         idVar.type() == JSIDVariant::TnsString &&
         idVar.get_nsString().EqualsLiteral("QueryInterface"))
     {
         // Handle QueryInterface on DOM Objects specially since we can assume
         // certain things about their implementation.
         RootedFunction qi(cx, JS_NewFunction(cx, CPOWDOMQI, 1, 0,
                                              "QueryInterface"));
@@ -514,25 +514,25 @@ WrapperOwner::get(JSContext *cx, HandleO
 
         vp.set(ObjectValue(*toStringObj));
     }
 
     return true;
 }
 
 bool
-CPOWProxyHandler::set(JSContext *cx, JS::HandleObject proxy, JS::HandleId id, JS::HandleValue v,
-                      JS::HandleValue receiver, JS::ObjectOpResult &result) const
+CPOWProxyHandler::set(JSContext* cx, JS::HandleObject proxy, JS::HandleId id, JS::HandleValue v,
+                      JS::HandleValue receiver, JS::ObjectOpResult& result) const
 {
     FORWARD(set, (cx, proxy, id, v, receiver, result));
 }
 
 bool
-WrapperOwner::set(JSContext *cx, JS::HandleObject proxy, JS::HandleId id, JS::HandleValue v,
-                  JS::HandleValue receiver, JS::ObjectOpResult &result)
+WrapperOwner::set(JSContext* cx, JS::HandleObject proxy, JS::HandleId id, JS::HandleValue v,
+                  JS::HandleValue receiver, JS::ObjectOpResult& result)
 {
     ObjectId objId = idOf(proxy);
 
     JSIDVariant idVar;
     if (!toJSIDVariant(cx, id, &idVar))
         return false;
 
     JSVariant val;
@@ -548,82 +548,82 @@ WrapperOwner::set(JSContext *cx, JS::Han
         return ipcfail(cx);
 
     LOG_STACK();
 
     return ok(cx, status, result);
 }
 
 bool
-CPOWProxyHandler::getOwnEnumerablePropertyKeys(JSContext *cx, HandleObject proxy,
-                                               AutoIdVector &props) const
+CPOWProxyHandler::getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject proxy,
+                                               AutoIdVector& props) const
 {
     FORWARD(getOwnEnumerablePropertyKeys, (cx, proxy, props));
 }
 
 bool
-WrapperOwner::getOwnEnumerablePropertyKeys(JSContext *cx, HandleObject proxy, AutoIdVector &props)
+WrapperOwner::getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject proxy, AutoIdVector& props)
 {
     return getPropertyKeys(cx, proxy, JSITER_OWNONLY, props);
 }
 
 bool
-CPOWProxyHandler::preventExtensions(JSContext *cx, HandleObject proxy, ObjectOpResult &result) const
+CPOWProxyHandler::preventExtensions(JSContext* cx, HandleObject proxy, ObjectOpResult& result) const
 {
     FORWARD(preventExtensions, (cx, proxy, result));
 }
 
 bool
-WrapperOwner::preventExtensions(JSContext *cx, HandleObject proxy, ObjectOpResult &result)
+WrapperOwner::preventExtensions(JSContext* cx, HandleObject proxy, ObjectOpResult& result)
 {
     ObjectId objId = idOf(proxy);
 
     ReturnStatus status;
     if (!SendPreventExtensions(objId, &status))
         return ipcfail(cx);
 
     LOG_STACK();
 
     return ok(cx, status, result);
 }
 
 bool
-CPOWProxyHandler::isExtensible(JSContext *cx, HandleObject proxy, bool *extensible) const
+CPOWProxyHandler::isExtensible(JSContext* cx, HandleObject proxy, bool* extensible) const
 {
     FORWARD(isExtensible, (cx, proxy, extensible));
 }
 
 bool
-WrapperOwner::isExtensible(JSContext *cx, HandleObject proxy, bool *extensible)
+WrapperOwner::isExtensible(JSContext* cx, HandleObject proxy, bool* extensible)
 {
     ObjectId objId = idOf(proxy);
 
     ReturnStatus status;
     if (!SendIsExtensible(objId, &status, extensible))
         return ipcfail(cx);
 
     LOG_STACK();
 
     return ok(cx, status);
 }
 
 bool
-CPOWProxyHandler::call(JSContext *cx, HandleObject proxy, const CallArgs &args) const
+CPOWProxyHandler::call(JSContext* cx, HandleObject proxy, const CallArgs& args) const
 {
     FORWARD(callOrConstruct, (cx, proxy, args, false));
 }
 
 bool
-CPOWProxyHandler::construct(JSContext *cx, HandleObject proxy, const CallArgs &args) const
+CPOWProxyHandler::construct(JSContext* cx, HandleObject proxy, const CallArgs& args) const
 {
     FORWARD(callOrConstruct, (cx, proxy, args, true));
 }
 
 bool
-WrapperOwner::callOrConstruct(JSContext *cx, HandleObject proxy, const CallArgs &args,
+WrapperOwner::callOrConstruct(JSContext* cx, HandleObject proxy, const CallArgs& args,
                               bool construct)
 {
     ObjectId objId = idOf(proxy);
 
     InfallibleTArray<JSParam> vals;
     AutoValueVector outobjects(cx);
 
     RootedValue v(cx);
@@ -690,23 +690,23 @@ WrapperOwner::callOrConstruct(JSContext 
 
     if (!fromVariant(cx, result, args.rval()))
         return false;
 
     return true;
 }
 
 bool
-CPOWProxyHandler::hasInstance(JSContext *cx, HandleObject proxy, MutableHandleValue v, bool *bp) const
+CPOWProxyHandler::hasInstance(JSContext* cx, HandleObject proxy, MutableHandleValue v, bool* bp) const
 {
     FORWARD(hasInstance, (cx, proxy, v, bp));
 }
 
 bool
-WrapperOwner::hasInstance(JSContext *cx, HandleObject proxy, MutableHandleValue v, bool *bp)
+WrapperOwner::hasInstance(JSContext* cx, HandleObject proxy, MutableHandleValue v, bool* bp)
 {
     ObjectId objId = idOf(proxy);
 
     JSVariant vVar;
     if (!toVariant(cx, v, &vVar))
         return false;
 
     ReturnStatus status;
@@ -715,70 +715,70 @@ WrapperOwner::hasInstance(JSContext *cx,
         return ipcfail(cx);
 
     LOG_STACK();
 
     return ok(cx, status);
 }
 
 bool
-CPOWProxyHandler::objectClassIs(HandleObject proxy, js::ESClassValue classValue, JSContext *cx) const
+CPOWProxyHandler::objectClassIs(HandleObject proxy, js::ESClassValue classValue, JSContext* cx) const
 {
     FORWARD(objectClassIs, (cx, proxy, classValue));
 }
 
 bool
-WrapperOwner::objectClassIs(JSContext *cx, HandleObject proxy, js::ESClassValue classValue)
+WrapperOwner::objectClassIs(JSContext* cx, HandleObject proxy, js::ESClassValue classValue)
 {
     ObjectId objId = idOf(proxy);
 
     // This function is assumed infallible, so we just return false if the IPC
     // channel fails.
     bool result;
     if (!SendObjectClassIs(objId, classValue, &result))
         return false;
 
     LOG_STACK();
 
     return result;
 }
 
-const char *
-CPOWProxyHandler::className(JSContext *cx, HandleObject proxy) const
+const char*
+CPOWProxyHandler::className(JSContext* cx, HandleObject proxy) const
 {
-    WrapperOwner *parent = OwnerOf(proxy);
+    WrapperOwner* parent = OwnerOf(proxy);
     if (!parent->active())
         return "<dead CPOW>";
     return parent->className(cx, proxy);
 }
 
-const char *
-WrapperOwner::className(JSContext *cx, HandleObject proxy)
+const char*
+WrapperOwner::className(JSContext* cx, HandleObject proxy)
 {
-    AuxCPOWData *data = AuxCPOWDataOf(proxy);
+    AuxCPOWData* data = AuxCPOWDataOf(proxy);
     if (data->className.IsEmpty()) {
         ObjectId objId = idOf(proxy);
 
         if (!SendClassName(objId, &data->className))
             return "<error>";
 
         LOG_STACK();
     }
 
     return data->className.get();
 }
 
 bool
-CPOWProxyHandler::getPrototype(JSContext *cx, HandleObject proxy, MutableHandleObject objp) const
+CPOWProxyHandler::getPrototype(JSContext* cx, HandleObject proxy, MutableHandleObject objp) const
 {
     FORWARD(getPrototype, (cx, proxy, objp));
 }
 
 bool
-WrapperOwner::getPrototype(JSContext *cx, HandleObject proxy, MutableHandleObject objp)
+WrapperOwner::getPrototype(JSContext* cx, HandleObject proxy, MutableHandleObject objp)
 {
     ObjectId objId = idOf(proxy);
 
     ObjectOrNullVariant val;
     ReturnStatus status;
     if (!SendGetPrototype(objId, &status, &val))
         return ipcfail(cx);
 
@@ -788,23 +788,23 @@ WrapperOwner::getPrototype(JSContext *cx
         return false;
 
     objp.set(fromObjectOrNullVariant(cx, val));
 
     return true;
 }
 
 bool
-CPOWProxyHandler::regexp_toShared(JSContext *cx, HandleObject proxy, RegExpGuard *g) const
+CPOWProxyHandler::regexp_toShared(JSContext* cx, HandleObject proxy, RegExpGuard* g) const
 {
     FORWARD(regexp_toShared, (cx, proxy, g));
 }
 
 bool
-WrapperOwner::regexp_toShared(JSContext *cx, HandleObject proxy, RegExpGuard *g)
+WrapperOwner::regexp_toShared(JSContext* cx, HandleObject proxy, RegExpGuard* g)
 {
     ObjectId objId = idOf(proxy);
 
     ReturnStatus status;
     nsString source;
     unsigned flags = 0;
     if (!SendRegExpToShared(objId, &status, &source, &flags))
         return ipcfail(cx);
@@ -819,76 +819,76 @@ WrapperOwner::regexp_toShared(JSContext 
     regexp = JS_NewUCRegExpObject(cx, global, source.get(), source.Length(), flags);
     if (!regexp)
         return false;
 
     return js::RegExpToSharedNonInline(cx, regexp, g);
 }
 
 void
-CPOWProxyHandler::finalize(JSFreeOp *fop, JSObject *proxy) const
+CPOWProxyHandler::finalize(JSFreeOp* fop, JSObject* proxy) const
 {
-    AuxCPOWData *aux = AuxCPOWDataOf(proxy);
+    AuxCPOWData* aux = AuxCPOWDataOf(proxy);
 
     OwnerOf(proxy)->drop(proxy);
 
     if (aux)
         delete aux;
 }
 
 void
-CPOWProxyHandler::objectMoved(JSObject *proxy, const JSObject *old) const
+CPOWProxyHandler::objectMoved(JSObject* proxy, const JSObject* old) const
 {
     OwnerOf(proxy)->updatePointer(proxy, old);
 }
 
 bool
-CPOWProxyHandler::isCallable(JSObject *proxy) const
+CPOWProxyHandler::isCallable(JSObject* proxy) const
 {
-    AuxCPOWData *aux = AuxCPOWDataOf(proxy);
+    AuxCPOWData* aux = AuxCPOWDataOf(proxy);
     return aux->isCallable;
 }
 
 bool
-CPOWProxyHandler::isConstructor(JSObject *proxy) const
+CPOWProxyHandler::isConstructor(JSObject* proxy) const
 {
-    AuxCPOWData *aux = AuxCPOWDataOf(proxy);
+    AuxCPOWData* aux = AuxCPOWDataOf(proxy);
     return aux->isConstructor;
 }
 
 void
-WrapperOwner::drop(JSObject *obj)
+WrapperOwner::drop(JSObject* obj)
 {
     ObjectId objId = idOf(obj);
 
     cpows_.remove(objId);
     if (active())
         unused << SendDropObject(objId);
     decref();
 }
 
 void
-WrapperOwner::updatePointer(JSObject *obj, const JSObject *old)
+WrapperOwner::updatePointer(JSObject* obj, const JSObject* old)
 {
     ObjectId objId = idOfUnchecked(obj);
     MOZ_ASSERT(findCPOWById(objId) == old);
     cpows_.add(objId, obj);
 }
 
 bool
 WrapperOwner::init()
 {
     if (!JavaScriptShared::init())
         return false;
 
     return true;
 }
 
 bool
-WrapperOwner::getPropertyKeys(JSContext *cx, HandleObject proxy, uint32_t flags, AutoIdVector &props)
+WrapperOwner::getPropertyKeys(JSContext* cx, HandleObject proxy, uint32_t flags, AutoIdVector& props)
 {
     ObjectId objId = idOf(proxy);
 
     ReturnStatus status;
     InfallibleTArray<JSIDVariant> ids;
     if (!SendGetPropertyKeys(objId, flags, &status, &ids))
         return ipcfail(cx);
 
@@ -907,61 +907,61 @@ WrapperOwner::getPropertyKeys(JSContext 
 
     return true;
 }
 
 namespace mozilla {
 namespace jsipc {
 
 bool
-IsCPOW(JSObject *obj)
+IsCPOW(JSObject* obj)
 {
     return IsProxy(obj) && GetProxyHandler(obj) == &CPOWProxyHandler::singleton;
 }
 
 bool
-IsWrappedCPOW(JSObject *obj)
+IsWrappedCPOW(JSObject* obj)
 {
-    JSObject *unwrapped = js::UncheckedUnwrap(obj, true);
+    JSObject* unwrapped = js::UncheckedUnwrap(obj, true);
     if (!unwrapped)
         return false;
     return IsCPOW(unwrapped);
 }
 
 void
-GetWrappedCPOWTag(JSObject *obj, nsACString &out)
+GetWrappedCPOWTag(JSObject* obj, nsACString& out)
 {
-    JSObject *unwrapped = js::UncheckedUnwrap(obj, true);
+    JSObject* unwrapped = js::UncheckedUnwrap(obj, true);
     MOZ_ASSERT(IsCPOW(unwrapped));
 
-    AuxCPOWData *aux = AuxCPOWDataOf(unwrapped);
+    AuxCPOWData* aux = AuxCPOWDataOf(unwrapped);
     if (aux)
         out = aux->objectTag;
 }
 
 nsresult
-InstanceOf(JSObject *proxy, const nsID *id, bool *bp)
+InstanceOf(JSObject* proxy, const nsID* id, bool* bp)
 {
-    WrapperOwner *parent = OwnerOf(proxy);
+    WrapperOwner* parent = OwnerOf(proxy);
     if (!parent->active())
         return NS_ERROR_UNEXPECTED;
     return parent->instanceOf(proxy, id, bp);
 }
 
 bool
-DOMInstanceOf(JSContext *cx, JSObject *proxy, int prototypeID, int depth, bool *bp)
+DOMInstanceOf(JSContext* cx, JSObject* proxy, int prototypeID, int depth, bool* bp)
 {
     FORWARD(domInstanceOf, (cx, proxy, prototypeID, depth, bp));
 }
 
 } /* namespace jsipc */
 } /* namespace mozilla */
 
 nsresult
-WrapperOwner::instanceOf(JSObject *obj, const nsID *id, bool *bp)
+WrapperOwner::instanceOf(JSObject* obj, const nsID* id, bool* bp)
 {
     ObjectId objId = idOf(obj);
 
     JSIID iid;
     ConvertID(*id, &iid);
 
     ReturnStatus status;
     if (!SendInstanceOf(objId, iid, &status, bp))
@@ -969,17 +969,17 @@ WrapperOwner::instanceOf(JSObject *obj, 
 
     if (status.type() != ReturnStatus::TReturnSuccess)
         return NS_ERROR_UNEXPECTED;
 
     return NS_OK;
 }
 
 bool
-WrapperOwner::domInstanceOf(JSContext *cx, JSObject *obj, int prototypeID, int depth, bool *bp)
+WrapperOwner::domInstanceOf(JSContext* cx, JSObject* obj, int prototypeID, int depth, bool* bp)
 {
     ObjectId objId = idOf(obj);
 
     ReturnStatus status;
     if (!SendDOMInstanceOf(objId, prototypeID, depth, &status, bp))
         return ipcfail(cx);
 
     LOG_STACK();
@@ -993,51 +993,51 @@ WrapperOwner::ActorDestroy(ActorDestroyR
     inactive_ = true;
 
     objects_.clear();
     unwaivedObjectIds_.clear();
     waivedObjectIds_.clear();
 }
 
 bool
-WrapperOwner::ipcfail(JSContext *cx)
+WrapperOwner::ipcfail(JSContext* cx)
 {
     JS_ReportError(cx, "child process crashed or timedout");
     return false;
 }
 
 bool
-WrapperOwner::ok(JSContext *cx, const ReturnStatus &status)
+WrapperOwner::ok(JSContext* cx, const ReturnStatus& status)
 {
     if (status.type() == ReturnStatus::TReturnSuccess)
         return true;
 
     if (status.type() == ReturnStatus::TReturnStopIteration)
         return JS_ThrowStopIteration(cx);
 
     RootedValue exn(cx);
     if (!fromVariant(cx, status.get_ReturnException().exn(), &exn))
         return false;
 
     JS_SetPendingException(cx, exn);
     return false;
 }
 
 bool
-WrapperOwner::ok(JSContext *cx, const ReturnStatus &status, ObjectOpResult &result)
+WrapperOwner::ok(JSContext* cx, const ReturnStatus& status, ObjectOpResult& result)
 {
     if (status.type() == ReturnStatus::TReturnObjectOpResult)
         return result.fail(status.get_ReturnObjectOpResult().code());
     if (!ok(cx, status))
         return false;
     return result.succeed();
 }
 
 static RemoteObject
-MakeRemoteObject(JSContext *cx, ObjectId id, HandleObject obj)
+MakeRemoteObject(JSContext* cx, ObjectId id, HandleObject obj)
 {
     nsCString objectTag;
 
     nsCOMPtr<nsIRemoteTagService> service =
         do_GetService("@mozilla.org/addons/remote-tag-service;1");
     if (service) {
         RootedValue objVal(cx, ObjectValue(*obj));
         service->GetRemoteObjectTag(objVal, objectTag);
@@ -1046,17 +1046,17 @@ MakeRemoteObject(JSContext *cx, ObjectId
     return RemoteObject(id.serialize(),
                         JS::IsCallable(obj),
                         JS::IsConstructor(obj),
                         dom::IsDOMObject(obj),
                         objectTag);
 }
 
 bool
-WrapperOwner::toObjectVariant(JSContext *cx, JSObject *objArg, ObjectVariant *objVarp)
+WrapperOwner::toObjectVariant(JSContext* cx, JSObject* objArg, ObjectVariant* objVarp)
 {
     RootedObject obj(cx, objArg);
     MOZ_ASSERT(obj);
 
     // We always save objects unwrapped in the CPOW table. If we stored
     // wrappers, then the wrapper might be GCed while the target remained alive.
     // Whenever operating on an object that comes from the table, we wrap it
     // in findObjectById.
@@ -1085,28 +1085,28 @@ WrapperOwner::toObjectVariant(JSContext 
         return false;
     if (!objectIdMap(waiveXray).add(cx, obj, id))
         return false;
 
     *objVarp = MakeRemoteObject(cx, id, obj);
     return true;
 }
 
-JSObject *
-WrapperOwner::fromObjectVariant(JSContext *cx, ObjectVariant objVar)
+JSObject*
+WrapperOwner::fromObjectVariant(JSContext* cx, ObjectVariant objVar)
 {
     if (objVar.type() == ObjectVariant::TRemoteObject) {
         return fromRemoteObjectVariant(cx, objVar.get_RemoteObject());
     } else {
         return fromLocalObjectVariant(cx, objVar.get_LocalObject());
     }
 }
 
-JSObject *
-WrapperOwner::fromRemoteObjectVariant(JSContext *cx, RemoteObject objVar)
+JSObject*
+WrapperOwner::fromRemoteObjectVariant(JSContext* cx, RemoteObject objVar)
 {
     ObjectId objId = ObjectId::deserialize(objVar.serializedId());
     RootedObject obj(cx, findCPOWById(objId));
     if (!obj) {
 
         // All CPOWs live in the privileged junk scope.
         RootedObject junkScope(cx, xpc::PrivilegedJunkScope());
         JSAutoCompartment ac(cx, junkScope);
@@ -1123,33 +1123,33 @@ WrapperOwner::fromRemoteObjectVariant(JS
             return nullptr;
 
         if (!cpows_.add(objId, obj))
             return nullptr;
 
         // Incref once we know the decref will be called.
         incref();
 
-        AuxCPOWData *aux = new AuxCPOWData(objId,
+        AuxCPOWData* aux = new AuxCPOWData(objId,
                                            objVar.isCallable(),
                                            objVar.isConstructor(),
                                            objVar.isDOMObject(),
                                            objVar.objectTag());
 
         SetProxyExtra(obj, 0, PrivateValue(this));
         SetProxyExtra(obj, 1, PrivateValue(aux));
     }
 
     if (!JS_WrapObject(cx, &obj))
         return nullptr;
     return obj;
 }
 
-JSObject *
-WrapperOwner::fromLocalObjectVariant(JSContext *cx, LocalObject objVar)
+JSObject*
+WrapperOwner::fromLocalObjectVariant(JSContext* cx, LocalObject objVar)
 {
     ObjectId id = ObjectId::deserialize(objVar.serializedId());
     Rooted<JSObject*> obj(cx, findObjectById(cx, id));
     if (!obj)
         return nullptr;
     if (!JS_WrapObject(cx, &obj))
         return nullptr;
     return obj;
--- a/js/ipc/WrapperOwner.h
+++ b/js/ipc/WrapperOwner.h
@@ -19,141 +19,141 @@ namespace jsipc {
 
 class WrapperOwner : public virtual JavaScriptShared
 {
   public:
     typedef mozilla::ipc::IProtocolManager<
                        mozilla::ipc::IProtocol>::ActorDestroyReason
            ActorDestroyReason;
 
-    explicit WrapperOwner(JSRuntime *rt);
+    explicit WrapperOwner(JSRuntime* rt);
     bool init();
 
     // Standard internal methods.
     // (The traps should be in the same order like js/Proxy.h)
-    bool getOwnPropertyDescriptor(JSContext *cx, JS::HandleObject proxy, JS::HandleId id,
+    bool getOwnPropertyDescriptor(JSContext* cx, JS::HandleObject proxy, JS::HandleId id,
                                   JS::MutableHandle<JSPropertyDescriptor> desc);
-    bool defineProperty(JSContext *cx, JS::HandleObject proxy, JS::HandleId id,
+    bool defineProperty(JSContext* cx, JS::HandleObject proxy, JS::HandleId id,
                         JS::Handle<JSPropertyDescriptor> desc,
-                        JS::ObjectOpResult &result);
-    bool ownPropertyKeys(JSContext *cx, JS::HandleObject proxy, JS::AutoIdVector &props);
-    bool delete_(JSContext *cx, JS::HandleObject proxy, JS::HandleId id,
-                 JS::ObjectOpResult &result);
-    bool preventExtensions(JSContext *cx, JS::HandleObject proxy, JS::ObjectOpResult &result);
-    bool isExtensible(JSContext *cx, JS::HandleObject proxy, bool *extensible);
-    bool has(JSContext *cx, JS::HandleObject proxy, JS::HandleId id, bool *bp);
-    bool get(JSContext *cx, JS::HandleObject proxy, JS::HandleObject receiver,
+                        JS::ObjectOpResult& result);
+    bool ownPropertyKeys(JSContext* cx, JS::HandleObject proxy, JS::AutoIdVector& props);
+    bool delete_(JSContext* cx, JS::HandleObject proxy, JS::HandleId id,
+                 JS::ObjectOpResult& result);
+    bool preventExtensions(JSContext* cx, JS::HandleObject proxy, JS::ObjectOpResult& result);
+    bool isExtensible(JSContext* cx, JS::HandleObject proxy, bool* extensible);
+    bool has(JSContext* cx, JS::HandleObject proxy, JS::HandleId id, bool* bp);
+    bool get(JSContext* cx, JS::HandleObject proxy, JS::HandleObject receiver,
              JS::HandleId id, JS::MutableHandleValue vp);
-    bool set(JSContext *cx, JS::HandleObject proxy, JS::HandleId id, JS::HandleValue v,
-             JS::HandleValue receiver, JS::ObjectOpResult &result);
-    bool callOrConstruct(JSContext *cx, JS::HandleObject proxy, const JS::CallArgs &args,
+    bool set(JSContext* cx, JS::HandleObject proxy, JS::HandleId id, JS::HandleValue v,
+             JS::HandleValue receiver, JS::ObjectOpResult& result);
+    bool callOrConstruct(JSContext* cx, JS::HandleObject proxy, const JS::CallArgs& args,
                          bool construct);
 
     // SpiderMonkey extensions.
-    bool getPropertyDescriptor(JSContext *cx, JS::HandleObject proxy, JS::HandleId id,
+    bool getPropertyDescriptor(JSContext* cx, JS::HandleObject proxy, JS::HandleId id,
                                JS::MutableHandle<JSPropertyDescriptor> desc);
-    bool hasOwn(JSContext *cx, JS::HandleObject proxy, JS::HandleId id, bool *bp);
-    bool getOwnEnumerablePropertyKeys(JSContext *cx, JS::HandleObject proxy,
-                                      JS::AutoIdVector &props);
-    bool hasInstance(JSContext *cx, JS::HandleObject proxy, JS::MutableHandleValue v, bool *bp);
-    bool objectClassIs(JSContext *cx, JS::HandleObject obj, js::ESClassValue classValue);
-    const char* className(JSContext *cx, JS::HandleObject proxy);
-    bool getPrototype(JSContext *cx, JS::HandleObject proxy, JS::MutableHandleObject protop);
+    bool hasOwn(JSContext* cx, JS::HandleObject proxy, JS::HandleId id, bool* bp);
+    bool getOwnEnumerablePropertyKeys(JSContext* cx, JS::HandleObject proxy,
+                                      JS::AutoIdVector& props);
+    bool hasInstance(JSContext* cx, JS::HandleObject proxy, JS::MutableHandleValue v, bool* bp);
+    bool objectClassIs(JSContext* cx, JS::HandleObject obj, js::ESClassValue classValue);
+    const char* className(JSContext* cx, JS::HandleObject proxy);
+    bool getPrototype(JSContext* cx, JS::HandleObject proxy, JS::MutableHandleObject protop);
 
-    bool regexp_toShared(JSContext *cx, JS::HandleObject proxy, js::RegExpGuard *g);
+    bool regexp_toShared(JSContext* cx, JS::HandleObject proxy, js::RegExpGuard* g);
 
-    nsresult instanceOf(JSObject *obj, const nsID *id, bool *bp);
+    nsresult instanceOf(JSObject* obj, const nsID* id, bool* bp);
 
-    bool toString(JSContext *cx, JS::HandleObject callee, JS::CallArgs &args);
-    bool DOMQI(JSContext *cx, JS::HandleObject callee, JS::CallArgs &args);
+    bool toString(JSContext* cx, JS::HandleObject callee, JS::CallArgs& args);
+    bool DOMQI(JSContext* cx, JS::HandleObject callee, JS::CallArgs& args);
 
     /*
      * Check that |obj| is a DOM wrapper whose prototype chain contains
      * |prototypeID| at depth |depth|.
      */
-    bool domInstanceOf(JSContext *cx, JSObject *obj, int prototypeID, int depth, bool *bp);
+    bool domInstanceOf(JSContext* cx, JSObject* obj, int prototypeID, int depth, bool* bp);
 
     bool active() { return !inactive_; }
 
-    void drop(JSObject *obj);
-    void updatePointer(JSObject *obj, const JSObject *old);
+    void drop(JSObject* obj);
+    void updatePointer(JSObject* obj, const JSObject* old);
 
     virtual void ActorDestroy(ActorDestroyReason why);
 
-    virtual bool toObjectVariant(JSContext *cx, JSObject *obj, ObjectVariant *objVarp);
-    virtual JSObject *fromObjectVariant(JSContext *cx, ObjectVariant objVar);
-    JSObject *fromRemoteObjectVariant(JSContext *cx, RemoteObject objVar);
-    JSObject *fromLocalObjectVariant(JSContext *cx, LocalObject objVar);
+    virtual bool toObjectVariant(JSContext* cx, JSObject* obj, ObjectVariant* objVarp);
+    virtual JSObject* fromObjectVariant(JSContext* cx, ObjectVariant objVar);
+    JSObject* fromRemoteObjectVariant(JSContext* cx, RemoteObject objVar);
+    JSObject* fromLocalObjectVariant(JSContext* cx, LocalObject objVar);
 
   protected:
-    ObjectId idOf(JSObject *obj);
+    ObjectId idOf(JSObject* obj);
 
   private:
-    ObjectId idOfUnchecked(JSObject *obj);
+    ObjectId idOfUnchecked(JSObject* obj);
 
-    bool getPropertyKeys(JSContext *cx, JS::HandleObject proxy, uint32_t flags,
-                         JS::AutoIdVector &props);
+    bool getPropertyKeys(JSContext* cx, JS::HandleObject proxy, uint32_t flags,
+                         JS::AutoIdVector& props);
 
     // Catastrophic IPC failure.
-    bool ipcfail(JSContext *cx);
+    bool ipcfail(JSContext* cx);
 
     // Check whether a return status is okay, and if not, propagate its error.
     //
     // If 'status' might be a ReturnObjectOpResult, which is only possible for
     // a subset of the operations below, 'result' must be passed.
-    bool ok(JSContext *cx, const ReturnStatus &status, JS::ObjectOpResult &result);
-    bool ok(JSContext *cx, const ReturnStatus &status);
+    bool ok(JSContext* cx, const ReturnStatus& status, JS::ObjectOpResult& result);
+    bool ok(JSContext* cx, const ReturnStatus& status);
 
     bool inactive_;
 
     /*** Dummy call handlers ***/
   public:
-    virtual bool SendDropObject(const ObjectId &objId) = 0;
-    virtual bool SendPreventExtensions(const ObjectId &objId, ReturnStatus *rs) = 0;
-    virtual bool SendGetPropertyDescriptor(const ObjectId &objId, const JSIDVariant &id,
-                                           ReturnStatus *rs,
-                                           PPropertyDescriptor *out) = 0;
-    virtual bool SendGetOwnPropertyDescriptor(const ObjectId &objId,
-                                              const JSIDVariant &id,
-                                              ReturnStatus *rs,
-                                              PPropertyDescriptor *out) = 0;
-    virtual bool SendDefineProperty(const ObjectId &objId, const JSIDVariant &id,
-                                    const PPropertyDescriptor &flags,
-                                    ReturnStatus *rs) = 0;
-    virtual bool SendDelete(const ObjectId &objId, const JSIDVariant &id,
-                            ReturnStatus *rs) = 0;
+    virtual bool SendDropObject(const ObjectId& objId) = 0;
+    virtual bool SendPreventExtensions(const ObjectId& objId, ReturnStatus* rs) = 0;
+    virtual bool SendGetPropertyDescriptor(const ObjectId& objId, const JSIDVariant& id,
+                                           ReturnStatus* rs,
+                                           PPropertyDescriptor* out) = 0;
+    virtual bool SendGetOwnPropertyDescriptor(const ObjectId& objId,
+                                              const JSIDVariant& id,
+                                              ReturnStatus* rs,
+                                              PPropertyDescriptor* out) = 0;
+    virtual bool SendDefineProperty(const ObjectId& objId, const JSIDVariant& id,
+                                    const PPropertyDescriptor& flags,
+                                    ReturnStatus* rs) = 0;
+    virtual bool SendDelete(const ObjectId& objId, const JSIDVariant& id,
+                            ReturnStatus* rs) = 0;
 
-    virtual bool SendHas(const ObjectId &objId, const JSIDVariant &id,
-                         ReturnStatus *rs, bool *bp) = 0;
-    virtual bool SendHasOwn(const ObjectId &objId, const JSIDVariant &id,
-                            ReturnStatus *rs, bool *bp) = 0;
-    virtual bool SendGet(const ObjectId &objId, const ObjectVariant &receiverVar,
-                         const JSIDVariant &id,
-                         ReturnStatus *rs, JSVariant *result) = 0;
-    virtual bool SendSet(const ObjectId &objId, const JSIDVariant &id, const JSVariant &value,
-                         const JSVariant &receiverVar, ReturnStatus *rs) = 0;
+    virtual bool SendHas(const ObjectId& objId, const JSIDVariant& id,
+                         ReturnStatus* rs, bool* bp) = 0;
+    virtual bool SendHasOwn(const ObjectId& objId, const JSIDVariant& id,
+                            ReturnStatus* rs, bool* bp) = 0;
+    virtual bool SendGet(const ObjectId& objId, const ObjectVariant& receiverVar,
+                         const JSIDVariant& id,
+                         ReturnStatus* rs, JSVariant* result) = 0;
+    virtual bool SendSet(const ObjectId& objId, const JSIDVariant& id, const JSVariant& value,
+                         const JSVariant& receiverVar, ReturnStatus* rs) = 0;
 
-    virtual bool SendIsExtensible(const ObjectId &objId, ReturnStatus *rs,
-                                  bool *result) = 0;
-    virtual bool SendCallOrConstruct(const ObjectId &objId, const nsTArray<JSParam> &argv,
-                                     const bool &construct, ReturnStatus *rs, JSVariant *result,
-                                     nsTArray<JSParam> *outparams) = 0;
-    virtual bool SendHasInstance(const ObjectId &objId, const JSVariant &v,
-                                 ReturnStatus *rs, bool *bp) = 0;
-    virtual bool SendObjectClassIs(const ObjectId &objId, const uint32_t &classValue,
-                                   bool *result) = 0;
-    virtual bool SendClassName(const ObjectId &objId, nsCString *result) = 0;
-    virtual bool SendGetPrototype(const ObjectId &objId, ReturnStatus *rs, ObjectOrNullVariant *result) = 0;
-    virtual bool SendRegExpToShared(const ObjectId &objId, ReturnStatus *rs, nsString *source,
-                                    uint32_t *flags) = 0;
+    virtual bool SendIsExtensible(const ObjectId& objId, ReturnStatus* rs,
+                                  bool* result) = 0;
+    virtual bool SendCallOrConstruct(const ObjectId& objId, const nsTArray<JSParam>& argv,
+                                     const bool& construct, ReturnStatus* rs, JSVariant* result,
+                                     nsTArray<JSParam>* outparams) = 0;
+    virtual bool SendHasInstance(const ObjectId& objId, const JSVariant& v,
+                                 ReturnStatus* rs, bool* bp) = 0;
+    virtual bool SendObjectClassIs(const ObjectId& objId, const uint32_t& classValue,
+                                   bool* result) = 0;
+    virtual bool SendClassName(const ObjectId& objId, nsCString* result) = 0;
+    virtual bool SendGetPrototype(const ObjectId& objId, ReturnStatus* rs, ObjectOrNullVariant* result) = 0;
+    virtual bool SendRegExpToShared(const ObjectId& objId, ReturnStatus* rs, nsString* source,
+                                    uint32_t* flags) = 0;
 
-    virtual bool SendGetPropertyKeys(const ObjectId &objId, const uint32_t &flags,
-                                     ReturnStatus *rs, nsTArray<JSIDVariant> *ids) = 0;
-    virtual bool SendInstanceOf(const ObjectId &objId, const JSIID &iid,
-                                ReturnStatus *rs, bool *instanceof) = 0;
-    virtual bool SendDOMInstanceOf(const ObjectId &objId, const int &prototypeID, const int &depth,
-                                   ReturnStatus *rs, bool *instanceof) = 0;
+    virtual bool SendGetPropertyKeys(const ObjectId& objId, const uint32_t& flags,
+                                     ReturnStatus* rs, nsTArray<JSIDVariant>* ids) = 0;
+    virtual bool SendInstanceOf(const ObjectId& objId, const JSIID& iid,
+                                ReturnStatus* rs, bool* instanceof) = 0;
+    virtual bool SendDOMInstanceOf(const ObjectId& objId, const int& prototypeID, const int& depth,
+                                   ReturnStatus* rs, bool* instanceof) = 0;
 };
 
 } // jsipc
 } // mozilla
 
 #endif // mozilla_jsipc_WrapperOwner_h__
--- a/js/public/CallArgs.h
+++ b/js/public/CallArgs.h
@@ -4,17 +4,17 @@
  * 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/. */
 
 /*
  * Helper classes encapsulating access to the callee, |this| value, arguments,
  * and argument count for a function call.
  *
  * The intent of JS::CallArgs and JS::CallReceiver is that they be used to
- * encapsulate access to the un-abstracted |unsigned argc, Value *vp| arguments
+ * encapsulate access to the un-abstracted |unsigned argc, Value* vp| arguments
  * to a function.  It's possible (albeit deprecated) to manually index into
  * |vp| to access the callee, |this|, and arguments of a function, and to set
  * its return value.  It's also possible to use the supported API of JS_CALLEE,
  * JS_THIS, JS_ARGV, JS_RVAL and JS_SET_RVAL to the same ends.  But neither API
  * has the error-handling or moving-GC correctness of CallArgs or CallReceiver.
  * New code should use CallArgs and CallReceiver instead whenever possible.
  *
  * The eventual plan is to change JSNative to take |const CallArgs&| directly,
@@ -35,47 +35,47 @@
 
 #include "jstypes.h"
 
 #include "js/RootingAPI.h"
 #include "js/Value.h"
 
 /* Typedef for native functions called by the JS VM. */
 typedef bool
-(* JSNative)(JSContext *cx, unsigned argc, JS::Value *vp);
+(* JSNative)(JSContext* cx, unsigned argc, JS::Value* vp);
 
 /*
  * Compute |this| for the |vp| inside a JSNative, either boxing primitives or
  * replacing with the global object as necessary.
  *
  * This method will go away at some point: instead use |args.thisv()|.  If the
  * value is an object, no further work is required.  If that value is |null| or
  * |undefined|, use |JS_GetGlobalForObject| to compute the global object.  If
  * the value is some other primitive, use |JS_ValueToObject| to box it.
  */
 extern JS_PUBLIC_API(JS::Value)
-JS_ComputeThis(JSContext *cx, JS::Value *vp);
+JS_ComputeThis(JSContext* cx, JS::Value* vp);
 
 namespace JS {
 
 extern JS_PUBLIC_DATA(const HandleValue) UndefinedHandleValue;
 
 /*
  * JS::CallReceiver encapsulates access to the callee, |this|, and eventual
  * return value for a function call.  The principal way to create a
  * CallReceiver is using JS::CallReceiverFromVp:
  *
  *   static bool
- *   FunctionReturningThis(JSContext *cx, unsigned argc, JS::Value *vp)
+ *   FunctionReturningThis(JSContext* cx, unsigned argc, JS::Value* vp)
  *   {
  *       JS::CallReceiver rec = JS::CallReceiverFromVp(vp);
  *
  *       // Access to the callee must occur before accessing/setting
  *       // the return value.
- *       JSObject &callee = rec.callee();
+ *       JSObject& callee = rec.callee();
  *       rec.rval().set(JS::ObjectValue(callee));
  *
  *       // callee() and calleev() will now assert.
  *
  *       // It's always fine to access thisv().
  *       HandleValue thisv = rec.thisv();
  *       rec.rval().set(thisv);
  *
@@ -127,24 +127,24 @@ class MOZ_STACK_CLASS CallReceiverBase :
 #ifdef JS_DEBUG
         WantUsedRval
 #else
         NoUsedRval
 #endif
     >
 {
   protected:
-    Value *argv_;
+    Value* argv_;
 
   public:
     /*
      * Returns the function being called, as an object.  Must not be called
      * after rval() has been used!
      */
-    JSObject &callee() const {
+    JSObject& callee() const {
         MOZ_ASSERT(!this->usedRval_);
         return argv_[-2].toObject();
     }
 
     /*
      * Returns the function being called, as a value.  Must not be called after
      * rval() has been used!
      */
@@ -161,17 +161,17 @@ class MOZ_STACK_CLASS CallReceiverBase :
      */
     HandleValue thisv() const {
         // Some internal code uses thisv() in constructing cases, so don't do
         // this yet.
         // MOZ_ASSERT(!argv_[-1].isMagic(JS_IS_CONSTRUCTING));
         return HandleValue::fromMarkedLocation(&argv_[-1]);
     }
 
-    Value computeThis(JSContext *cx) const {
+    Value computeThis(JSContext* cx) const {
         if (thisv().isObject())
             return thisv();
 
         return JS_ComputeThis(cx, base());
     }
 
     bool isConstructing() const {
 #ifdef JS_DEBUG
@@ -196,19 +196,19 @@ class MOZ_STACK_CLASS CallReceiverBase :
         this->setUsedRval();
         return MutableHandleValue::fromMarkedLocation(&argv_[-2]);
     }
 
   public:
     // These methods are only intended for internal use.  Embedders shouldn't
     // use them!
 
-    Value *base() const { return argv_ - 2; }
+    Value* base() const { return argv_ - 2; }
 
-    Value *spAfterCall() const {
+    Value* spAfterCall() const {
         this->setUsedRval();
         return argv_ - 1;
     }
 
   public:
     // These methods are publicly exposed, but they are *not* to be used when
     // implementing a JSNative method and encapsulating access to |vp| within
     // it.  You probably don't want to use these!
@@ -227,42 +227,42 @@ class MOZ_STACK_CLASS CallReceiverBase :
     }
 };
 
 } // namespace detail
 
 class MOZ_STACK_CLASS CallReceiver : public detail::CallReceiverBase<detail::IncludeUsedRval>
 {
   private:
-    friend CallReceiver CallReceiverFromVp(Value *vp);
-    friend CallReceiver CallReceiverFromArgv(Value *argv);
+    friend CallReceiver CallReceiverFromVp(Value* vp);
+    friend CallReceiver CallReceiverFromArgv(Value* argv);
 };
 
 MOZ_ALWAYS_INLINE CallReceiver
-CallReceiverFromArgv(Value *argv)
+CallReceiverFromArgv(Value* argv)
 {
     CallReceiver receiver;
     receiver.clearUsedRval();
     receiver.argv_ = argv;
     return receiver;
 }
 
 MOZ_ALWAYS_INLINE CallReceiver
-CallReceiverFromVp(Value *vp)
+CallReceiverFromVp(Value* vp)
 {
     return CallReceiverFromArgv(vp + 2);
 }
 
 /*
  * JS::CallArgs encapsulates everything JS::CallReceiver does, plus access to
  * the function call's arguments.  The principal way to create a CallArgs is
  * like so, using JS::CallArgsFromVp:
  *
  *   static bool
- *   FunctionReturningArgcTimesArg0(JSContext *cx, unsigned argc, JS::Value *vp)
+ *   FunctionReturningArgcTimesArg0(JSContext* cx, unsigned argc, JS::Value* vp)
  *   {
  *       JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
  *
  *       // Guard against no arguments or a non-numeric arg0.
  *       if (args.length() == 0 || !args[0].isNumber()) {
  *           args.rval().setInt32(0);
  *           return true;
  *       }
@@ -314,77 +314,77 @@ class MOZ_STACK_CLASS CallArgsBase :
         return i < argc_ && !this->argv_[i].isUndefined();
     }
 
   public:
     // These methods are publicly exposed, but we're less sure of the interface
     // here than we'd like (because they're hackish and drop assertions).  Try
     // to avoid using these if you can.
 
-    Value *array() const { return this->argv_; }
-    Value *end() const { return this->argv_ + argc_; }
+    Value* array() const { return this->argv_; }
+    Value* end() const { return this->argv_ + argc_; }
 };
 
 } // namespace detail
 
 class MOZ_STACK_CLASS CallArgs : public detail::CallArgsBase<detail::IncludeUsedRval>
 {
   private:
-    friend CallArgs CallArgsFromVp(unsigned argc, Value *vp);
-    friend CallArgs CallArgsFromSp(unsigned argc, Value *sp);
+    friend CallArgs CallArgsFromVp(unsigned argc, Value* vp);
+    friend CallArgs CallArgsFromSp(unsigned argc, Value* sp);
 
-    static CallArgs create(unsigned argc, Value *argv) {
+    static CallArgs create(unsigned argc, Value* argv) {
         CallArgs args;
         args.clearUsedRval();
         args.argv_ = argv;
         args.argc_ = argc;
         return args;
     }
 
   public:
     /*
      * Returns true if there are at least |required| arguments passed in. If
      * false, it reports an error message on the context.
      */
-    bool requireAtLeast(JSContext *cx, const char *fnname, unsigned required);
+    bool requireAtLeast(JSContext* cx, const char* fnname, unsigned required);
 
 };
 
 MOZ_ALWAYS_INLINE CallArgs
-CallArgsFromVp(unsigned argc, Value *vp)
+CallArgsFromVp(unsigned argc, Value* vp)
 {
     return CallArgs::create(argc, vp + 2);
 }
 
 // This method is only intended for internal use in SpiderMonkey.  We may
 // eventually move it to an internal header.  Embedders should use
 // JS::CallArgsFromVp!
 MOZ_ALWAYS_INLINE CallArgs
-CallArgsFromSp(unsigned argc, Value *sp)
+CallArgsFromSp(unsigned argc, Value* sp)
 {
     return CallArgs::create(argc, sp - argc);
 }
 
 } // namespace JS
 
 /*
  * Macros to hide interpreter stack layout details from a JSNative using its
- * JS::Value *vp parameter.  DO NOT USE THESE!  Instead use JS::CallArgs and
+ * JS::Value* vp parameter.  DO NOT USE THESE!  Instead use JS::CallArgs and
  * friends, above.  These macros will be removed when we change JSNative to
  * take a const JS::CallArgs&.
  */
 
 #define JS_THIS_OBJECT(cx,vp)   (JS_THIS(cx,vp).toObjectOrNull())
 
 /*
  * Note: if this method returns null, an error has occurred and must be
  * propagated or caught.
  */
 MOZ_ALWAYS_INLINE JS::Value
-JS_THIS(JSContext *cx, JS::Value *vp)
+JS_THIS(JSContext* cx, JS::Value* vp)
 {
     return vp[1].isPrimitive() ? JS_ComputeThis(cx, vp) : vp[1];
 }
 
 /*
  * |this| is passed to functions in ES5 without change.  Functions themselves
  * do any post-processing they desire to box |this|, compute the global object,
  * &c.  This macro retrieves a function's unboxed |this| value.
--- a/js/public/CallNonGenericMethod.h
+++ b/js/public/CallNonGenericMethod.h
@@ -13,23 +13,23 @@
 
 namespace JS {
 
 // Returns true if |v| is considered an acceptable this-value.
 typedef bool (*IsAcceptableThis)(HandleValue v);
 
 // Implements the guts of a method; guaranteed to be provided an acceptable
 // this-value, as determined by a corresponding IsAcceptableThis method.
-typedef bool (*NativeImpl)(JSContext *cx, CallArgs args);
+typedef bool (*NativeImpl)(JSContext* cx, CallArgs args);
 
 namespace detail {
 
 // DON'T CALL THIS DIRECTLY.  It's for use only by CallNonGenericMethod!
 extern JS_PUBLIC_API(bool)
-CallMethodIfWrapped(JSContext *cx, IsAcceptableThis test, NativeImpl impl, CallArgs args);
+CallMethodIfWrapped(JSContext* cx, IsAcceptableThis test, NativeImpl impl, CallArgs args);
 
 } // namespace detail
 
 // Methods usually act upon |this| objects only from a single global object and
 // compartment.  Sometimes, however, a method must act upon |this| values from
 // multiple global objects or compartments.  In such cases the |this| value a
 // method might see will be wrapped, such that various access to the object --
 // to its class, its private data, its reserved slots, and so on -- will not
@@ -39,43 +39,43 @@ CallMethodIfWrapped(JSContext *cx, IsAcc
 // To implement a method that accepts |this| values from multiple compartments,
 // define two functions.  The first function matches the IsAcceptableThis type
 // and indicates whether the provided value is an acceptable |this| for the
 // method; it must be a pure function only of its argument.
 //
 //   static const JSClass AnswerClass = { ... };
 //
 //   static bool
-//   IsAnswerObject(const Value &v)
+//   IsAnswerObject(const Value& v)
 //   {
 //       if (!v.isObject())
 //           return false;
 //       return JS_GetClass(&v.toObject()) == &AnswerClass;
 //   }
 //
 // The second function implements the NativeImpl signature and defines the
 // behavior of the method when it is provided an acceptable |this| value.
 // Aside from some typing niceties -- see the CallArgs interface for details --
 // its interface is the same as that of JSNative.
 //
 //   static bool
-//   answer_getAnswer_impl(JSContext *cx, JS::CallArgs args)
+//   answer_getAnswer_impl(JSContext* cx, JS::CallArgs args)
 //   {
 //       args.rval().setInt32(42);
 //       return true;
 //   }
 //
 // The implementation function is guaranteed to be called *only* with a |this|
 // value which is considered acceptable.
 //
 // Now to implement the actual method, write a JSNative that calls the method
 // declared below, passing the appropriate template and runtime arguments.
 //
 //   static bool
-//   answer_getAnswer(JSContext *cx, unsigned argc, JS::Value *vp)
+//   answer_getAnswer(JSContext* cx, unsigned argc, JS::Value* vp)
 //   {
 //       JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 //       return JS::CallNonGenericMethod<IsAnswerObject, answer_getAnswer_impl>(cx, args);
 //   }
 //
 // Note that, because they are used as template arguments, the predicate
 // and implementation functions must have external linkage. (This is
 // unfortunate, but GCC wasn't inlining things as one would hope when we
@@ -88,27 +88,27 @@ CallMethodIfWrapped(JSContext *cx, IsAcc
 // that succeeds, all well and good.  If it doesn't succeed, a TypeError will
 // be thrown.
 //
 // Note: JS::CallNonGenericMethod will only work correctly if it's called in
 //       tail position in a JSNative.  Do not call it from any other place.
 //
 template<IsAcceptableThis Test, NativeImpl Impl>
 MOZ_ALWAYS_INLINE bool
-CallNonGenericMethod(JSContext *cx, CallArgs args)
+CallNonGenericMethod(JSContext* cx, CallArgs args)
 {
     HandleValue thisv = args.thisv();
     if (Test(thisv))
         return Impl(cx, args);
 
     return detail::CallMethodIfWrapped(cx, Test, Impl, args);
 }
 
 MOZ_ALWAYS_INLINE bool
-CallNonGenericMethod(JSContext *cx, IsAcceptableThis Test, NativeImpl Impl, CallArgs args)
+CallNonGenericMethod(JSContext* cx, IsAcceptableThis Test, NativeImpl Impl, CallArgs args)
 {
     HandleValue thisv = args.thisv();
     if (Test(thisv))
         return Impl(cx, args);
 
     return detail::CallMethodIfWrapped(cx, Test, Impl, args);
 }
 
--- a/js/public/CharacterEncoding.h
+++ b/js/public/CharacterEncoding.h
@@ -27,122 +27,122 @@ namespace JS {
  * string containing characters beyond U+00FF.
  */
 class Latin1Chars : public mozilla::Range<Latin1Char>
 {
     typedef mozilla::Range<Latin1Char> Base;
 
   public:
     Latin1Chars() : Base() {}
-    Latin1Chars(char *aBytes, size_t aLength) : Base(reinterpret_cast<Latin1Char *>(aBytes), aLength) {}
-    Latin1Chars(const Latin1Char *aBytes, size_t aLength)
-      : Base(const_cast<Latin1Char *>(aBytes), aLength)
+    Latin1Chars(char* aBytes, size_t aLength) : Base(reinterpret_cast<Latin1Char*>(aBytes), aLength) {}
+    Latin1Chars(const Latin1Char* aBytes, size_t aLength)
+      : Base(const_cast<Latin1Char*>(aBytes), aLength)
     {}
-    Latin1Chars(const char *aBytes, size_t aLength)
-      : Base(reinterpret_cast<Latin1Char *>(const_cast<char *>(aBytes)), aLength)
+    Latin1Chars(const char* aBytes, size_t aLength)
+      : Base(reinterpret_cast<Latin1Char*>(const_cast<char*>(aBytes)), aLength)
     {}
 };
 
 /*
  * A Latin1Chars, but with \0 termination for C compatibility.
  */
 class Latin1CharsZ : public mozilla::RangedPtr<Latin1Char>
 {
     typedef mozilla::RangedPtr<Latin1Char> Base;
 
   public:
     Latin1CharsZ() : Base(nullptr, 0) {}
 
-    Latin1CharsZ(char *aBytes, size_t aLength)
-      : Base(reinterpret_cast<Latin1Char *>(aBytes), aLength)
+    Latin1CharsZ(char* aBytes, size_t aLength)
+      : Base(reinterpret_cast<Latin1Char*>(aBytes), aLength)
     {
         MOZ_ASSERT(aBytes[aLength] == '\0');
     }
 
-    Latin1CharsZ(Latin1Char *aBytes, size_t aLength)
+    Latin1CharsZ(Latin1Char* aBytes, size_t aLength)
       : Base(aBytes, aLength)
     {
         MOZ_ASSERT(aBytes[aLength] == '\0');
     }
 
     using Base::operator=;
 
-    char *c_str() { return reinterpret_cast<char *>(get()); }
+    char* c_str() { return reinterpret_cast<char*>(get()); }
 };
 
 class UTF8Chars : public mozilla::Range<unsigned char>
 {
     typedef mozilla::Range<unsigned char> Base;
 
   public:
     UTF8Chars() : Base() {}
-    UTF8Chars(char *aBytes, size_t aLength)
-      : Base(reinterpret_cast<unsigned char *>(aBytes), aLength)
+    UTF8Chars(char* aBytes, size_t aLength)
+      : Base(reinterpret_cast<unsigned char*>(aBytes), aLength)
     {}
-    UTF8Chars(const char *aBytes, size_t aLength)
-      : Base(reinterpret_cast<unsigned char *>(const_cast<char *>(aBytes)), aLength)
+    UTF8Chars(const char* aBytes, size_t aLength)
+      : Base(reinterpret_cast<unsigned char*>(const_cast<char*>(aBytes)), aLength)
     {}
 };
 
 /*
  * SpiderMonkey also deals directly with UTF-8 encoded text in some places.
  */
 class UTF8CharsZ : public mozilla::RangedPtr<unsigned char>