Bug 1144366 - Switch SpiderMonkey and XPConnect style from |T *t| to |T* t|. r=jorendorff
authorJan de Mooij <jdemooij@mozilla.com>
Sat, 28 Mar 2015 23:22:11 +0100
changeset 236396 02f2f4c75007651c63bbc0791d9a58dea88f545f
parent 236395 df0b52334a1dbdb58a309ac31a32248a397cd43f
child 236403 385840329d91d1b469111b1e0471d41e36e257be
child 236411 e19def475b91d36c13de902824c3818de2ab6287
push id14797
push userphilringnalda@gmail.com
push dateSun, 29 Mar 2015 04:41:41 +0000
treeherderb2g-inbound@385840329d91 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjorendorff
bugs1144366
milestone39.0a1
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>
 {
     typedef mozilla::RangedPtr<unsigned char> Base;
 
   public:
     UTF8CharsZ() : Base(nullptr, 0) {}
 
-    UTF8CharsZ(char *aBytes, size_t aLength)
-      : Base(reinterpret_cast<unsigned char *>(aBytes), aLength)
+    UTF8CharsZ(char* aBytes, size_t aLength)
+      : Base(reinterpret_cast<unsigned char*>(aBytes), aLength)
     {
         MOZ_ASSERT(aBytes[aLength] == '\0');
     }
 
-    UTF8CharsZ(unsigned char *aBytes, size_t aLength)
+    UTF8CharsZ(unsigned char* 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()); }
 };
 
 /*
  * SpiderMonkey uses a 2-byte character representation: it is a
  * 2-byte-at-a-time view of a UTF-16 byte stream. This is similar to UCS-2,
  * but unlike UCS-2, we do not strip UTF-16 extension bytes. This allows a
  * sufficiently dedicated JavaScript program to be fully unicode-aware by
  * manually interpreting UTF-16 extension characters embedded in the JS
  * string.
  */
 class TwoByteChars : public mozilla::Range<char16_t>
 {
     typedef mozilla::Range<char16_t> Base;
 
   public:
     TwoByteChars() : Base() {}
-    TwoByteChars(char16_t *aChars, size_t aLength) : Base(aChars, aLength) {}
-    TwoByteChars(const char16_t *aChars, size_t aLength) : Base(const_cast<char16_t *>(aChars), aLength) {}
+    TwoByteChars(char16_t* aChars, size_t aLength) : Base(aChars, aLength) {}
+    TwoByteChars(const char16_t* aChars, size_t aLength) : Base(const_cast<char16_t*>(aChars), aLength) {}
 };
 
 /*
  * A TwoByteChars, but \0 terminated for compatibility with JSFlatString.
  */
 class TwoByteCharsZ : public mozilla::RangedPtr<char16_t>
 {
     typedef mozilla::RangedPtr<char16_t> Base;
 
   public:
     TwoByteCharsZ() : Base(nullptr, 0) {}
 
-    TwoByteCharsZ(char16_t *chars, size_t length)
+    TwoByteCharsZ(char16_t* chars, size_t length)
       : Base(chars, length)
     {
         MOZ_ASSERT(chars[length] == '\0');
     }
 
     using Base::operator=;
 };
 
@@ -152,69 +152,69 @@ typedef mozilla::RangedPtr<const char16_
  * Like TwoByteChars, but the chars are const.
  */
 class ConstTwoByteChars : public mozilla::Range<const char16_t>
 {
     typedef mozilla::Range<const char16_t> Base;
 
   public:
     ConstTwoByteChars() : Base() {}
-    ConstTwoByteChars(const char16_t *aChars, size_t aLength) : Base(aChars, aLength) {}
+    ConstTwoByteChars(const char16_t* aChars, size_t aLength) : Base(aChars, aLength) {}
 };
 
 /*
  * Convert a 2-byte character sequence to "ISO-Latin-1". This works by
  * truncating each 2-byte pair in the sequence to a 1-byte pair. If the source
  * contains any UTF-16 extension characters, then this may give invalid Latin1
  * output. The returned string is zero terminated. The returned string or the
  * returned string's |start()| must be freed with JS_free or js_free,
  * respectively. If allocation fails, an OOM error will be set and the method
  * will return a nullptr chars (which can be tested for with the ! operator).
  * This method cannot trigger GC.
  */
 extern Latin1CharsZ
-LossyTwoByteCharsToNewLatin1CharsZ(js::ExclusiveContext *cx,
+LossyTwoByteCharsToNewLatin1CharsZ(js::ExclusiveContext* cx,
                                    const mozilla::Range<const char16_t> tbchars);
 
 template <typename CharT>
 extern UTF8CharsZ
-CharsToNewUTF8CharsZ(js::ExclusiveContext *cx, const mozilla::Range<const CharT> chars);
+CharsToNewUTF8CharsZ(js::ExclusiveContext* cx, const mozilla::Range<const CharT> chars);