Bug 902332 - Replace JS_{FALSE,TRUE} with {false,true} almost everywhere. r=luke,bz.
authorNicholas Nethercote <nnethercote@mozilla.com>
Tue, 06 Aug 2013 23:59:54 -0700
changeset 149730 ade325617a7322f9869ce67b359255c542c74587
parent 149729 56912957f3e96b7a549202dab4e96cd321da3daa
child 149731 ab9642207875d08e6351bfe0edaabc165095d4ec
push idunknown
push userunknown
push dateunknown
reviewersluke, bz
bugs902332
milestone26.0a1
Bug 902332 - Replace JS_{FALSE,TRUE} with {false,true} almost everywhere. r=luke,bz.
caps/src/nsScriptSecurityManager.cpp
content/xbl/src/nsXBLDocumentInfo.cpp
content/xbl/src/nsXBLProtoImplMethod.cpp
content/xul/document/src/nsXULPrototypeDocument.cpp
dom/base/nsDOMClassInfo.cpp
dom/base/nsGlobalWindow.cpp
dom/base/nsJSEnvironment.cpp
dom/base/nsJSUtils.cpp
dom/base/nsJSUtils.h
dom/bluetooth/BluetoothHfpManager.cpp
dom/indexedDB/KeyPath.cpp
dom/plugins/base/nsJSNPRuntime.cpp
dom/plugins/ipc/PluginScriptableObjectParent.cpp
dom/src/geolocation/nsGeolocation.cpp
dom/src/json/nsJSON.cpp
dom/system/gonk/TimeZoneSettingObserver.cpp
gfx/skia/src/xml/SkJS.cpp
gfx/skia/src/xml/SkJSDisplayable.cpp
ipc/testshell/TestShellParent.cpp
ipc/testshell/XPCShellEnvironment.cpp
ipc/testshell/XPCShellEnvironment.h
js/ipc/JavaScriptShared.cpp
js/jsd/idl/jsdIDebuggerService.idl
js/jsd/jsd_high.cpp
js/jsd/jsd_hook.cpp
js/jsd/jsd_lock.cpp
js/jsd/jsd_scpt.cpp
js/jsd/jsd_stak.cpp
js/jsd/jsd_step.cpp
js/jsd/jsd_text.cpp
js/jsd/jsd_val.cpp
js/jsd/jsd_xpc.cpp
js/jsd/jsdebug.cpp
js/jsd/jsdebug.h
js/jsd/jshash.cpp
js/public/Value.h
js/src/builtin/Profilers.cpp
js/src/ctypes/CTypes.cpp
js/src/ion/arm/Trampoline-arm.cpp
js/src/jsapi-tests/testClassGetter.cpp
js/src/jsapi-tests/testDebugger.cpp
js/src/jsapi-tests/testDefineGetterSetterNonEnumerable.cpp
js/src/jsapi-tests/testIndexToString.cpp
js/src/jsapi-tests/testJSEvaluateScript.cpp
js/src/jsapi-tests/testOps.cpp
js/src/jsapi-tests/testPropCache.cpp
js/src/jsapi-tests/testSetProperty.cpp
js/src/jsapi-tests/testSourcePolicy.cpp
js/src/jsapi-tests/testTrap.cpp
js/src/jsapi-tests/tests.h
js/src/jsapi.cpp
js/src/jsapi.h
js/src/jscntxt.cpp
js/src/jsdate.cpp
js/src/jsdbgapi.cpp
js/src/jsdbgapi.h
js/src/jsdtoa.cpp
js/src/jsexn.h
js/src/jsfun.cpp
js/src/jsnum.cpp
js/src/jsobj.cpp
js/src/json.cpp
js/src/jsopcode.cpp
js/src/jspubtd.h
js/src/jsreflect.cpp
js/src/jsscript.cpp
js/src/jsstr.cpp
js/src/jstypes.h
js/src/jswrapper.cpp
js/src/perf/jsperf.cpp
js/src/shell/js.cpp
js/src/vm/ArgumentsObject.cpp
js/src/vm/Interpreter.cpp
js/xpconnect/idl/nsIXPCSecurityManager.idl
js/xpconnect/src/dictionary_helper_gen.py
js/xpconnect/src/qsgen.py
startupcache/test/TestStartupCache.cpp
tools/profiler/JSObjectBuilder.cpp
tools/profiler/SaveProfileTask.cpp
widget/xpwidgets/GfxInfoCollector.h
--- a/caps/src/nsScriptSecurityManager.cpp
+++ b/caps/src/nsScriptSecurityManager.cpp
@@ -427,44 +427,44 @@ JSBool
 nsScriptSecurityManager::ContentSecurityPolicyPermitsJSAction(JSContext *cx)
 {
     // Get the security manager
     nsScriptSecurityManager *ssm =
         nsScriptSecurityManager::GetScriptSecurityManager();
 
     NS_ASSERTION(ssm, "Failed to get security manager service");
     if (!ssm)
-        return JS_FALSE;
+        return false;
 
     nsresult rv;
     nsIPrincipal* subjectPrincipal = ssm->GetSubjectPrincipal(cx, &rv);
 
     NS_ASSERTION(NS_SUCCEEDED(rv), "CSP: Failed to get nsIPrincipal from js context");
     if (NS_FAILED(rv))
-        return JS_FALSE; // Not just absence of principal, but failure.
+        return false; // Not just absence of principal, but failure.
 
     if (!subjectPrincipal)
-        return JS_TRUE;
+        return true;
 
     nsCOMPtr<nsIContentSecurityPolicy> csp;
     rv = subjectPrincipal->GetCsp(getter_AddRefs(csp));
     NS_ASSERTION(NS_SUCCEEDED(rv), "CSP: Failed to get CSP from principal.");
 
     // don't do anything unless there's a CSP
     if (!csp)
-        return JS_TRUE;
+        return true;
 
     bool evalOK = true;
     bool reportViolation = false;
     rv = csp->GetAllowsEval(&reportViolation, &evalOK);
 
     if (NS_FAILED(rv))
     {
         NS_WARNING("CSP: failed to get allowsEval");
-        return JS_TRUE; // fail open to not break sites.
+        return true; // fail open to not break sites.
     }
 
     if (reportViolation) {
         nsAutoString fileName;
         unsigned lineNum = 0;
         NS_NAMED_LITERAL_STRING(scriptSample, "call to eval() or related function blocked by CSP");
 
         JSScript *script;
@@ -489,17 +489,17 @@ nsScriptSecurityManager::CheckObjectAcce
                                            JS::MutableHandle<JS::Value> vp)
 {
     // Get the security manager
     nsScriptSecurityManager *ssm =
         nsScriptSecurityManager::GetScriptSecurityManager();
 
     NS_WARN_IF_FALSE(ssm, "Failed to get security manager service");
     if (!ssm)
-        return JS_FALSE;
+        return false;
 
     // Get the object being accessed.  We protect these cases:
     // 1. The Function.prototype.caller property's value, which might lead
     //    an attacker up a call-stack to a function or another object from
     //    a different trust domain.
     // 2. A user-defined getter or setter function accessible on another
     //    trust domain's window or document object.
     // vp can be a primitive, in that case, we use obj as the target
@@ -510,19 +510,19 @@ nsScriptSecurityManager::CheckObjectAcce
     // Pass the parent object's class name, as we have no class-info for it.
     nsresult rv =
         ssm->CheckPropertyAccess(cx, target, js::GetObjectClass(obj)->name, id,
                                  (mode & JSACC_WRITE) ?
                                  (int32_t)nsIXPCSecurityManager::ACCESS_SET_PROPERTY :
                                  (int32_t)nsIXPCSecurityManager::ACCESS_GET_PROPERTY);
 
     if (NS_FAILED(rv))
-        return JS_FALSE; // Security check failed (XXX was an error reported?)
-
-    return JS_TRUE;
+        return false; // Security check failed (XXX was an error reported?)
+
+    return true;
 }
 
 NS_IMETHODIMP
 nsScriptSecurityManager::CheckPropertyAccess(JSContext* cx,
                                              JSObject* aJSObject,
                                              const char* aClassName,
                                              jsid aProperty,
                                              uint32_t aAction)
--- a/content/xbl/src/nsXBLDocumentInfo.cpp
+++ b/content/xbl/src/nsXBLDocumentInfo.cpp
@@ -92,29 +92,29 @@ protected:
 
 JSBool
 nsXBLDocGlobalObject::doCheckAccess(JSContext *cx, JS::Handle<JSObject*> obj,
                                     JS::Handle<jsid> id, uint32_t accessType)
 {
   nsIScriptSecurityManager *ssm = nsContentUtils::GetSecurityManager();
   if (!ssm) {
     ::JS_ReportError(cx, "Unable to verify access to a global object property.");
-    return JS_FALSE;
+    return false;
   }
 
   // Make sure to actually operate on our object, and not some object further
   // down on the proto chain.
   JS::Rooted<JSObject*> base(cx, obj);
   while (JS_GetClass(base) != &nsXBLDocGlobalObject::gSharedGlobalClass) {
     if (!::JS_GetPrototype(cx, base, &base)) {
-      return JS_FALSE;
+      return false;
     }
     if (!base) {
       ::JS_ReportError(cx, "Invalid access to a global object property.");
-      return JS_FALSE;
+      return false;
     }
   }
 
   nsresult rv = ssm->CheckPropertyAccess(cx, base, JS_GetClass(base)->name,
                                          id, accessType);
   return NS_SUCCEEDED(rv);
 }
 
@@ -161,17 +161,17 @@ nsXBLDocGlobalObject_finalize(JSFreeOp *
 
   // The addref was part of JSObject construction
   NS_RELEASE(nativeThis);
 }
 
 static JSBool
 nsXBLDocGlobalObject_resolve(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id)
 {
-  JSBool did_resolve = JS_FALSE;
+  JSBool did_resolve = false;
   return JS_ResolveStandardClass(cx, obj, id, &did_resolve);
 }
 
 
 JSClass nsXBLDocGlobalObject::gSharedGlobalClass = {
     "nsXBLPrototypeScript compilation scope",
     JSCLASS_HAS_PRIVATE | JSCLASS_PRIVATE_IS_NSISUPPORTS |
     JSCLASS_IMPLEMENTS_BARRIERS | JSCLASS_GLOBAL_FLAGS_WITH_SLOTS(0),
--- a/content/xbl/src/nsXBLProtoImplMethod.cpp
+++ b/content/xbl/src/nsXBLProtoImplMethod.cpp
@@ -337,17 +337,17 @@ nsXBLProtoImplAnonymousMethod::Execute(n
     return NS_ERROR_OUT_OF_MEMORY;
 
   // Now call the method
 
   // Check whether it's OK to call the method.
   rv = nsContentUtils::GetSecurityManager()->CheckFunctionAccess(cx, method,
                                                                  thisObject);
 
-  JSBool ok = JS_TRUE;
+  JSBool ok = true;
   if (NS_SUCCEEDED(rv)) {
     JS::Rooted<JS::Value> retval(cx);
     ok = ::JS_CallFunctionValue(cx, thisObject, OBJECT_TO_JSVAL(method),
                                 0 /* argc */, nullptr /* argv */, retval.address());
   }
 
   if (!ok) {
     // If a constructor or destructor threw an exception, it doesn't stop
--- a/content/xul/document/src/nsXULPrototypeDocument.cpp
+++ b/content/xul/document/src/nsXULPrototypeDocument.cpp
@@ -96,17 +96,17 @@ nsXULPDGlobalObject_finalize(JSFreeOp *f
     // The addref was part of JSObject construction
     nsContentUtils::DeferredFinalize(nativeThis);
 }
 
 
 JSBool
 nsXULPDGlobalObject_resolve(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id)
 {
-    JSBool did_resolve = JS_FALSE;
+    JSBool did_resolve = false;
 
     return JS_ResolveStandardClass(cx, obj, id, &did_resolve);
 }
 
 
 JSClass nsXULPDGlobalObject::gSharedGlobalClass = {
     "nsXULPrototypeScript compilation scope",
     JSCLASS_HAS_PRIVATE | JSCLASS_PRIVATE_IS_NSISUPPORTS |
--- a/dom/base/nsDOMClassInfo.cpp
+++ b/dom/base/nsDOMClassInfo.cpp
@@ -2357,20 +2357,20 @@ nsWindowSH::GlobalScopePolluterGetProper
     sSecMan->CheckPropertyAccess(cx, ::JS_GetGlobalForObject(cx, obj),
                                  "Window", id,
                                  nsIXPCSecurityManager::ACCESS_GET_PROPERTY);
 
   if (NS_FAILED(rv)) {
     // The security check failed. The security manager set a JS
     // exception for us.
 
-    return JS_FALSE;
+    return false;
   }
 
-  return JS_TRUE;
+  return true;
 }
 
 // Gets a subframe.
 static JSBool
 ChildWindowGetter(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
                   JS::MutableHandle<JS::Value> vp)
 {
   MOZ_ASSERT(JSID_IS_STRING(id));
@@ -2408,17 +2408,17 @@ GetDocument(JSObject *obj)
 // static
 JSBool
 nsWindowSH::GlobalScopePolluterNewResolve(JSContext *cx, JS::Handle<JSObject*> obj,
                                           JS::Handle<jsid> id, unsigned flags,
                                           JS::MutableHandle<JSObject*> objp)
 {
   if (!JSID_IS_STRING(id)) {
     // Nothing to do if we're resolving a non-string property.
-    return JS_TRUE;
+    return true;
   }
 
   // Crash reports from the wild seem to get here during shutdown when there's
   // no more XPConnect singleton.
   nsIXPConnect *xpc = XPConnect();
   NS_ENSURE_TRUE(xpc, true);
 
   // Grab the DOM window.
@@ -2445,26 +2445,26 @@ nsWindowSH::GlobalScopePolluterNewResolv
 
       objp.set(obj);
       return true;
     }
   }
 
   JS::Rooted<JSObject*> proto(cx);
   if (!::JS_GetPrototype(cx, obj, &proto)) {
-    return JS_FALSE;
+    return false;
   }
   JSBool hasProp;
 
   if (!proto || !::JS_HasPropertyById(cx, proto, id, &hasProp) ||
       hasProp) {
     // No prototype, or the property exists on the prototype. Do
     // nothing.
 
-    return JS_TRUE;
+    return true;
   }
 
   //
   // The rest of this function is for HTML documents only.
   //
   nsCOMPtr<nsIHTMLDocument> htmlDoc =
     do_QueryInterface(win->GetExtantDoc());
   if (!htmlDoc)
@@ -2484,63 +2484,63 @@ nsWindowSH::GlobalScopePolluterNewResolv
     result = document->ResolveName(str, &cache);
   }
 
   if (result) {
     JS::Rooted<JS::Value> v(cx);
     nsCOMPtr<nsIXPConnectJSObjectHolder> holder;
     nsresult rv = WrapNative(cx, obj, result, cache, true, v.address(),
                              getter_AddRefs(holder));
-    NS_ENSURE_SUCCESS(rv, JS_FALSE);
+    NS_ENSURE_SUCCESS(rv, false);
 
     if (!JS_WrapValue(cx, v.address()) ||
         !JS_DefinePropertyById(cx, obj, id, v, JS_PropertyStub, JS_StrictPropertyStub, 0)) {
-      return JS_FALSE;
+      return false;
     }
 
     objp.set(obj);
   }
 
-  return JS_TRUE;
+  return true;
 }
 
 // static
 JSBool
 nsWindowSH::InvalidateGlobalScopePolluter(JSContext *cx,
                                           JS::Handle<JSObject*> aObj)
 {
   JS::Rooted<JSObject*> proto(cx);
   JS::Rooted<JSObject*> obj(cx, aObj);
 
   for (;;) {
     if (!::JS_GetPrototype(cx, obj, &proto)) {
-      return JS_FALSE;
+      return false;
     }
     if (!proto) {
       break;
     }
 
     if (JS_GetClass(proto) == &sGlobalScopePolluterClass) {
 
       JS::Rooted<JSObject*> proto_proto(cx);
       if (!::JS_GetPrototype(cx, proto, &proto_proto)) {
-        return JS_FALSE;
+        return false;
       }
 
       // Pull the global scope polluter out of the prototype chain so
       // that it can be freed.
       ::JS_SplicePrototype(cx, obj, proto_proto);
 
       break;
     }
 
     obj = proto;
   }
 
-  return JS_TRUE;
+  return true;
 }
 
 // static
 nsresult
 nsWindowSH::InstallGlobalScopePolluter(JSContext *cx, JS::Handle<JSObject*> obj)
 {
   JS::Rooted<JSObject*> gsp(cx, ::JS_NewObjectWithUniqueType(cx, &sGlobalScopePolluterClass, nullptr, obj));
   if (!gsp) {
@@ -3013,17 +3013,17 @@ nsDOMConstructor::Construct(nsIXPConnect
                             bool *_retval)
 {
   MOZ_ASSERT(obj);
 
   const nsGlobalNameStruct *name_struct = GetNameStruct();
   NS_ENSURE_TRUE(name_struct, NS_ERROR_FAILURE);
 
   if (!IsConstructable(name_struct)) {
-    // ignore return value, we return JS_FALSE anyway
+    // ignore return value, we return false anyway
     return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
   }
 
   return BaseStubConstructor(mWeakOwner, name_struct, cx, obj, args);
 }
 
 nsresult
 nsDOMConstructor::HasInstance(nsIXPConnectWrappedNative *wrapper,
@@ -3094,17 +3094,17 @@ nsDOMConstructor::HasInstance(nsIXPConne
     // Doesn't have DOM interfaces.
     return NS_OK;
   }
 
   const nsGlobalNameStruct *class_name_struct = GetNameStruct();
   NS_ENSURE_TRUE(class_name_struct, NS_ERROR_FAILURE);
 
   if (name_struct == class_name_struct) {
-    *bp = JS_TRUE;
+    *bp = true;
 
     return NS_OK;
   }
 
   nsScriptNameSpaceManager *nameSpaceManager =
     nsJSRuntime::GetNameSpaceManager();
   NS_ASSERTION(nameSpaceManager, "Can't get namespace manager?");
 
@@ -3130,17 +3130,17 @@ nsDOMConstructor::HasInstance(nsIXPConne
         sClassInfoData[alias_struct->mDOMClassInfoID].mProtoChainInterface;
     } else if (alias_struct->mType == nsGlobalNameStruct::eTypeExternalClassInfo) {
       class_iid = alias_struct->mData->mProtoChainInterface;
     } else {
       NS_ERROR("Expected eTypeClassConstructor or eTypeExternalClassInfo.");
       return NS_ERROR_UNEXPECTED;
     }
   } else {
-    *bp = JS_FALSE;
+    *bp = false;
 
     return NS_OK;
   }
 
   if (name_struct->mType == nsGlobalNameStruct::eTypeExternalConstructorAlias) {
     name_struct = nameSpaceManager->GetConstructorProto(name_struct);
     if (!name_struct) {
       NS_ERROR("Couldn't get constructor prototype.");
@@ -3167,17 +3167,17 @@ nsDOMConstructor::HasInstance(nsIXPConne
     return NS_ERROR_UNEXPECTED;
   }
 
   nsCOMPtr<nsIInterfaceInfo> if_info;
   uint32_t count = 0;
   const nsIID* class_interface;
   while ((class_interface = ci_data->mInterfaces[count++])) {
     if (class_iid->Equals(*class_interface)) {
-      *bp = JS_TRUE;
+      *bp = true;
 
       return NS_OK;
     }
 
     iim->GetInfoForIID(class_interface, getter_AddRefs(if_info));
     if (!if_info) {
       NS_ERROR("nsDOMConstructor::HasInstance can't get interface info.");
       return NS_ERROR_UNEXPECTED;
@@ -3844,20 +3844,20 @@ LocationSetterGuts(JSContext *cx, JSObje
 template<class Interface>
 static JSBool
 LocationSetter(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id, JSBool strict,
                JS::MutableHandle<JS::Value> vp)
 {
   nsresult rv = LocationSetterGuts<Interface>(cx, obj, vp.address());
   if (NS_FAILED(rv)) {
     xpc::Throw(cx, rv);
-    return JS_FALSE;
+    return false;
   }
 
-  return JS_TRUE;
+  return true;
 }
 
 static JSBool
 LocationSetterUnwrapper(JSContext *cx, JS::Handle<JSObject*> obj_, JS::Handle<jsid> id,
                         JSBool strict, JS::MutableHandle<JS::Value> vp)
 {
   JS::RootedObject obj(cx, obj_);
 
@@ -3977,18 +3977,18 @@ nsWindowSH::NewResolve(nsIXPConnectWrapp
   nsGlobalWindow *win = nsGlobalWindow::FromWrapper(wrapper);
   MOZ_ASSERT(win->IsInnerWindow());
 
   nsIScriptContext *my_context = win->GetContextInternal();
 
   // Don't resolve standard classes on XrayWrappers, only resolve them if we're
   // resolving on the real global object.
   if (!xpc::WrapperFactory::IsXrayWrapper(obj)) {
-    JSBool did_resolve = JS_FALSE;
-    JSBool ok = JS_TRUE;
+    JSBool did_resolve = false;
+    JSBool ok = true;
     JS::Rooted<JS::Value> exn(cx, JSVAL_VOID);
 
     {
       // Resolve standard classes on my_context's JSContext (or on cx,
       // if we don't have a my_context yet), in case the two contexts
       // have different origins.  We want lazy standard class
       // initialization to behave as if it were done eagerly, on each
       // window's own context (not on some other window-caller's
@@ -4012,17 +4012,17 @@ nsWindowSH::NewResolve(nsIXPConnectWrapp
         // JS_SetPendingException is important in the case that my_cx == cx.
 
         JS_ClearPendingException(my_cx);
       }
     }
 
     if (!ok) {
       JS_SetPendingException(cx, exn);
-      *_retval = JS_FALSE;
+      *_retval = false;
       return NS_OK;
     }
 
     if (did_resolve) {
       *objp = obj;
       return NS_OK;
     }
   }
@@ -4210,26 +4210,26 @@ nsWindowSH::NewResolve(nsIXPConnectWrapp
   // defined on our prototype chain. This way we can access this
   // expando w/o ever getting back into XPConnect.
   if (flags & JSRESOLVE_ASSIGNING) {
     JS::Rooted<JSObject*> realObj(cx, wrapper->GetJSObject());
 
     if (obj == realObj) {
       JS::Rooted<JSObject*> proto(cx);
       if (!js::GetObjectProto(cx, obj, &proto)) {
-          *_retval = JS_FALSE;
+          *_retval = false;
           return NS_OK;
       }
       if (proto) {
         JS::Rooted<JSObject*> pobj(cx);
         JS::Rooted<JS::Value> val(cx);
 
         if (!::JS_LookupPropertyWithFlagsById(cx, proto, id, flags,
                                               pobj.address(), &val)) {
-          *_retval = JS_FALSE;
+          *_retval = false;
 
           return NS_OK;
         }
 
         if (pobj) {
           // A property was found on the prototype chain.
           *objp = pobj;
           return NS_OK;
@@ -4245,17 +4245,17 @@ nsWindowSH::NewResolve(nsIXPConnectWrapp
       //
       // Since we always create the undeclared property here, shortcutting the
       // normal process, we go out of our way to tell the JS engine to report
       // strict warnings/errors using js::ReportIfUndeclaredVarAssignment.
       JS::Rooted<JSString*> str(cx, JSID_TO_STRING(id));
       if (!js::ReportIfUndeclaredVarAssignment(cx, str) ||
           !::JS_DefinePropertyById(cx, obj, id, JSVAL_VOID, JS_PropertyStub,
                                    JS_StrictPropertyStub, JSPROP_ENUMERATE)) {
-        *_retval = JS_FALSE;
+        *_retval = false;
 
         return NS_OK;
       }
 
       *objp = obj;
     }
   }
 
@@ -4660,45 +4660,45 @@ nsHTMLDocumentSH::GetDocumentAllNodeList
 
     // ... and store it in our reserved slot.
     JS_SetReservedSlot(obj, 0, collection);
   }
 
   if (NS_FAILED(rv)) {
     xpc::Throw(cx, NS_ERROR_FAILURE);
 
-    return JS_FALSE;
+    return false;
   }
 
   return *nodeList != nullptr;
 }
 
 JSBool
 nsHTMLDocumentSH::DocumentAllGetProperty(JSContext *cx, JS::Handle<JSObject*> obj_,
                                          JS::Handle<jsid> id, JS::MutableHandle<JS::Value> vp)
 {
   JS::Rooted<JSObject*> obj(cx, obj_);
 
   // document.all.item and .namedItem get their value in the
   // newResolve hook, so nothing to do for those properties here. And
   // we need to return early to prevent <div id="item"> from shadowing
   // document.all.item(), etc.
   if (nsDOMClassInfo::sItem_id == id || nsDOMClassInfo::sNamedItem_id == id) {
-    return JS_TRUE;
+    return true;
   }
 
   JS::Rooted<JSObject*> proto(cx);
   while (js::GetObjectJSClass(obj) != &sHTMLDocumentAllClass) {
     if (!js::GetObjectProto(cx, obj, &proto)) {
-      return JS_FALSE;
+      return false;
     }
 
     if (!proto) {
       NS_ERROR("The JS engine lies!");
-      return JS_TRUE;
+      return true;
     }
 
     obj = proto;
   }
 
   nsHTMLDocument *doc = GetDocument(obj);
   nsISupports *result;
   nsWrapperCache *cache;
@@ -4707,70 +4707,70 @@ nsHTMLDocumentSH::DocumentAllGetProperty
   if (JSID_IS_STRING(id)) {
     if (nsDOMClassInfo::sLength_id == id) {
       // Map document.all.length to the length of the collection
       // document.getElementsByTagName("*"), and make sure <div
       // id="length"> doesn't shadow document.all.length.
 
       nsRefPtr<nsContentList> nodeList;
       if (!GetDocumentAllNodeList(cx, obj, doc, getter_AddRefs(nodeList))) {
-        return JS_FALSE;
+        return false;
       }
 
       uint32_t length;
       rv = nodeList->GetLength(&length);
 
       if (NS_FAILED(rv)) {
         xpc::Throw(cx, rv);
 
-        return JS_FALSE;
+        return false;
       }
 
       vp.set(INT_TO_JSVAL(length));
 
-      return JS_TRUE;
+      return true;
     }
 
     // For all other strings, look for an element by id or name.
     nsDependentJSString str(id);
     result = doc->GetDocumentAllResult(str, &cache, &rv);
 
     if (NS_FAILED(rv)) {
       xpc::Throw(cx, rv);
-      return JS_FALSE;
+      return false;
     }
   } else if (JSID_IS_INT(id) && JSID_TO_INT(id) >= 0) {
     // Map document.all[n] (where n is a number) to the n:th item in
     // the document.all node list.
 
     nsRefPtr<nsContentList> nodeList;
     if (!GetDocumentAllNodeList(cx, obj, doc, getter_AddRefs(nodeList))) {
-      return JS_FALSE;
+      return false;
     }
 
     nsIContent *node = nodeList->Item(JSID_TO_INT(id));
 
     result = node;
     cache = node;
   } else {
     result = nullptr;
   }
 
   if (result) {
     rv = WrapNative(cx, JS::CurrentGlobalOrNull(cx), result, cache, true, vp.address());
     if (NS_FAILED(rv)) {
       xpc::Throw(cx, rv);
 
-      return JS_FALSE;
+      return false;
     }
   } else {
     vp.setUndefined();
   }
 
-  return JS_TRUE;
+  return true;
 }
 
 JSBool
 nsHTMLDocumentSH::DocumentAllNewResolve(JSContext *cx, JS::Handle<JSObject*> obj,
                                         JS::Handle<jsid> id, unsigned flags,
                                         JS::MutableHandle<JSObject*> objp)
 {
   JS::RootedValue v(cx);
@@ -4789,21 +4789,21 @@ nsHTMLDocumentSH::DocumentAllNewResolve(
     // document.all.length. Any jsval other than undefined would do
     // here, all we need is to get into the code below that defines
     // this propery on obj, the rest happens in
     // DocumentAllGetProperty().
 
     v = JSVAL_ONE;
   } else {
     if (!DocumentAllGetProperty(cx, obj, id, &v)) {
-      return JS_FALSE;
+      return false;
     }
   }
 
-  JSBool ok = JS_TRUE;
+  JSBool ok = true;
 
   if (v.get() != JSVAL_VOID) {
     ok = ::JS_DefinePropertyById(cx, obj, id, v, nullptr, nullptr, 0);
     objp.set(obj);
   }
 
   return ok;
 }
--- a/dom/base/nsGlobalWindow.cpp
+++ b/dom/base/nsGlobalWindow.cpp
@@ -6761,17 +6761,17 @@ PostMessageWriteStructuredClone(JSContex
 
   const JSStructuredCloneCallbacks* runtimeCallbacks =
     js::GetContextStructuredCloneCallbacks(cx);
 
   if (runtimeCallbacks) {
     return runtimeCallbacks->write(cx, writer, obj, nullptr);
   }
 
-  return JS_FALSE;
+  return false;
 }
 
 JSStructuredCloneCallbacks kPostMessageCallbacks = {
   PostMessageReadStructuredClone,
   PostMessageWriteStructuredClone,
   nullptr
 };
 
--- a/dom/base/nsJSEnvironment.cpp
+++ b/dom/base/nsJSEnvironment.cpp
@@ -699,17 +699,17 @@ nsJSContext::DOMOperationCallback(JSCont
 {
   nsresult rv;
 
   // Get the native context
   nsJSContext *ctx = static_cast<nsJSContext *>(::JS_GetContextPrivate(cx));
 
   if (!ctx) {
     // Can happen; see bug 355811
-    return JS_TRUE;
+    return true;
   }
 
   // XXX Save the operation callback time so we can restore it after the GC,
   // because GCing can cause JS to run on our context, causing our
   // ScriptEvaluated to be called, and clearing our operation callback time.
   // See bug 302333.
   PRTime callbackTime = ctx->mOperationCallbackTime;
   PRTime modalStateTime = ctx->mModalStateTime;
@@ -719,51 +719,51 @@ nsJSContext::DOMOperationCallback(JSCont
   ctx->mModalStateTime = modalStateTime;
 
   PRTime now = PR_Now();
 
   if (callbackTime == 0) {
     // Initialize mOperationCallbackTime to start timing how long the
     // script has run
     ctx->mOperationCallbackTime = now;
-    return JS_TRUE;
+    return true;
   }
 
   if (ctx->mModalStateDepth) {
     // We're waiting on a modal dialog, nothing more to do here.
-    return JS_TRUE;
+    return true;
   }
 
   PRTime duration = now - callbackTime;
 
   // Check the amount of time this script has been running, or if the
   // dialog is disabled.
   JSObject* global = ::JS::CurrentGlobalOrNull(cx);
   bool isTrackingChromeCodeTime =
     global && xpc::AccessCheck::isChrome(js::GetObjectCompartment(global));
   if (duration < (isTrackingChromeCodeTime ?
                   sMaxChromeScriptRunTime : sMaxScriptRunTime)) {
-    return JS_TRUE;
+    return true;
   }
 
   if (!nsContentUtils::IsSafeToRunScript()) {
     // If it isn't safe to run script, then it isn't safe to bring up the
     // prompt (since that will cause the event loop to spin). In this case
     // (which is rare), we just stop the script... But report a warning so
     // that developers have some idea of what went wrong.
 
     JS_ReportWarning(cx, "A long running script was terminated");
-    return JS_FALSE;
+    return false;
   }
 
   // If we get here we're most likely executing an infinite loop in JS,
   // we'll tell the user about this and we'll give the user the option
   // of stopping the execution of the script.
   nsCOMPtr<nsIPrompt> prompt = GetPromptFromContext(ctx);
-  NS_ENSURE_TRUE(prompt, JS_FALSE);
+  NS_ENSURE_TRUE(prompt, false);
 
   // Check if we should offer the option to debug
   JS::RootedScript script(cx);
   unsigned lineno;
   JSBool hasFrame = ::JS_DescribeScriptedCaller(cx, script.address(), &lineno);
 
   bool debugPossible = hasFrame && js::CanCallContextDebugHandler(cx);
 #ifdef MOZ_JSDEBUGGER
@@ -839,17 +839,17 @@ nsJSContext::DOMOperationCallback(JSCont
       rv = tmp;
     }
   }
 
   //GetStringFromName can return NS_OK and still give NULL string
   if (NS_FAILED(rv) || !title || !msg || !stopButton || !waitButton ||
       (!debugButton && debugPossible) || !neverShowDlg) {
     NS_ERROR("Failed to get localized strings.");
-    return JS_TRUE;
+    return true;
   }
 
   // Append file and line number information, if available
   if (script) {
     const char *filename = ::JS_GetScriptFilename(cx, script);
     if (filename) {
       nsXPIDLString scriptLocation;
       NS_ConvertUTF8toUTF16 filenameUTF16(filename);
@@ -897,24 +897,24 @@ nsJSContext::DOMOperationCallback(JSCont
         sMaxChromeScriptRunTime = NS_UNLIMITED_SCRIPT_RUNTIME;
       } else {
         Preferences::SetInt("dom.max_script_run_time", 0);
         sMaxScriptRunTime = NS_UNLIMITED_SCRIPT_RUNTIME;
       }
     }
 
     ctx->mOperationCallbackTime = PR_Now();
-    return JS_TRUE;
+    return true;
   }
   else if ((buttonPressed == 2) && debugPossible) {
     return js_CallContextDebugHandler(cx);
   }
 
   JS_ClearPendingException(cx);
-  return JS_FALSE;
+  return false;
 }
 
 void
 nsJSContext::EnterModalState()
 {
   if (!mModalStateDepth) {
     mModalStateTime =  mOperationCallbackTime ? PR_Now() : 0;
   }
@@ -3321,17 +3321,17 @@ NS_DOMWriteStructuredClone(JSContext* cx
                            JS::Handle<JSObject*> obj,
                            void *closure)
 {
   ImageData* imageData;
   nsresult rv = UnwrapObject<ImageData>(cx, obj, imageData);
   if (NS_FAILED(rv)) {
     // Don't know what this is. Bail.
     xpc::Throw(cx, NS_ERROR_DOM_DATA_CLONE_ERR);
-    return JS_FALSE;
+    return false;
   }
 
   // Prepare the ImageData internals.
   uint32_t width = imageData->Width();
   uint32_t height = imageData->Height();
   JS::Rooted<JSObject*> dataArray(cx, imageData->GetDataObject());
 
   // Write the internals to the stream.
--- a/dom/base/nsJSUtils.cpp
+++ b/dom/base/nsJSUtils.cpp
@@ -33,23 +33,23 @@
 JSBool
 nsJSUtils::GetCallingLocation(JSContext* aContext, const char* *aFilename,
                               uint32_t* aLineno)
 {
   JSScript* script = nullptr;
   unsigned lineno = 0;
 
   if (!JS_DescribeScriptedCaller(aContext, &script, &lineno)) {
-    return JS_FALSE;
+    return false;
   }
 
   *aFilename = ::JS_GetScriptFilename(aContext, script);
   *aLineno = lineno;
 
-  return JS_TRUE;
+  return true;
 }
 
 nsIScriptGlobalObject *
 nsJSUtils::GetStaticScriptGlobal(JSObject* aObj)
 {
   JSClass* clazz;
   JSObject* glob = aObj; // starting point for search
 
--- a/dom/base/nsJSUtils.h
+++ b/dom/base/nsJSUtils.h
@@ -99,22 +99,22 @@ public:
   {
   }
 
   JSBool init(JSContext* aContext, JSString* str)
   {
       size_t length;
       const jschar* chars = JS_GetStringCharsZAndLength(aContext, str, &length);
       if (!chars)
-          return JS_FALSE;
+          return false;
 
       NS_ASSERTION(IsEmpty(), "init() on initialized string");
       nsDependentString* base = this;
       new(base) nsDependentString(chars, length);
-      return JS_TRUE;
+      return true;
   }
 
   JSBool init(JSContext* aContext, const JS::Value &v)
   {
       return init(aContext, JSVAL_TO_STRING(v));
   }
 
   void init(JSFlatString* fstr)
--- a/dom/bluetooth/BluetoothHfpManager.cpp
+++ b/dom/bluetooth/BluetoothHfpManager.cpp
@@ -544,17 +544,17 @@ BluetoothHfpManager::HandleVolumeChanged
   JS::Rooted<JSObject*> obj(cx, &val.toObject());
   JS::Rooted<JS::Value> key(cx);
   if (!JS_GetProperty(cx, obj, "key", &key) || !key.isString()) {
     return;
   }
 
   JSBool match;
   if (!JS_StringEqualsAscii(cx, key.toString(), AUDIO_VOLUME_BT_SCO_ID, &match) ||
-      (match != JS_TRUE)) {
+      !match) {
     return;
   }
 
   JS::Rooted<JS::Value> value(cx);
   if (!JS_GetProperty(cx, obj, "value", &value)||
       !value.isNumber()) {
     return;
   }
--- a/dom/indexedDB/KeyPath.cpp
+++ b/dom/indexedDB/KeyPath.cpp
@@ -44,17 +44,17 @@ IsValidKeyPathString(JSContext* aCx, con
     jsval stringVal;
     if (!xpc::StringToJsval(aCx, token, &stringVal)) {
       return false;
     }
 
     NS_ASSERTION(JSVAL_IS_STRING(stringVal), "This should never happen");
     JSString* str = JSVAL_TO_STRING(stringVal);
 
-    JSBool isIdentifier = JS_FALSE;
+    JSBool isIdentifier = false;
     if (!JS_IsIdentifier(aCx, str, &isIdentifier) || !isIdentifier) {
       return false;
     }
   }
 
   // If the very last character was a '.', the tokenizer won't give us an empty
   // token, but the keyPath is still invalid.
   if (!aKeyPath.IsEmpty() &&
--- a/dom/plugins/base/nsJSNPRuntime.cpp
+++ b/dom/plugins/base/nsJSNPRuntime.cpp
@@ -468,22 +468,22 @@ ThrowJSException(JSContext *cx, const ch
 }
 
 static JSBool
 ReportExceptionIfPending(JSContext *cx)
 {
   const char *ex = PeekException();
 
   if (!ex) {
-    return JS_TRUE;
+    return true;
   }
 
   ThrowJSException(cx, nullptr);
 
-  return JS_FALSE;
+  return false;
 }
 
 
 nsJSObjWrapper::nsJSObjWrapper(NPP npp)
   : nsJSObjWrapperKey(nullptr, npp)
 {
   MOZ_COUNT_CTOR(nsJSObjWrapper);
   OnWrapperCreated();
@@ -628,52 +628,50 @@ doInvoke(NPObject *npobj, NPIdentifier m
     if (!jsargs) {
       ::JS_ReportOutOfMemory(cx);
 
       return false;
     }
   }
 
   JS::Rooted<JS::Value> v(cx);
-  JSBool ok;
+  bool ok;
 
   {
     JS::AutoArrayRooter tvr(cx, 0, jsargs);
 
     // Convert args
     for (uint32_t i = 0; i < argCount; ++i) {
       jsargs[i] = NPVariantToJSVal(npp, cx, args + i);
       tvr.changeLength(i + 1);
     }
 
     if (ctorCall) {
       JSObject *newObj =
         ::JS_New(cx, npjsobj->mJSObj, argCount, jsargs);
 
       if (newObj) {
         v = OBJECT_TO_JSVAL(newObj);
-        ok = JS_TRUE;
+        ok = true;
       } else {
-        ok = JS_FALSE;
+        ok = false;
       }
     } else {
       ok = ::JS_CallFunctionValue(cx, npjsobj->mJSObj, fv, argCount, jsargs, v.address());
     }
 
   }
 
   if (jsargs != jsargs_buf)
     PR_Free(jsargs);
 
   if (ok)
     ok = JSValToNPVariant(npp, cx, v, result);
 
-  // return ok == JS_TRUE to quiet down compiler warning, even if
-  // return ok is what we really want.
-  return ok == JS_TRUE;
+  return ok;
 }
 
 // static
 bool
 nsJSObjWrapper::NP_Invoke(NPObject *npobj, NPIdentifier method,
                           const NPVariant *args, uint32_t argCount,
                           NPVariant *result)
 {
@@ -707,17 +705,17 @@ nsJSObjWrapper::NP_HasProperty(NPObject 
   if (!npobj) {
     ThrowJSException(cx,
                      "Null npobj in nsJSObjWrapper::NP_HasProperty!");
 
     return false;
   }
 
   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
-  JSBool found, ok = JS_FALSE;
+  JSBool found, ok = false;
 
   nsCxPusher pusher;
   pusher.Push(cx);
   AutoJSExceptionReporter reporter(cx);
   JSAutoCompartment ac(cx, npjsobj->mJSObj);
 
   NS_ASSERTION(NPIdentifierIsInt(id) || NPIdentifierIsString(id),
                "id must be either string or int!\n");
@@ -771,32 +769,30 @@ nsJSObjWrapper::NP_SetProperty(NPObject 
   if (!npobj) {
     ThrowJSException(cx,
                      "Null npobj in nsJSObjWrapper::NP_SetProperty!");
 
     return false;
   }
 
   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
-  JSBool ok = JS_FALSE;
+  bool ok = false;
 
   nsCxPusher pusher;
   pusher.Push(cx);
   AutoJSExceptionReporter reporter(cx);
   JSAutoCompartment ac(cx, npjsobj->mJSObj);
 
   JS::Rooted<JS::Value> v(cx, NPVariantToJSVal(npp, cx, value));
 
   NS_ASSERTION(NPIdentifierIsInt(id) || NPIdentifierIsString(id),
                "id must be either string or int!\n");
   ok = ::JS_SetPropertyById(cx, npjsobj->mJSObj, NPIdentifierToJSId(id), v);
 
-  // return ok == JS_TRUE to quiet down compiler warning, even if
-  // return ok is what we really want.
-  return ok == JS_TRUE;
+  return ok;
 }
 
 // static
 bool
 nsJSObjWrapper::NP_RemoveProperty(NPObject *npobj, NPIdentifier id)
 {
   NPP npp = NPPStack::Peek();
   JSContext *cx = GetJSContext(npp);
@@ -808,17 +804,17 @@ nsJSObjWrapper::NP_RemoveProperty(NPObje
   if (!npobj) {
     ThrowJSException(cx,
                      "Null npobj in nsJSObjWrapper::NP_RemoveProperty!");
 
     return false;
   }
 
   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
-  JSBool ok = JS_FALSE;
+  JSBool ok = false;
 
   nsCxPusher pusher;
   pusher.Push(cx);
   AutoJSExceptionReporter reporter(cx);
   bool deleted = false;
   JSAutoCompartment ac(cx, npjsobj->mJSObj);
 
   NS_ASSERTION(NPIdentifierIsInt(id) || NPIdentifierIsString(id),
@@ -1108,72 +1104,72 @@ static JSBool
 NPObjWrapper_AddProperty(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id, JS::MutableHandle<JS::Value> vp)
 {
   NPObject *npobj = GetNPObject(cx, obj);
 
   if (!npobj || !npobj->_class || !npobj->_class->hasProperty ||
       !npobj->_class->hasMethod) {
     ThrowJSException(cx, "Bad NPObject as private data!");
 
-    return JS_FALSE;
+    return false;
   }
 
   if (NPObjectIsOutOfProcessProxy(npobj)) {
-    return JS_TRUE;
+    return true;
   }
 
   PluginDestructionGuard pdg(LookupNPP(npobj));
 
   NPIdentifier identifier = JSIdToNPIdentifier(id);
   JSBool hasProperty = npobj->_class->hasProperty(npobj, identifier);
   if (!ReportExceptionIfPending(cx))
-    return JS_FALSE;
+    return false;
 
   if (hasProperty)
-    return JS_TRUE;
+    return true;
 
   // We must permit methods here since JS_DefineUCFunction() will add
   // the function as a property
   JSBool hasMethod = npobj->_class->hasMethod(npobj, identifier);
   if (!ReportExceptionIfPending(cx))
-    return JS_FALSE;
+    return false;
 
   if (!hasMethod) {
     ThrowJSException(cx, "Trying to add unsupported property on NPObject!");
 
-    return JS_FALSE;
+    return false;
   }
 
-  return JS_TRUE;
+  return true;
 }
 
 static JSBool
 NPObjWrapper_DelProperty(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id, JSBool *succeeded)
 {
   NPObject *npobj = GetNPObject(cx, obj);
 
   if (!npobj || !npobj->_class || !npobj->_class->hasProperty ||
       !npobj->_class->removeProperty) {
     ThrowJSException(cx, "Bad NPObject as private data!");
 
-    return JS_FALSE;
+    return false;
   }
 
   PluginDestructionGuard pdg(LookupNPP(npobj));
 
   NPIdentifier identifier = JSIdToNPIdentifier(id);
 
   if (!NPObjectIsOutOfProcessProxy(npobj)) {
     JSBool hasProperty = npobj->_class->hasProperty(npobj, identifier);
     if (!ReportExceptionIfPending(cx))
-      return JS_FALSE;
+      return false;
 
     if (!hasProperty) {
       *succeeded = true;
-      return JS_TRUE;
+      return true;
     }
   }
 
   if (!npobj->_class->removeProperty(npobj, identifier))
     *succeeded = false;
 
   return ReportExceptionIfPending(cx);
 }
@@ -1183,85 +1179,85 @@ NPObjWrapper_SetProperty(JSContext *cx, 
                          JS::MutableHandle<JS::Value> vp)
 {
   NPObject *npobj = GetNPObject(cx, obj);
 
   if (!npobj || !npobj->_class || !npobj->_class->hasProperty ||
       !npobj->_class->setProperty) {
     ThrowJSException(cx, "Bad NPObject as private data!");
 
-    return JS_FALSE;
+    return false;
   }
 
   // Find out what plugin (NPP) is the owner of the object we're
   // manipulating, and make it own any JSObject wrappers created here.
   NPP npp = LookupNPP(npobj);
 
   if (!npp) {
     ThrowJSException(cx, "No NPP found for NPObject!");
 
-    return JS_FALSE;
+    return false;
   }
 
   PluginDestructionGuard pdg(npp);
 
   NPIdentifier identifier = JSIdToNPIdentifier(id);
 
   if (!NPObjectIsOutOfProcessProxy(npobj)) {
     JSBool hasProperty = npobj->_class->hasProperty(npobj, identifier);
     if (!ReportExceptionIfPending(cx))
-      return JS_FALSE;
+      return false;
 
     if (!hasProperty) {
       ThrowJSException(cx, "Trying to set unsupported property on NPObject!");
 
-      return JS_FALSE;
+      return false;
     }
   }
 
   NPVariant npv;
   if (!JSValToNPVariant(npp, cx, vp, &npv)) {
     ThrowJSException(cx, "Error converting jsval to NPVariant!");
 
-    return JS_FALSE;
+    return false;
   }
 
   JSBool ok = npobj->_class->setProperty(npobj, identifier, &npv);
   _releasevariantvalue(&npv); // Release the variant
   if (!ReportExceptionIfPending(cx))
-    return JS_FALSE;
+    return false;
 
   if (!ok) {
     ThrowJSException(cx, "Error setting property on NPObject!");
 
-    return JS_FALSE;
+    return false;
   }
 
-  return JS_TRUE;
+  return true;
 }
 
 static JSBool
 NPObjWrapper_GetProperty(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id, JS::MutableHandle<JS::Value> vp)
 {
   NPObject *npobj = GetNPObject(cx, obj);
 
   if (!npobj || !npobj->_class || !npobj->_class->hasProperty ||
       !npobj->_class->hasMethod || !npobj->_class->getProperty) {
     ThrowJSException(cx, "Bad NPObject as private data!");
 
-    return JS_FALSE;
+    return false;
   }
 
   // Find out what plugin (NPP) is the owner of the object we're
   // manipulating, and make it own any JSObject wrappers created here.
   NPP npp = LookupNPP(npobj);
   if (!npp) {
     ThrowJSException(cx, "No NPP found for NPObject!");
 
-    return JS_FALSE;
+    return false;
   }
 
   PluginDestructionGuard pdg(npp);
 
   bool hasProperty, hasMethod;
 
   NPVariant npv;
   VOID_TO_NPVARIANT(npv);
@@ -1269,117 +1265,117 @@ NPObjWrapper_GetProperty(JSContext *cx, 
   NPIdentifier identifier = JSIdToNPIdentifier(id);
 
   if (NPObjectIsOutOfProcessProxy(npobj)) {
     PluginScriptableObjectParent* actor =
       static_cast<ParentNPObject*>(npobj)->parent;
 
     // actor may be null if the plugin crashed.
     if (!actor)
-      return JS_FALSE;
+      return false;
 
     JSBool success = actor->GetPropertyHelper(identifier, &hasProperty,
                                               &hasMethod, &npv);
     if (!ReportExceptionIfPending(cx)) {
       if (success)
         _releasevariantvalue(&npv);
-      return JS_FALSE;
+      return false;
     }
 
     if (success) {
       // We return NPObject Member class here to support ambiguous members.
       if (hasProperty && hasMethod)
         return CreateNPObjectMember(npp, cx, obj, npobj, id, &npv, vp.address());
 
       if (hasProperty) {
         vp.set(NPVariantToJSVal(npp, cx, &npv));
         _releasevariantvalue(&npv);
 
         if (!ReportExceptionIfPending(cx))
-          return JS_FALSE;
+          return false;
       }
     }
-    return JS_TRUE;
+    return true;
   }
 
   hasProperty = npobj->_class->hasProperty(npobj, identifier);
   if (!ReportExceptionIfPending(cx))
-    return JS_FALSE;
+    return false;
 
   hasMethod = npobj->_class->hasMethod(npobj, identifier);
   if (!ReportExceptionIfPending(cx))
-    return JS_FALSE;
+    return false;
 
   // We return NPObject Member class here to support ambiguous members.
   if (hasProperty && hasMethod)
     return CreateNPObjectMember(npp, cx, obj, npobj, id, nullptr, vp.address());
 
   if (hasProperty) {
     if (npobj->_class->getProperty(npobj, identifier, &npv))
       vp.set(NPVariantToJSVal(npp, cx, &npv));
 
     _releasevariantvalue(&npv);
 
     if (!ReportExceptionIfPending(cx))
-      return JS_FALSE;
+      return false;
   }
 
-  return JS_TRUE;
+  return true;
 }
 
 static JSBool
 CallNPMethodInternal(JSContext *cx, JS::Handle<JSObject*> obj, unsigned argc,
                      JS::Value *argv, JS::Value *rval, bool ctorCall)
 {
   NPObject *npobj = GetNPObject(cx, obj);
 
   if (!npobj || !npobj->_class) {
     ThrowJSException(cx, "Bad NPObject as private data!");
 
-    return JS_FALSE;
+    return false;
   }
 
   // Find out what plugin (NPP) is the owner of the object we're
   // manipulating, and make it own any JSObject wrappers created here.
   NPP npp = LookupNPP(npobj);
 
   if (!npp) {
     ThrowJSException(cx, "Error finding NPP for NPObject!");
 
-    return JS_FALSE;
+    return false;
   }
 
   PluginDestructionGuard pdg(npp);
 
   NPVariant npargs_buf[8];
   NPVariant *npargs = npargs_buf;
 
   if (argc > (sizeof(npargs_buf) / sizeof(NPVariant))) {
     // Our stack buffer isn't large enough to hold all arguments,
     // malloc a buffer.
     npargs = (NPVariant *)PR_Malloc(argc * sizeof(NPVariant));
 
     if (!npargs) {
       ThrowJSException(cx, "Out of memory!");
 
-      return JS_FALSE;
+      return false;
     }
   }
 
   // Convert arguments
   uint32_t i;
   for (i = 0; i < argc; ++i) {
     if (!JSValToNPVariant(npp, cx, argv[i], npargs + i)) {
       ThrowJSException(cx, "Error converting jsvals to NPVariants!");
 
       if (npargs != npargs_buf) {
         PR_Free(npargs);
       }
 
-      return JS_FALSE;
+      return false;
     }
   }
 
   NPVariant v;
   VOID_TO_NPVARIANT(v);
 
   JSObject *funobj = JSVAL_TO_OBJECT(argv[-2]);
   JSBool ok;
@@ -1388,65 +1384,65 @@ CallNPMethodInternal(JSContext *cx, JS::
   if (ctorCall) {
     // construct a new NPObject based on the NPClass in npobj. Fail if
     // no construct method is available.
 
     if (NP_CLASS_STRUCT_VERSION_HAS_CTOR(npobj->_class) &&
         npobj->_class->construct) {
       ok = npobj->_class->construct(npobj, npargs, argc, &v);
     } else {
-      ok = JS_FALSE;
+      ok = false;
 
       msg = "Attempt to construct object from class with no constructor.";
     }
   } else if (funobj != obj) {
     // A obj.function() style call is made, get the method name from
     // the function object.
 
     if (npobj->_class->invoke) {
       JSFunction *fun = ::JS_GetObjectFunction(funobj);
       JSString *name = ::JS_InternJSString(cx, ::JS_GetFunctionId(fun));
       NPIdentifier id = StringToNPIdentifier(cx, name);
 
       ok = npobj->_class->invoke(npobj, id, npargs, argc, &v);
     } else {
-      ok = JS_FALSE;
+      ok = false;
 
       msg = "Attempt to call a method on object with no invoke method.";
     }
   } else {
     if (npobj->_class->invokeDefault) {
       // obj is a callable object that is being called, no method name
       // available then. Invoke the default method.
 
       ok = npobj->_class->invokeDefault(npobj, npargs, argc, &v);
     } else {
-      ok = JS_FALSE;
+      ok = false;
 
       msg = "Attempt to call a default method on object with no "
         "invokeDefault method.";
     }
   }
 
   // Release arguments.
   for (i = 0; i < argc; ++i) {
     _releasevariantvalue(npargs + i);
   }
 
   if (npargs != npargs_buf) {
     PR_Free(npargs);
   }
 
   if (!ok) {
-    // ReportExceptionIfPending returns a return value, which is JS_TRUE
+    // ReportExceptionIfPending returns a return value, which is true
     // if no exception was thrown. In that case, throw our own.
     if (ReportExceptionIfPending(cx))
       ThrowJSException(cx, msg);
 
-    return JS_FALSE;
+    return false;
   }
 
   *rval = NPVariantToJSVal(npp, cx, &v);
 
   // *rval now owns the value, release our reference.
   _releasevariantvalue(&v);
 
   return ReportExceptionIfPending(cx);
@@ -1474,49 +1470,49 @@ NPObjWrapper_newEnumerate(JSContext *cx,
 {
   NPObject *npobj = GetNPObject(cx, obj);
   NPIdentifier *enum_value;
   uint32_t length;
   NPObjectEnumerateState *state;
 
   if (!npobj || !npobj->_class) {
     ThrowJSException(cx, "Bad NPObject as private data!");
-    return JS_FALSE;
+    return false;
   }
 
   PluginDestructionGuard pdg(LookupNPP(npobj));
 
   NS_ASSERTION(statep, "Must have a statep to enumerate!");
 
   switch(enum_op) {
   case JSENUMERATE_INIT:
   case JSENUMERATE_INIT_ALL:
     state = new NPObjectEnumerateState();
     if (!state) {
       ThrowJSException(cx, "Memory allocation failed for "
                        "NPObjectEnumerateState!");
 
-      return JS_FALSE;
+      return false;
     }
 
     if (!NP_CLASS_STRUCT_VERSION_HAS_ENUM(npobj->_class) ||
         !npobj->_class->enumerate) {
       enum_value = 0;
       length = 0;
     } else if (!npobj->_class->enumerate(npobj, &enum_value, &length)) {
       delete state;
 
       if (ReportExceptionIfPending(cx)) {
-        // ReportExceptionIfPending returns a return value, which is JS_TRUE
+        // ReportExceptionIfPending returns a return value, which is true
         // if no exception was thrown. In that case, throw our own.
         ThrowJSException(cx, "Error enumerating properties on scriptable "
                              "plugin object");
       }
 
-      return JS_FALSE;
+      return false;
     }
 
     state->value = enum_value;
     state->length = length;
     state->index = 0;
     *statep = PRIVATE_TO_JSVAL(state);
     if (idp) {
       *idp = INT_TO_JSID(length);
@@ -1525,86 +1521,86 @@ NPObjWrapper_newEnumerate(JSContext *cx,
     break;
 
   case JSENUMERATE_NEXT:
     state = (NPObjectEnumerateState *)JSVAL_TO_PRIVATE(*statep);
     enum_value = state->value;
     length = state->length;
     if (state->index != length) {
       *idp = NPIdentifierToJSId(enum_value[state->index++]);
-      return JS_TRUE;
+      return true;
     }
 
     // FALL THROUGH
 
   case JSENUMERATE_DESTROY:
     state = (NPObjectEnumerateState *)JSVAL_TO_PRIVATE(*statep);
     if (state->value)
       PR_Free(state->value);
     delete state;
     *statep = JSVAL_NULL;
 
     break;
   }
 
-  return JS_TRUE;
+  return true;
 }
 
 static JSBool
 NPObjWrapper_NewResolve(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id, unsigned flags,
                         JS::MutableHandle<JSObject*> objp)
 {
   NPObject *npobj = GetNPObject(cx, obj);
 
   if (!npobj || !npobj->_class || !npobj->_class->hasProperty ||
       !npobj->_class->hasMethod) {
     ThrowJSException(cx, "Bad NPObject as private data!");
 
-    return JS_FALSE;
+    return false;
   }
 
   PluginDestructionGuard pdg(LookupNPP(npobj));
 
   NPIdentifier identifier = JSIdToNPIdentifier(id);
 
   bool hasProperty = npobj->_class->hasProperty(npobj, identifier);
   if (!ReportExceptionIfPending(cx))
-    return JS_FALSE;
+    return false;
 
   if (hasProperty) {
     NS_ASSERTION(JSID_IS_STRING(id) || JSID_IS_INT(id),
                  "id must be either string or int!\n");
     if (!::JS_DefinePropertyById(cx, obj, id, JSVAL_VOID, nullptr,
                                  nullptr, JSPROP_ENUMERATE | JSPROP_SHARED)) {
-        return JS_FALSE;
+        return false;
     }
 
     objp.set(obj);
 
-    return JS_TRUE;
+    return true;
   }
 
   bool hasMethod = npobj->_class->hasMethod(npobj, identifier);
   if (!ReportExceptionIfPending(cx))
-    return JS_FALSE;
+    return false;
 
   if (hasMethod) {
     NS_ASSERTION(JSID_IS_STRING(id) || JSID_IS_INT(id),
                  "id must be either string or int!\n");
 
     JSFunction *fnc = ::JS_DefineFunctionById(cx, obj, id, CallNPMethod, 0,
                                               JSPROP_ENUMERATE);
 
     objp.set(obj);
 
     return fnc != nullptr;
   }
 
   // no property or method
-  return JS_TRUE;
+  return true;
 }
 
 static JSBool
 NPObjWrapper_Convert(JSContext *cx, JS::Handle<JSObject*> obj, JSType hint, JS::MutableHandle<JS::Value> vp)
 {
   JS_ASSERT(hint == JSTYPE_NUMBER || hint == JSTYPE_STRING || hint == JSTYPE_VOID);
 
   // Plugins do not simply use JS_ConvertStub, and the default [[DefaultValue]]
@@ -1943,38 +1939,38 @@ LookupNPP(NPObject *npobj)
 
   return entry->mNpp;
 }
 
 JSBool
 CreateNPObjectMember(NPP npp, JSContext *cx, JSObject *obj, NPObject* npobj,
                      JS::Handle<jsid> id,  NPVariant* getPropertyResult, JS::Value *vp)
 {
-  NS_ENSURE_TRUE(vp, JS_FALSE);
+  NS_ENSURE_TRUE(vp, false);
 
   if (!npobj || !npobj->_class || !npobj->_class->getProperty ||
       !npobj->_class->invoke) {
     ThrowJSException(cx, "Bad NPObject");
 
-    return JS_FALSE;
+    return false;
   }
 
   NPObjectMemberPrivate *memberPrivate =
     (NPObjectMemberPrivate *)PR_Malloc(sizeof(NPObjectMemberPrivate));
   if (!memberPrivate)
-    return JS_FALSE;
+    return false;
 
   // Make sure to clear all members in case something fails here
   // during initialization.
   memset(memberPrivate, 0, sizeof(NPObjectMemberPrivate));
 
   JSObject *memobj = ::JS_NewObject(cx, &sNPObjectMemberClass, nullptr, nullptr);
   if (!memobj) {
     PR_Free(memberPrivate);
-    return JS_FALSE;
+    return false;
   }
 
   *vp = OBJECT_TO_JSVAL(memobj);
   ::JS_AddValueRoot(cx, vp);
 
   ::JS_SetPrivate(memobj, (void *)memberPrivate);
 
   NPIdentifier identifier = JSIdToNPIdentifier(id);
@@ -1988,22 +1984,22 @@ CreateNPObjectMember(NPP npp, JSContext 
   }
   else {
     VOID_TO_NPVARIANT(npv);
 
     NPBool hasProperty = npobj->_class->getProperty(npobj, identifier,
                                                     &npv);
     if (!ReportExceptionIfPending(cx)) {
       ::JS_RemoveValueRoot(cx, vp);
-      return JS_FALSE;
+      return false;
     }
 
     if (!hasProperty) {
       ::JS_RemoveValueRoot(cx, vp);
-      return JS_FALSE;
+      return false;
     }
   }
 
   fieldValue = NPVariantToJSVal(npp, cx, &npv);
 
   // npobjWrapper is the JSObject through which we make sure we don't
   // outlive the underlying NPObject, so make sure it points to the
   // real JSObject wrapper for the NPObject.
@@ -2012,50 +2008,50 @@ CreateNPObjectMember(NPP npp, JSContext 
   memberPrivate->npobjWrapper = obj;
 
   memberPrivate->fieldValue = fieldValue;
   memberPrivate->methodName = id;
   memberPrivate->npp = npp;
 
   ::JS_RemoveValueRoot(cx, vp);
 
-  return JS_TRUE;
+  return true;
 }
 
 static JSBool
 NPObjectMember_Convert(JSContext *cx, JS::Handle<JSObject*> obj, JSType type, JS::MutableHandle<JS::Value> vp)
 {
   NPObjectMemberPrivate *memberPrivate =
     (NPObjectMemberPrivate *)::JS_GetInstancePrivate(cx, obj,
                                                      &sNPObjectMemberClass,
                                                      nullptr);
   if (!memberPrivate) {
     NS_ERROR("no Ambiguous Member Private data!");
-    return JS_FALSE;
+    return false;
   }
 
   switch (type) {
   case JSTYPE_VOID:
   case JSTYPE_STRING:
   case JSTYPE_NUMBER:
     vp.set(memberPrivate->fieldValue);
     if (!JSVAL_IS_PRIMITIVE(vp)) {
       return JS_DefaultValue(cx, JSVAL_TO_OBJECT(vp), type, vp.address());
     }
-    return JS_TRUE;
+    return true;
   case JSTYPE_BOOLEAN:
   case JSTYPE_OBJECT:
     vp.set(memberPrivate->fieldValue);
-    return JS_TRUE;
+    return true;
   case JSTYPE_FUNCTION:
     // Leave this to NPObjectMember_Call.
-    return JS_TRUE;
+    return true;
   default:
     NS_ERROR("illegal operation on JSObject prototype object");
-    return JS_FALSE;
+    return false;
   }
 }
 
 static void
 NPObjectMember_Finalize(JSFreeOp *fop, JSObject *obj)
 {
   NPObjectMemberPrivate *memberPrivate;
 
@@ -2127,17 +2123,17 @@ NPObjectMember_Call(JSContext *cx, unsig
     _releasevariantvalue(npargs + i);
   }
 
   if (npargs != npargs_buf) {
     PR_Free(npargs);
   }
 
   if (!ok) {
-    // ReportExceptionIfPending returns a return value, which is JS_TRUE
+    // ReportExceptionIfPending returns a return value, which is true
     // if no exception was thrown. In that case, throw our own.
     if (ReportExceptionIfPending(cx))
       ThrowJSException(cx, "Error calling method on NPObject!");
 
     return false;
   }
 
   JS_SET_RVAL(cx, vp, NPVariantToJSVal(memberPrivate->npp, cx, &npv));
--- a/dom/plugins/ipc/PluginScriptableObjectParent.cpp
+++ b/dom/plugins/ipc/PluginScriptableObjectParent.cpp
@@ -1218,36 +1218,36 @@ PluginScriptableObjectParent::GetPropert
                                                 bool* aHasMethod,
                                                 NPVariant* aResult)
 {
   NS_ASSERTION(Type() == Proxy, "Bad type!");
 
   ParentNPObject* object = static_cast<ParentNPObject*>(mObject);
   if (object->invalidated) {
     NS_WARNING("Calling method on an invalidated object!");
-    return JS_FALSE;
+    return false;
   }
 
   StackIdentifier identifier(GetInstance(), aName);
   if (!identifier) {
-    return JS_FALSE;
+    return false;
   }
 
   bool hasProperty, hasMethod, success;
   Variant result;
   if (!CallGetChildProperty(identifier, &hasProperty, &hasMethod, &result,
                             &success)) {
-    return JS_FALSE;
+    return false;
   }
 
   if (!success) {
-    return JS_FALSE;
+    return false;
   }
 
   if (!ConvertToVariant(result, *aResult, GetInstance())) {
     NS_WARNING("Failed to convert result!");
-    return JS_FALSE;
+    return false;
   }
 
   *aHasProperty = hasProperty;
   *aHasMethod = hasMethod;
-  return JS_TRUE;
+  return true;
 }
--- a/dom/src/geolocation/nsGeolocation.cpp
+++ b/dom/src/geolocation/nsGeolocation.cpp
@@ -719,17 +719,17 @@ nsGeolocationService::HandleMozsettingCh
 
     JS::Rooted<JSObject*> obj(cx, &val.toObject());
     JS::Rooted<JS::Value> key(cx);
     if (!JS_GetProperty(cx, obj, "key", &key) || !key.isString()) {
       return;
     }
 
     JSBool match;
-    if (!JS_StringEqualsAscii(cx, key.toString(), GEO_SETINGS_ENABLED, &match) || (match != JS_TRUE)) {
+    if (!JS_StringEqualsAscii(cx, key.toString(), GEO_SETINGS_ENABLED, &match) || !match) {
       return;
     }
 
     JS::Rooted<JS::Value> value(cx);
     if (!JS_GetProperty(cx, obj, "value", &value) || !value.isBoolean()) {
       return;
     }
 
--- a/dom/src/json/nsJSON.cpp
+++ b/dom/src/json/nsJSON.cpp
@@ -160,19 +160,19 @@ nsJSON::EncodeToStream(nsIOutputStream *
 }
 
 static JSBool
 WriteCallback(const jschar *buf, uint32_t len, void *data)
 {
   nsJSONWriter *writer = static_cast<nsJSONWriter*>(data);
   nsresult rv =  writer->Write((const PRUnichar*)buf, (uint32_t)len);
   if (NS_FAILED(rv))
-    return JS_FALSE;
+    return false;
 
-  return JS_TRUE;
+  return true;
 }
 
 NS_IMETHODIMP
 nsJSON::EncodeFromJSVal(JS::Value *value, JSContext *cx, nsAString &result)
 {
   result.Truncate();
 
   mozilla::Maybe<JSAutoCompartment> ac;
--- a/dom/system/gonk/TimeZoneSettingObserver.cpp
+++ b/dom/system/gonk/TimeZoneSettingObserver.cpp
@@ -182,17 +182,17 @@ TimeZoneSettingObserver::Observe(nsISupp
   JSObject &obj(val.toObject());
   JS::Rooted<JS::Value> key(cx);
   if (!JS_GetProperty(cx, &obj, "key", &key) ||
       !key.isString()) {
     return NS_OK;
   }
   JSBool match;
   if (!JS_StringEqualsAscii(cx, key.toString(), TIME_TIMEZONE, &match) ||
-      match != JS_TRUE) {
+      !match) {
     return NS_OK;
   }
 
   // Get the value, which should be a JS string like "America/Chicago".
   JS::Rooted<JS::Value> value(cx);
   if (!JS_GetProperty(cx, &obj, "value", &value) ||
       !value.isString()) {
     return NS_OK;
--- a/gfx/skia/src/xml/SkJS.cpp
+++ b/gfx/skia/src/xml/SkJS.cpp
@@ -74,63 +74,63 @@ extern "C" {
 #endif
 
 static JSBool
 global_enumerate(JSContext *cx, JSObject *obj)
 {
 #ifdef LAZY_STANDARD_CLASSES
     return JS_EnumerateStandardClasses(cx, obj);
 #else
-    return JS_TRUE;
+    return true;
 #endif
 }
 
 static JSBool
 global_resolve(JSContext *cx, JSObject *obj, jsval id, uintN flags, JSObject **objp)
 {
 #ifdef LAZY_STANDARD_CLASSES
     if ((flags & JSRESOLVE_ASSIGNING) == 0) {
         JSBool resolved;
 
         if (!JS_ResolveStandardClass(cx, obj, id, &resolved))
-            return JS_FALSE;
+            return false;
         if (resolved) {
             *objp = obj;
-            return JS_TRUE;
+            return true;
         }
     }
 #endif
 
 #if defined(SHELL_HACK) && defined(DEBUG) && defined(XP_UNIX)
     if ((flags & (JSRESOLVE_QUALIFIED | JSRESOLVE_ASSIGNING)) == 0) {
         /*
          * Do this expensive hack only for unoptimized Unix builds, which are
          * not used for benchmarking.
          */
         char *path, *comp, *full;
         const char *name;
         JSBool ok, found;
         JSFunction *fun;
 
         if (!JSVAL_IS_STRING(id))
-            return JS_TRUE;
+            return true;
         path = getenv("PATH");
         if (!path)
-            return JS_TRUE;
+            return true;
         path = JS_strdup(cx, path);
         if (!path)
-            return JS_FALSE;
+            return false;
         name = JS_GetStringBytes(JSVAL_TO_STRING(id));
-        ok = JS_TRUE;
+        ok = true;
         for (comp = strtok(path, ":"); comp; comp = strtok(NULL, ":")) {
             if (*comp != '\0') {
                 full = JS_smprintf("%s/%s", comp, name);
                 if (!full) {
                     JS_ReportOutOfMemory(cx);
-                    ok = JS_FALSE;
+                    ok = false;
                     break;
                 }
             } else {
                 full = (char *)name;
             }
             found = (access(full, X_OK) == 0);
             if (*comp != '\0')
                 free(full);
@@ -141,17 +141,17 @@ global_resolve(JSContext *cx, JSObject *
                     *objp = obj;
                 break;
             }
         }
         JS_free(cx, path);
         return ok;
     }
 #else
-    return JS_TRUE;
+    return true;
 #endif
 }
 
 JSClass global_class = {
     "global", JSCLASS_NEW_RESOLVE,
     JS_PropertyStub,  JS_PropertyStub,
     JS_PropertyStub,  JS_PropertyStub,
     global_enumerate, (JSResolveOp) global_resolve,
--- a/gfx/skia/src/xml/SkJSDisplayable.cpp
+++ b/gfx/skia/src/xml/SkJSDisplayable.cpp
@@ -74,17 +74,17 @@ SkPaint* SkJSDisplayable::gPaint;
 JSBool SkJSDisplayable::Draw(JSContext *cx, JSObject *obj, uintN argc,
                                     jsval *argv, jsval *rval)
 {
     SkJSDisplayable *p = (SkJSDisplayable*) JS_GetPrivate(cx, obj);
     SkASSERT(p->fDisplayable->isDrawable());
     SkDrawable* drawable = (SkDrawable*) p->fDisplayable;
     SkAnimateMaker maker(NULL, gCanvas, gPaint);
     drawable->draw(maker);
-    return JS_TRUE;
+    return true;
 }
 
 
 JSFunctionSpec SkJSDisplayable_methods[] =
 {
     { "draw", SkJSDisplayable::Draw, 1, 0, 0 },
     { 0 }
 };
@@ -92,17 +92,17 @@ JSFunctionSpec SkJSDisplayable_methods[]
 static JSPropertySpec* gDisplayableProperties[kNumberOfTypes];
 static JSClass gDisplayableClasses[kNumberOfTypes];
 
 #define JS_INIT(_prefix, _class) \
 static JSBool _class##Constructor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { \
     SkJSDisplayable* jsDisplayable = new SkJSDisplayable(); \
     jsDisplayable->fDisplayable = new _prefix##_class(); \
     JS_SetPrivate(cx, obj, (void*) jsDisplayable); \
-    return JS_TRUE; \
+    return true; \
 } \
     \
 static JSObject* _class##Init(JSContext *cx, JSObject *obj, JSObject *proto) { \
     JSObject *newProtoObj = JS_InitClass(cx, obj, proto, &gDisplayableClasses[SkType_##_class], \
         _class##Constructor, 0, \
         NULL, SkJSDisplayable_methods , \
         NULL, NULL); \
     JS_DefineProperties(cx, newProtoObj, gDisplayableProperties[SkType_##_class]); \
@@ -214,17 +214,17 @@ static void GenerateTables() {
 void SkJSDisplayable::Destructor(JSContext *cx, JSObject *obj) {
     delete (SkJSDisplayable*) JS_GetPrivate(cx, obj);
 }
 
 JSBool SkJSDisplayable::GetProperty(JSContext *cx, JSObject *obj, jsval id,
                                  jsval *vp)
 {
     if (JSVAL_IS_INT(id) == 0)
-        return JS_TRUE;
+        return true;
     SkJSDisplayable *p = (SkJSDisplayable *) JS_GetPrivate(cx, obj);
     SkDisplayable* displayable = p->fDisplayable;
     SkDisplayTypes displayableType = displayable->getType();
     int members;
     const SkMemberInfo* info = SkDisplayType::GetMembers(NULL /* fMaker */, displayableType, &members);
     int idIndex = JSVAL_TO_INT(id);
     SkASSERT(idIndex >= 0 && idIndex < members);
     info = &info[idIndex];
@@ -285,22 +285,22 @@ JSBool SkJSDisplayable::GetProperty(JSCo
             break;
         case SkType_String:
             str = JS_NewStringCopyN(cx, string->c_str(), string->size());
             *vp = STRING_TO_JSVAL(str);
             break;
         default:
             SkASSERT(0); // !!! unimplemented
     }
-    return JS_TRUE;
+    return true;
 }
 
 JSBool SkJSDisplayable::SetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp) {
     if (JSVAL_IS_INT(id) == 0)
-        return JS_TRUE;
+        return true;
     SkJSDisplayable *p = (SkJSDisplayable *) JS_GetPrivate(cx, obj);
     SkDisplayable* displayable = p->fDisplayable;
     SkDisplayTypes displayableType = displayable->getType();
     int members;
     const SkMemberInfo* info = SkDisplayType::GetMembers(NULL /* fMaker */, displayableType, &members);
     int idIndex = JSVAL_TO_INT(id);
     SkASSERT(idIndex >= 0 && idIndex < members);
     info = &info[idIndex];
@@ -363,17 +363,17 @@ JSBool SkJSDisplayable::SetProperty(JSCo
                 SkOperand operand;
                 operand.fScalar = scalar;
                 info->setValue(displayable, &operand, 1);
                 break;
             default:
                 SkASSERT(0); // !!! unimplemented
         }
     }
-    return JS_TRUE;
+    return true;
 }
 
 void SkJS::InitializeDisplayables(const SkBitmap& bitmap, JSContext *cx, JSObject *obj, JSObject *proto) {
     SkJSDisplayable::gCanvas = new SkCanvas(bitmap);
     SkJSDisplayable::gPaint = new SkPaint();
 #if SK_USE_CONDENSED_INFO == 0
     GenerateTables();
 #else
--- a/ipc/testshell/TestShellParent.cpp
+++ b/ipc/testshell/TestShellParent.cpp
@@ -41,46 +41,46 @@ TestShellParent::CommandDone(TestShellCo
   return true;
 }
 
 JSBool
 TestShellCommandParent::SetCallback(JSContext* aCx,
                                     JS::Value aCallback)
 {
   if (!mCallback.Hold(aCx)) {
-    return JS_FALSE;
+    return false;
   }
 
   mCallback = aCallback;
   mCx = aCx;
 
-  return JS_TRUE;
+  return true;
 }
 
 JSBool
 TestShellCommandParent::RunCallback(const nsString& aResponse)
 {
-  NS_ENSURE_TRUE(*mCallback.ToJSValPtr() != JSVAL_NULL && mCx, JS_FALSE);
+  NS_ENSURE_TRUE(*mCallback.ToJSValPtr() != JSVAL_NULL && mCx, false);
 
   JSAutoRequest ar(mCx);
-  NS_ENSURE_TRUE(mCallback.ToJSObject(), JS_FALSE);
+  NS_ENSURE_TRUE(mCallback.ToJSObject(), false);
   JSAutoCompartment ac(mCx, mCallback.ToJSObject());
   JS::Rooted<JSObject*> global(mCx, JS::CurrentGlobalOrNull(mCx));
 
   JSString* str = JS_NewUCStringCopyN(mCx, aResponse.get(), aResponse.Length());
-  NS_ENSURE_TRUE(str, JS_FALSE);
+  NS_ENSURE_TRUE(str, false);
 
   JS::Rooted<JS::Value> strVal(mCx, JS::StringValue(str));
 
   JS::Rooted<JS::Value> rval(mCx);
   JSBool ok = JS_CallFunctionValue(mCx, global, mCallback, 1, strVal.address(),
                                    rval.address());
-  NS_ENSURE_TRUE(ok, JS_FALSE);
+  NS_ENSURE_TRUE(ok, false);
 
-  return JS_TRUE;
+  return true;
 }
 
 void
 TestShellCommandParent::ReleaseCallback()
 {
   mCallback.Release();
 }
 
--- a/ipc/testshell/XPCShellEnvironment.cpp
+++ b/ipc/testshell/XPCShellEnvironment.cpp
@@ -116,19 +116,19 @@ static JSBool
 GetLine(char *bufp,
         FILE *file,
         const char *prompt)
 {
     char line[256];
     fputs(prompt, stdout);
     fflush(stdout);
     if (!fgets(line, sizeof line, file))
-        return JS_FALSE;
+        return false;
     strcpy(bufp, line);
-    return JS_TRUE;
+    return true;
 }
 
 static bool
 Dump(JSContext *cx,
      unsigned argc,
      JS::Value *vp)
 {
     JS_SET_RVAL(cx, vp, JSVAL_VOID);
@@ -448,34 +448,34 @@ XPCShellEnvironment::ProcessFile(JSConte
         if (script)
             (void)JS_ExecuteScript(cx, obj, script, result.address());
 
         return;
     }
 
     /* It's an interactive filehandle; drop into read-eval-print loop. */
     lineno = 1;
-    hitEOF = JS_FALSE;
+    hitEOF = false;
     do {
         bufp = buffer;
         *bufp = '\0';
 
         JSAutoRequest ar(cx);
         JSAutoCompartment ac(cx, obj);
 
         /*
          * Accumulate lines until we get a 'compilable unit' - one that either
          * generates an error (before running out of source) or that compiles
          * cleanly.  This should be whenever we get a complete statement that
          * coincides with the end of a line.
          */
         startline = lineno;
         do {
             if (!GetLine(bufp, file, startline == lineno ? "js> " : "")) {
-                hitEOF = JS_TRUE;
+                hitEOF = true;
                 break;
             }
             bufp += strlen(bufp);
             lineno++;
         } while (!JS_BufferIsCompilableUnit(cx, obj, buffer, strlen(buffer)));
 
         /* Clear any pending exception from previous failed compiles.  */
         JS_ClearPendingException(cx);
@@ -493,17 +493,17 @@ XPCShellEnvironment::ProcessFile(JSConte
                 JSAutoByteString bytes;
                 if (str)
                     bytes.encodeLatin1(cx, str);
                 JS_SetErrorReporter(cx, older);
 
                 if (!!bytes)
                     fprintf(stdout, "%s\n", bytes.ptr());
                 else
-                    ok = JS_FALSE;
+                    ok = false;
             }
         }
     } while (!hitEOF && !env->IsQuitting());
 
     fprintf(stdout, "\n");
 }
 
 NS_IMETHODIMP_(nsrefcnt)
@@ -549,17 +549,17 @@ XPCShellEnvironment::CreateEnvironment()
     if (env && !env->Init()) {
         delete env;
         env = nullptr;
     }
     return env;
 }
 
 XPCShellEnvironment::XPCShellEnvironment()
-:   mQuitting(JS_FALSE)
+:   mQuitting(false)
 {
 }
 
 XPCShellEnvironment::~XPCShellEnvironment()
 {
 
     AutoSafeJSContext cx;
     Rooted<JSObject*> global(cx, GetGlobalObject());
@@ -669,17 +669,17 @@ XPCShellEnvironment::Init()
     }
 
     mGlobalHolder = globalObj;
 
     FILE* runtimeScriptFile = fopen(kDefaultRuntimeScriptFilename, "r");
     if (runtimeScriptFile) {
         fprintf(stdout, "[loading '%s'...]\n", kDefaultRuntimeScriptFilename);
         ProcessFile(cx, globalObj, kDefaultRuntimeScriptFilename,
-                    runtimeScriptFile, JS_FALSE);
+                    runtimeScriptFile, false);
         fclose(runtimeScriptFile);
     }
 
     return true;
 }
 
 bool
 XPCShellEnvironment::EvaluateString(const nsString& aString,
--- a/ipc/testshell/XPCShellEnvironment.h
+++ b/ipc/testshell/XPCShellEnvironment.h
@@ -39,17 +39,17 @@ public:
         return nsJSPrincipals::get(nsContentUtils::GetSystemPrincipal());
     }
 
     JSObject* GetGlobalObject() {
         return mGlobalHolder.ToJSObject();
     }
 
     void SetIsQuitting() {
-        mQuitting = JS_TRUE;
+        mQuitting = true;
     }
     JSBool IsQuitting() {
         return mQuitting;
     }
 
 protected:
     XPCShellEnvironment();
     bool Init();
--- a/js/ipc/JavaScriptShared.cpp
+++ b/js/ipc/JavaScriptShared.cpp
@@ -353,24 +353,24 @@ JavaScriptShared::fromDescriptor(JSConte
 
     return true;
 }
 
 JSBool
 UnknownPropertyStub(JSContext *cx, HandleObject obj, HandleId id, MutableHandleValue vp)
 {
     JS_ReportError(cx, "getter could not be wrapped via CPOWs");
-    return JS_FALSE;
+    return false;
 }
 
 JSBool
 UnknownStrictPropertyStub(JSContext *cx, HandleObject obj, HandleId id, JSBool strict, MutableHandleValue vp)
 {
     JS_ReportError(cx, "setter could not be wrapped via CPOWs");
-    return JS_FALSE;
+    return false;
 }
 
 bool
 JavaScriptShared::toDescriptor(JSContext *cx, const PPropertyDescriptor &in, JSPropertyDescriptor *out)
 {
     out->attrs = in.attrs();
     out->shortid = in.shortid();
     if (!toValue(cx, in.value(), &out->value))
--- a/js/jsd/idl/jsdIDebuggerService.idl
+++ b/js/jsd/idl/jsdIDebuggerService.idl
@@ -1198,17 +1198,17 @@ interface jsdIProperty : jsdIEphemeral
     /** property has an alias id */
     const unsigned long FLAG_ALIAS     = 0x08;
     /** argument to function */
     const unsigned long FLAG_ARGUMENT  = 0x10;
     /** local variable in function */
     const unsigned long FLAG_VARIABLE  = 0x20;
     /** exception occurred looking up property, value is exception */
     const unsigned long FLAG_EXCEPTION = 0x40;
-    /** native getter returned JS_FALSE without throwing an exception */
+    /** native getter returned false without throwing an exception */
     const unsigned long FLAG_ERROR     = 0x80;
     /** found via explicit lookup (property defined elsewhere.) */
     const unsigned long FLAG_HINTED    = 0x800;
 
     /** FLAG_* values OR'd together, representing the flags for this property. */
     readonly attribute unsigned long flags;
     /** jsdIValue representing the alias for this property. */
     readonly attribute jsdIValue     alias;
--- a/js/jsd/jsd_high.cpp
+++ b/js/jsd/jsd_high.cpp
@@ -128,17 +128,17 @@ static JSDContext*
         JSAutoCompartment ac(cx, jsdc->glob);
         ok = JS_AddNamedObjectRoot(cx, &jsdc->glob, "JSD context global") &&
              JS_InitStandardClasses(cx, jsdc->glob);
     }
     if( ! ok )
         goto label_newJSDContext_failure;
 
     jsdc->data = NULL;
-    jsdc->inited = JS_TRUE;
+    jsdc->inited = true;
 
     JSD_LOCK();
     JS_INSERT_LINK(&jsdc->links, &_jsd_context_list);
     JSD_UNLOCK();
 
     return jsdc;
 
 label_newJSDContext_failure:
@@ -162,17 +162,17 @@ static void
     JSD_UNLOCK();
 
     if ( jsdc->glob ) {
         JS_RemoveObjectRootRT(jsdc->jsrt, &jsdc->glob);
     }
     jsd_DestroyObjectManager(jsdc);
     jsd_DestroyAtomTable(jsdc);
 
-    jsdc->inited = JS_FALSE;
+    jsdc->inited = false;
 
     /*
     * We should free jsdc here, but we let it leak in case there are any 
     * asynchronous hooks calling into the system using it as a handle
     *
     * XXX we also leak the locks
     */
 }
@@ -213,17 +213,17 @@ jsd_DebuggerOn(void)
     JS_ASSERT(_jsrt);
     JS_ASSERT(_validateUserCallbacks(&_callbacks));
     return jsd_DebuggerOnForUser(_jsrt, &_callbacks, _user, NULL);
 }
 
 void
 jsd_DebuggerOff(JSDContext* jsdc)
 {
-    jsd_DebuggerPause(jsdc, JS_TRUE);
+    jsd_DebuggerPause(jsdc, true);
     /* clear hooks here */
     JS_SetNewScriptHookProc(jsdc->jsrt, NULL, NULL);
     JS_SetDestroyScriptHookProc(jsdc->jsrt, NULL, NULL);
 
     /* clean up */
     JSD_LockScriptSubsystem(jsdc);
     jsd_DestroyScriptManager(jsdc);
     JSD_UnlockScriptSubsystem(jsdc);
@@ -334,81 +334,81 @@ jsd_DebugErrorHook(JSContext *cx, const 
 {
     JSDContext* jsdc = (JSDContext*) closure;
     JSD_ErrorReporter errorReporter;
     void*             errorReporterData;
     
     if( ! jsdc )
     {
         JS_ASSERT(0);
-        return JS_TRUE;
+        return true;
     }
     if( JSD_IS_DANGEROUS_THREAD(jsdc) )
-        return JS_TRUE;
+        return true;
 
     /* local in case hook gets cleared on another thread */
     JSD_LOCK();
     errorReporter     = jsdc->errorReporter;
     errorReporterData = jsdc->errorReporterData;
     JSD_UNLOCK();
 
     if(!errorReporter)
-        return JS_TRUE;
+        return true;
 
     switch(errorReporter(jsdc, cx, message, report, errorReporterData))
     {
         case JSD_ERROR_REPORTER_PASS_ALONG:
-            return JS_TRUE;
+            return true;
         case JSD_ERROR_REPORTER_RETURN:
-            return JS_FALSE;
+            return false;
         case JSD_ERROR_REPORTER_DEBUG:
         {
             jsval rval;
             JSD_ExecutionHookProc   hook;
             void*                   hookData;
 
             /* local in case hook gets cleared on another thread */
             JSD_LOCK();
             hook = jsdc->debugBreakHook;
             hookData = jsdc->debugBreakHookData;
             JSD_UNLOCK();
 
             jsd_CallExecutionHook(jsdc, cx, JSD_HOOK_DEBUG_REQUESTED,
                                   hook, hookData, &rval);
             /* XXX Should make this dependent on ExecutionHook retval */
-            return JS_TRUE;
+            return true;
         }
         case JSD_ERROR_REPORTER_CLEAR_RETURN:
             if(report && JSREPORT_IS_EXCEPTION(report->flags))
                 JS_ClearPendingException(cx);
-            return JS_FALSE;
+            return false;
         default:
             JS_ASSERT(0);
             break;
     }
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_SetErrorReporter(JSDContext*       jsdc, 
                      JSD_ErrorReporter reporter, 
                      void*             callerdata)
 {
     JSD_LOCK();
     jsdc->errorReporter = reporter;
     jsdc->errorReporterData = callerdata;
     JSD_UNLOCK();
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_GetErrorReporter(JSDContext*        jsdc, 
                      JSD_ErrorReporter* reporter, 
                      void**             callerdata)
 {
     JSD_LOCK();
     if( reporter )
         *reporter = jsdc->errorReporter;
     if( callerdata )
         *callerdata = jsdc->errorReporterData;
     JSD_UNLOCK();
-    return JS_TRUE;
+    return true;
 }
--- a/js/jsd/jsd_hook.cpp
+++ b/js/jsd/jsd_hook.cpp
@@ -170,17 +170,17 @@ jsd_CallCallHook (JSDContext* jsdc,
                   JSContext *cx,
                   unsigned type,
                   JSD_CallHookProc hook,
                   void* hookData)
 {
     JSBool hookanswer;
     JSDThreadState*  jsdthreadstate;
     
-    hookanswer = JS_FALSE;
+    hookanswer = false;
     if(hook && NULL != (jsdthreadstate = jsd_NewThreadState(jsdc, cx)))
     {
         hookanswer = hook(jsdc, jsdthreadstate, type, hookData);
         jsd_DestroyThreadState(jsdc, jsdthreadstate);
     }
 
     return hookanswer;
 }
@@ -191,137 +191,137 @@ jsd_SetInterruptHook(JSDContext*        
                      void*                 callerdata)
 {
     JSD_LOCK();
     jsdc->interruptHookData  = callerdata;
     jsdc->interruptHook      = hook;
     JS_SetInterrupt(jsdc->jsrt, jsd_InterruptHandler, (void*) jsdc);
     JSD_UNLOCK();
 
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_ClearInterruptHook(JSDContext* jsdc)
 {
     JSD_LOCK();
     JS_ClearInterrupt(jsdc->jsrt, NULL, NULL );
     jsdc->interruptHook      = NULL;
     JSD_UNLOCK();
 
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_SetDebugBreakHook(JSDContext*           jsdc,
                       JSD_ExecutionHookProc hook,
                       void*                 callerdata)
 {
     JSD_LOCK();
     jsdc->debugBreakHookData  = callerdata;
     jsdc->debugBreakHook      = hook;
     JSD_UNLOCK();
 
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_ClearDebugBreakHook(JSDContext* jsdc)
 {
     JSD_LOCK();
     jsdc->debugBreakHook      = NULL;
     JSD_UNLOCK();
 
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_SetDebuggerHook(JSDContext*           jsdc,
                       JSD_ExecutionHookProc hook,
                       void*                 callerdata)
 {
     JSD_LOCK();
     jsdc->debuggerHookData  = callerdata;
     jsdc->debuggerHook      = hook;
     JSD_UNLOCK();
 
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_ClearDebuggerHook(JSDContext* jsdc)
 {
     JSD_LOCK();
     jsdc->debuggerHook      = NULL;
     JSD_UNLOCK();
 
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_SetThrowHook(JSDContext*           jsdc,
                  JSD_ExecutionHookProc hook,
                  void*                 callerdata)
 {
     JSD_LOCK();
     jsdc->throwHookData  = callerdata;
     jsdc->throwHook      = hook;
     JSD_UNLOCK();
 
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_ClearThrowHook(JSDContext* jsdc)
 {
     JSD_LOCK();
     jsdc->throwHook      = NULL;
     JSD_UNLOCK();
 
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_SetFunctionHook(JSDContext*      jsdc,
                     JSD_CallHookProc hook,
                     void*            callerdata)
 {
     JSD_LOCK();
     jsdc->functionHookData  = callerdata;
     jsdc->functionHook      = hook;
     JSD_UNLOCK();
 
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_ClearFunctionHook(JSDContext* jsdc)
 {
     JSD_LOCK();
     jsdc->functionHook      = NULL;
     JSD_UNLOCK();
 
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_SetTopLevelHook(JSDContext*      jsdc,
                     JSD_CallHookProc hook,
                     void*            callerdata)
 {
     JSD_LOCK();
     jsdc->toplevelHookData  = callerdata;
     jsdc->toplevelHook      = hook;
     JSD_UNLOCK();
 
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_ClearTopLevelHook(JSDContext* jsdc)
 {
     JSD_LOCK();
     jsdc->toplevelHook      = NULL;
     JSD_UNLOCK();
 
-    return JS_TRUE;
+    return true;
 }
 
--- a/js/jsd/jsd_lock.cpp
+++ b/js/jsd/jsd_lock.cpp
@@ -144,19 +144,19 @@ jsd_Unlock(JSDStaticLock* lock)
 #ifdef DEBUG
 JSBool
 jsd_IsLocked(JSDStaticLock* lock)
 {
     void* me;
     ASSERT_VALID_LOCK(lock);
     _CURRENT_THREAD(me);
     if (lock->owner != me)
-        return JS_FALSE;
+        return false;
     JS_ASSERT(lock->count > 0);
-    return JS_TRUE;
+    return true;
 }    
 #endif /* DEBUG */
 
 void*
 jsd_CurrentThread()
 {
     void* me;
     _CURRENT_THREAD(me);
@@ -192,17 +192,17 @@ void
 jsd_Unlock(void* lock)
 {
 }    
 
 #ifdef DEBUG
 JSBool
 jsd_IsLocked(void* lock)
 {
-    return JS_TRUE;
+    return true;
 }    
 #endif /* DEBUG */
 
 /* 
  * This Windows only thread id code is here to allow the Java-based 
  * JSDebugger to work with the single threaded js.c shell (even without 
  * real locking and threading support).
  */
--- a/js/jsd/jsd_scpt.cpp
+++ b/js/jsd/jsd_scpt.cpp
@@ -400,19 +400,19 @@ jsd_IsActiveScript(JSDContext* jsdc, JSD
 
     JS_ASSERT(JSD_SCRIPTS_LOCKED(jsdc));
 
     for( current = (JSDScript *)jsdc->scripts.next;
          current != (JSDScript *)&jsdc->scripts;
          current = (JSDScript *)current->links.next )
     {
         if(jsdscript == current)
-            return JS_TRUE;
+            return true;
     }
-    return JS_FALSE;
+    return false;
 }        
 
 const char*
 jsd_GetScriptFilename(JSDContext* jsdc, JSDScript *jsdscript)
 {
     return jsdscript->url;
 }
 
@@ -488,17 +488,17 @@ jsd_GetLinePCs(JSDContext* jsdc, JSDScri
 {
     unsigned first = jsdscript->lineBase;
     unsigned last = first + jsd_GetScriptLineExtent(jsdc, jsdscript) - 1;
     JSBool ok;
     jsbytecode **pcs;
     unsigned i;
 
     if (last < startLine)
-        return JS_TRUE;
+        return true;
 
     AutoSafeJSContext cx;
     JSAutoCompartment ac(cx, jsdscript->script);
 
     ok = JS_GetLinePCs(cx, jsdscript->script,
                        startLine, maxLines,
                        count, retLines, &pcs);
 
@@ -517,29 +517,29 @@ jsd_GetLinePCs(JSDContext* jsdc, JSDScri
 
 JSBool
 jsd_SetScriptHook(JSDContext* jsdc, JSD_ScriptHookProc hook, void* callerdata)
 {
     JSD_LOCK();
     jsdc->scriptHook = hook;
     jsdc->scriptHookData = callerdata;
     JSD_UNLOCK();
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_GetScriptHook(JSDContext* jsdc, JSD_ScriptHookProc* hook, void** callerdata)
 {
     JSD_LOCK();
     if( hook )
         *hook = jsdc->scriptHook;
     if( callerdata )
         *callerdata = jsdc->scriptHookData;
     JSD_UNLOCK();
-    return JS_TRUE;
+    return true;
 }    
 
 JSBool
 jsd_EnableSingleStepInterrupts(JSDContext* jsdc, JSDScript* jsdscript, JSBool enable)
 {
     JSBool rv;
     AutoSafeJSContext cx;
     JSAutoCompartment ac(cx, jsdscript->script);
@@ -588,17 +588,17 @@ jsd_NewScriptHookProc(
     JSD_LOCK();
     hook = jsdc->scriptHook;
     if( hook )
         jsdscript->flags = jsdscript->flags | JSD_SCRIPT_CALL_DESTROY_HOOK_BIT;
     hookData = jsdc->scriptHookData;
     JSD_UNLOCK();
 
     if( hook )
-        hook(jsdc, jsdscript, JS_TRUE, hookData);
+        hook(jsdc, jsdscript, true, hookData);
 }
 
 void
 jsd_DestroyScriptHookProc( 
                 JSFreeOp    *fop,
                 JSScript    *script_,
                 void*       callerdata )
 {
@@ -630,17 +630,17 @@ jsd_DestroyScriptHookProc(
 
     /* local in case hook gets cleared on another thread */
     JSD_LOCK();
     hook = (jsdscript->flags & JSD_SCRIPT_CALL_DESTROY_HOOK_BIT) ? jsdc->scriptHook : NULL;
     hookData = jsdc->scriptHookData;
     JSD_UNLOCK();
 
     if( hook )
-        hook(jsdc, jsdscript, JS_FALSE, hookData);
+        hook(jsdc, jsdscript, false, hookData);
 
     JSD_LOCK_SCRIPTS(jsdc);
     JS_HashTableRemove(jsdc->scriptsTable, (void *)script);
     JSD_UNLOCK_SCRIPTS(jsdc);
 
 #ifdef JSD_DUMP
     JSD_LOCK_SCRIPTS(jsdc);
     _dumpJSDScriptList(jsdc);
@@ -674,33 +674,33 @@ static JSBool
     JSCList* list;
     JSDScript* jsdscript;
 
     JSD_LOCK_SCRIPTS(jsdc);
     jsdscript = jsd_FindJSDScript(jsdc, script);
     if( ! jsdscript)
     {
         JSD_UNLOCK_SCRIPTS(jsdc);
-        return JS_FALSE;
+        return false;
     }
 
     list = &jsdscript->hooks;
 
     for( current = (JSDExecHook*)list->next;
          current != (JSDExecHook*)list;
          current = (JSDExecHook*)current->links.next )
     {
         if(current == jsdhook)
         {
             JSD_UNLOCK_SCRIPTS(jsdc);
-            return JS_TRUE;
+            return true;
         }
     }
     JSD_UNLOCK_SCRIPTS(jsdc);
-    return JS_FALSE;
+    return false;
 }
 
 
 JSTrapStatus
 jsd_TrapHandler(JSContext *cx, JSScript *script_, jsbytecode *pc, jsval *rval,
                 jsval closure)
 {
     JS::RootedScript script(cx, script_);
@@ -751,33 +751,33 @@ jsd_SetExecutionHook(JSDContext*        
     JSDExecHook* jsdhook;
     JSBool rv;
 
     JSD_LOCK();
     if( ! hook )
     {
         jsd_ClearExecutionHook(jsdc, jsdscript, pc);
         JSD_UNLOCK();
-        return JS_TRUE;
+        return true;
     }
 
     jsdhook = _findHook(jsdc, jsdscript, pc);
     if( jsdhook )
     {
         jsdhook->hook       = hook;
         jsdhook->callerdata = callerdata;
         JSD_UNLOCK();
-        return JS_TRUE;
+        return true;
     }
     /* else... */
 
     jsdhook = (JSDExecHook*)calloc(1, sizeof(JSDExecHook));
     if( ! jsdhook ) {
         JSD_UNLOCK();
-        return JS_FALSE;
+        return false;
     }
     jsdhook->jsdscript  = jsdscript;
     jsdhook->pc         = pc;
     jsdhook->hook       = hook;
     jsdhook->callerdata = callerdata;
 
     {
         AutoSafeJSContext cx;
@@ -785,53 +785,53 @@ jsd_SetExecutionHook(JSDContext*        
         rv = JS_SetTrap(cx, jsdscript->script, 
                         (jsbytecode*)pc, jsd_TrapHandler,
                         PRIVATE_TO_JSVAL(jsdhook));
     }
 
     if ( ! rv ) {
         free(jsdhook);
         JSD_UNLOCK();
-        return JS_FALSE;
+        return false;
     }
 
     JS_APPEND_LINK(&jsdhook->links, &jsdscript->hooks);
     JSD_UNLOCK();
 
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_ClearExecutionHook(JSDContext*           jsdc, 
                        JSDScript*            jsdscript,
                        uintptr_t             pc)
 {
     JSDExecHook* jsdhook;
 
     JSD_LOCK();
 
     jsdhook = _findHook(jsdc, jsdscript, pc);
     if( ! jsdhook )
     {
         JSD_UNLOCK();
-        return JS_FALSE;
+        return false;
     }
 
     {
         AutoSafeJSContext cx;
         JSAutoCompartment ac(cx, jsdscript->script);
         JS_ClearTrap(cx, jsdscript->script, 
                      (jsbytecode*)pc, NULL, NULL );
     }
 
     JS_REMOVE_LINK(&jsdhook->links);
     free(jsdhook);
 
     JSD_UNLOCK();
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_ClearAllExecutionHooksForScript(JSDContext* jsdc, JSDScript* jsdscript)
 {
     JSDExecHook* jsdhook;
     JSCList* list = &jsdscript->hooks;
     JSD_LOCK();
@@ -840,30 +840,30 @@ jsd_ClearAllExecutionHooksForScript(JSDC
     {
         JS_REMOVE_LINK(&jsdhook->links);
         free(jsdhook);
     }
 
     JS_ClearScriptTraps(jsdc->jsrt, jsdscript->script);
     JSD_UNLOCK();
 
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 jsd_ClearAllExecutionHooks(JSDContext* jsdc)
 {
     JSDScript* jsdscript;
     JSDScript* iterp = NULL;
 
     JSD_LOCK();
     while( NULL != (jsdscript = jsd_IterateScripts(jsdc, &iterp)) )
         jsd_ClearAllExecutionHooksForScript(jsdc, jsdscript);
     JSD_UNLOCK();
-    return JS_TRUE;
+    return true;
 }
 
 void
 jsd_ScriptCreated(JSDContext* jsdc,
                   JSContext   *cx,
                   const char  *filename,    /* URL this script loads from */
                   unsigned       lineno,       /* line where this script starts */
                   JSScript    *script,
--- a/js/jsd/jsd_stak.cpp
+++ b/js/jsd/jsd_stak.cpp
@@ -356,34 +356,34 @@ jsd_GetIdForStackFrame(JSDContext* jsdc,
     return rv;
 }
 
 JSBool
 jsd_IsStackFrameDebugger(JSDContext* jsdc, 
                          JSDThreadState* jsdthreadstate,
                          JSDStackFrameInfo* jsdframe)
 {
-    JSBool rv = JS_TRUE;
+    JSBool rv = true;
     JSD_LOCK_THREADSTATES(jsdc);
 
     if( jsd_IsValidFrameInThreadState(jsdc, jsdthreadstate, jsdframe) )
     {
         rv = jsdframe->frame.isDebuggerFrame();
     }
 
     JSD_UNLOCK_THREADSTATES(jsdc);
     return rv;
 }
 
 JSBool
 jsd_IsStackFrameConstructing(JSDContext* jsdc, 
                              JSDThreadState* jsdthreadstate,
                              JSDStackFrameInfo* jsdframe)
 {
-    JSBool rv = JS_TRUE;
+    JSBool rv = true;
     JSD_LOCK_THREADSTATES(jsdc);
 
     if( jsd_IsValidFrameInThreadState(jsdc, jsdthreadstate, jsdframe) )
     {
         rv = jsdframe->isConstructing;
     }
 
     JSD_UNLOCK_THREADSTATES(jsdc);
@@ -404,17 +404,17 @@ jsd_EvaluateUCScriptInStackFrame(JSDCont
 
     JS_ASSERT(JSD_CURRENT_THREAD() == jsdthreadstate->thread);
 
     JSD_LOCK_THREADSTATES(jsdc);
     valid = jsd_IsValidFrameInThreadState(jsdc, jsdthreadstate, jsdframe);
     JSD_UNLOCK_THREADSTATES(jsdc);
 
     if( ! valid )
-        return JS_FALSE;
+        return false;
 
     AutoPushJSContext cx(jsdthreadstate->context);
     JS_ASSERT(cx);
 
     if (eatExceptions)
         exceptionState = JS_SaveExceptionState(cx);
     JS_ClearPendingException(cx);
     jsd_StartingEvalUsingFilename(jsdc, filename);
@@ -441,17 +441,17 @@ jsd_EvaluateScriptInStackFrame(JSDContex
 
     JS_ASSERT(JSD_CURRENT_THREAD() == jsdthreadstate->thread);
 
     JSD_LOCK_THREADSTATES(jsdc);
     valid = jsd_IsValidFrameInThreadState(jsdc, jsdthreadstate, jsdframe);
     JSD_UNLOCK_THREADSTATES(jsdc);
 
     if (!valid)
-        return JS_FALSE;
+        return false;
 
     AutoPushJSContext cx(jsdthreadstate->context);
     JS_ASSERT(cx);
 
     if (eatExceptions)
         exceptionState = JS_SaveExceptionState(cx);
     JS_ClearPendingException(cx);
     jsd_StartingEvalUsingFilename(jsdc, filename);
@@ -500,37 +500,37 @@ jsd_IsValidThreadState(JSDContext*      
 
     JS_ASSERT( JSD_THREADSTATES_LOCKED(jsdc) );
 
     for( cur = (JSDThreadState*)jsdc->threadsStates.next;
          cur != (JSDThreadState*)&jsdc->threadsStates;
          cur = (JSDThreadState*)cur->links.next ) 
     {
         if( cur == jsdthreadstate )
-            return JS_TRUE;
+            return true;
     }
-    return JS_FALSE;
+    return false;
 }    
 
 JSBool
 jsd_IsValidFrameInThreadState(JSDContext*        jsdc, 
                               JSDThreadState*    jsdthreadstate,
                               JSDStackFrameInfo* jsdframe)
 {
     JS_ASSERT(JSD_THREADSTATES_LOCKED(jsdc));
 
     if( ! jsd_IsValidThreadState(jsdc, jsdthreadstate) )
-        return JS_FALSE;
+        return false;
     if( jsdframe->jsdthreadstate != jsdthreadstate )
-        return JS_FALSE;
+        return false;
 
     JSD_ASSERT_VALID_THREAD_STATE(jsdthreadstate);
     JSD_ASSERT_VALID_STACK_FRAME(jsdframe);
     
-    return JS_TRUE;
+    return true;
 }
 
 static JSContext*
 _getContextForThreadState(JSDContext* jsdc, JSDThreadState* jsdthreadstate)
 {
     JSBool valid;
     JSD_LOCK_THREADSTATES(jsdc);
     valid = jsd_IsValidThreadState(jsdc, jsdthreadstate);
@@ -556,17 +556,17 @@ jsd_GetException(JSDContext* jsdc, JSDTh
 
 JSBool
 jsd_SetException(JSDContext* jsdc, JSDThreadState* jsdthreadstate, 
                  JSDValue* jsdval)
 {
     JSContext* cx;
 
     if(!(cx = _getContextForThreadState(jsdc, jsdthreadstate)))
-        return JS_FALSE;
+        return false;
 
     if(jsdval)
         JS_SetPendingException(cx, JSD_GetValueWrappedJSVal(jsdc, jsdval));
     else
         JS_ClearPendingException(cx);
-    return JS_TRUE;
+    return true;
 }
 
--- a/js/jsd/jsd_step.cpp
+++ b/js/jsd/jsd_step.cpp
@@ -77,33 +77,33 @@ static void
 #endif
 
 JSBool
 _callHook(JSDContext *jsdc, JSContext *cx, JSAbstractFramePtr frame, bool isConstructing,
           JSBool before, unsigned type, JSD_CallHookProc hook, void *hookData)
 {
     JSDScript*        jsdscript;
     JSScript*         jsscript;
-    JSBool            hookresult = JS_TRUE;
+    JSBool            hookresult = true;
     
     if (!jsdc || !jsdc->inited)
-        return JS_FALSE;
+        return false;
 
     if (!hook && !(jsdc->flags & JSD_COLLECT_PROFILE_DATA))
     {
         /* no hook to call, no profile data needs to be collected,
          * so there is nothing to do here.
          */
         return hookresult;
     }
 
     if (before && isConstructing) {
         JS::RootedValue newObj(cx);
         if (!frame.getThisValue(cx, &newObj))
-            return JS_FALSE;
+            return false;
         jsd_Constructing(jsdc, cx, JSVAL_TO_OBJECT(newObj), frame);
     }
 
     jsscript = frame.script();
     if (jsscript)
     {
         JSD_LOCK_SCRIPTS(jsdc);
         jsdscript = jsd_FindOrCreateJSDScript(jsdc, cx, jsscript, frame);
@@ -148,17 +148,17 @@ JSBool
                              * called!), and we'll need the call start time. */
                             pdata->runningTime = 0;
                             pdata->lastCallStart = now;
                         } else {
                             if (++pdata->recurseDepth > pdata->maxRecurseDepth)
                                 pdata->maxRecurseDepth = pdata->recurseDepth;
                         }
                         /* make sure we're called for the return too. */
-                        hookresult = JS_TRUE;
+                        hookresult = true;
                     } else if (!pdata->recurseDepth && pdata->lastCallStart) {
                         int64_t now, ll_delta;
                         double delta;
                         now = JS_Now();
                         ll_delta = now - pdata->lastCallStart;
                         delta = ll_delta;
                         delta /= 1000.0;
                         pdata->totalExecutionTime += delta;
@@ -213,24 +213,24 @@ JSBool
                 }
                 if (hook)
                     jsd_CallCallHook (jsdc, cx, type, hook, hookData);
             } else {
                 if (hook)
                     hookresult = 
                         jsd_CallCallHook (jsdc, cx, type, hook, hookData);
                 else
-                    hookresult = JS_TRUE;
+                    hookresult = true;
             }
         }
     }
 
 #ifdef JSD_TRACE
     _interpreterTrace(jsdc, cx, frame, isConstructing, before);
-    return JS_TRUE;
+    return true;
 #else
     return hookresult;
 #endif
 
 }
 
 void *
 jsd_FunctionCallHook(JSContext *cx, JSAbstractFramePtr frame, bool isConstructing,
--- a/js/jsd/jsd_text.cpp
+++ b/js/jsd/jsd_text.cpp
@@ -26,19 +26,19 @@ static void
 _clearText(JSDContext* jsdc, JSDSourceText* jsdsrc)
 {
     if( jsdsrc->text )
         free(jsdsrc->text);
     jsdsrc->text        = NULL;
     jsdsrc->textLength  = 0;
     jsdsrc->textSpace   = 0;
     jsdsrc->status      = JSD_SOURCE_CLEARED;
-    jsdsrc->dirty       = JS_TRUE;
+    jsdsrc->dirty       = true;
     jsdsrc->alterCount  = jsdc->sourceAlterCount++ ;
-    jsdsrc->doingEval   = JS_FALSE;
+    jsdsrc->doingEval   = false;
 }    
 
 static JSBool
 _appendText(JSDContext* jsdc, JSDSourceText* jsdsrc, 
             const char* text, size_t length)
 {
 #define MEMBUF_GROW 1000
 
@@ -61,39 +61,39 @@ static JSBool
             /* try again with the minimal size really asked for */
             iNewSize = neededSize;
             newBuf = (char*) realloc(jsdsrc->text, iNewSize);
             if( ! newBuf )
             {
                 /* out of memory */
                 _clearText( jsdc, jsdsrc );
                 jsdsrc->status = JSD_SOURCE_FAILED;
-                return JS_FALSE;
+                return false;
             }
         }
 
         jsdsrc->text = newBuf;
         jsdsrc->textSpace = iNewSize;
     }
 
     memcpy(jsdsrc->text + jsdsrc->textLength, text, length);
     jsdsrc->textLength += length;
-    return JS_TRUE;
+    return true;
 }
 
 static JSDSourceText*
 _newSource(JSDContext* jsdc, char* url)
 {
     JSDSourceText* jsdsrc = (JSDSourceText*)calloc(1,sizeof(JSDSourceText));
     if( ! jsdsrc )
         return NULL;
     
     jsdsrc->url        = url;
     jsdsrc->status     = JSD_SOURCE_INITED;
-    jsdsrc->dirty      = JS_TRUE;
+    jsdsrc->dirty      = true;
     jsdsrc->alterCount = jsdc->sourceAlterCount++ ;
             
     return jsdsrc;
 }
 
 static void
 _destroySource(JSDContext* jsdc, JSDSourceText* jsdsrc)
 {
@@ -140,19 +140,19 @@ static JSBool
 {
     JSDSourceText *jsdsrc;
 
     for( jsdsrc = (JSDSourceText*)jsdc->sources.next;
          jsdsrc != (JSDSourceText*)&jsdc->sources;
          jsdsrc = (JSDSourceText*)jsdsrc->links.next ) 
     {
         if( jsdsrc == jsdsrcToFind )
-            return JS_TRUE;
+            return true;
     }
-    return JS_FALSE;
+    return false;
 }
 
 /*  compare strings in a case insensitive manner with a length limit
 */
 
 static int 
 strncasecomp (const char* one, const char * two, int n)
 {
@@ -256,17 +256,17 @@ jsd_GetSourceURL(JSDContext* jsdc, JSDSo
 }
 
 JSBool
 jsd_GetSourceText(JSDContext* jsdc, JSDSourceText* jsdsrc,
                   const char** ppBuf, int* pLen )
 {
     *ppBuf = jsdsrc->text;
     *pLen  = jsdsrc->textLength;
-    return JS_TRUE;
+    return true;
 }
 
 void
 jsd_ClearSourceText(JSDContext* jsdc, JSDSourceText* jsdsrc)
 {
     if( JSD_SOURCE_INITED  != jsdsrc->status &&
         JSD_SOURCE_PARTIAL != jsdsrc->status )
     {
@@ -389,25 +389,25 @@ jsd_AppendSourceText(JSDContext* jsdc,
     {
         _removeSourceFromRemovedList( jsdc, jsdsrc );
         JSD_UNLOCK_SOURCE_TEXT(jsdc);
         return NULL;
     }
 
     if( text && length && ! _appendText( jsdc, jsdsrc, text, length ) )
     {
-        jsdsrc->dirty  = JS_TRUE;
+        jsdsrc->dirty  = true;
         jsdsrc->alterCount  = jsdc->sourceAlterCount++ ;
         jsdsrc->status = JSD_SOURCE_FAILED;
         _moveSourceToRemovedList(jsdc, jsdsrc);
         JSD_UNLOCK_SOURCE_TEXT(jsdc);
         return NULL;    
     }
 
-    jsdsrc->dirty  = JS_TRUE;
+    jsdsrc->dirty  = true;
     jsdsrc->alterCount  = jsdc->sourceAlterCount++ ;
     jsdsrc->status = status;
     DEBUG_ITERATE_SOURCES(jsdc);
     JSD_UNLOCK_SOURCE_TEXT(jsdc);
     return jsdsrc;
 }
 
 JSDSourceText*
@@ -467,17 +467,17 @@ jsd_AddFullSourceText(JSDContext* jsdc,
         jsdsrc = jsd_AppendSourceText(jsdc, jsdsrc,
                                       text, length, JSD_SOURCE_PARTIAL );
     if( jsdsrc )
         jsdsrc = jsd_AppendSourceText(jsdc, jsdsrc,
                                       NULL, 0, JSD_SOURCE_COMPLETED );
 
     JSD_UNLOCK_SOURCE_TEXT(jsdc);
 
-    return jsdsrc ? JS_TRUE : JS_FALSE;
+    return jsdsrc ? true : false;
 }
 
 /***************************************************************************/
 
 void
 jsd_StartingEvalUsingFilename(JSDContext* jsdc, const char* url)
 {
     JSDSourceText* jsdsrc;
@@ -488,17 +488,17 @@ jsd_StartingEvalUsingFilename(JSDContext
     jsdsrc = jsd_FindSourceForURL(jsdc, url);
     if(jsdsrc)
     {
 #if 0
 #ifndef JSD_LOWLEVEL_SOURCE
         JS_ASSERT(! jsdsrc->doingEval);
 #endif
 #endif
-        jsdsrc->doingEval = JS_TRUE;
+        jsdsrc->doingEval = true;
     }
 }    
 
 void
 jsd_FinishedEvalUsingFilename(JSDContext* jsdc, const char* url)
 {
     JSDSourceText* jsdsrc;
 
@@ -512,13 +512,13 @@ jsd_FinishedEvalUsingFilename(JSDContext
         /*
         * when using this low level source addition, this jsdsrc might 
         * not have existed before the eval, but does exist now (without
         * this flag set!)
         */
         JS_ASSERT(jsdsrc->doingEval);
 #endif
 #endif
-        jsdsrc->doingEval = JS_FALSE;
+        jsdsrc->doingEval = false;
     }
 
     JSD_UNLOCK_SOURCE_TEXT(jsdc);
 }    
--- a/js/jsd/jsd_val.cpp
+++ b/js/jsd/jsd_val.cpp
@@ -124,34 +124,34 @@ jsd_IsValueNative(JSDContext* jsdc, JSDV
 {
     AutoSafeJSContext cx;
     JS::RootedFunction fun(cx);
 
     if(jsd_IsValueFunction(jsdc, jsdval))
     {
         JSAutoCompartment ac(cx, JSVAL_TO_OBJECT(jsdval->val));
         AutoSaveExceptionState as(cx);
-        JSBool ok = JS_FALSE;
+        JSBool ok = false;
         fun = JSD_GetValueFunction(jsdc, jsdval);
         if(fun)
-            ok = JS_GetFunctionScript(cx, fun) ? JS_FALSE : JS_TRUE;
+            ok = JS_GetFunctionScript(cx, fun) ? false : true;
         JS_ASSERT(fun);
         return ok;
     }
     return !JSVAL_IS_PRIMITIVE(jsdval->val);
 }
 
 /***************************************************************************/
 
 JSBool
 jsd_GetValueBoolean(JSDContext* jsdc, JSDValue* jsdval)
 {
     jsval val = jsdval->val;
     if(!JSVAL_IS_BOOLEAN(val))
-        return JS_FALSE;
+        return false;
     return JSVAL_TO_BOOLEAN(val);
 }
 
 int32_t
 jsd_GetValueInt(JSDContext* jsdc, JSDValue* jsdval)
 {
     jsval val = jsdval->val;
     if(!JSVAL_IS_INT(val))
@@ -249,17 +249,17 @@ jsd_NewValue(JSDContext* jsdc, jsval val
     if(JSVAL_IS_GCTHING(val))
     {
         JSBool ok;
         JSAutoCompartment ac(cx, jsdc->glob);
 
         ok = JS_AddNamedValueRoot(cx, &jsdval->val, "JSDValue");
         if(ok && JSVAL_IS_STRING(val)) {
             if(!JS_WrapValue(cx, val.address())) {
-                ok = JS_FALSE;
+                ok = false;
             }
         }
 
         if(!ok)
         {
             free(jsdval);
             return NULL;
         }
@@ -358,25 +358,25 @@ static JSBool _buildProps(JSDContext* js
     JSPropertyDescArray pda;
     unsigned i;
 
     JS_ASSERT(JS_CLIST_IS_EMPTY(&jsdval->props));
     JS_ASSERT(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PROPS)));
     JS_ASSERT(!JSVAL_IS_PRIMITIVE(jsdval->val));
 
     if(JSVAL_IS_PRIMITIVE(jsdval->val))
-        return JS_FALSE;
+        return false;
 
     obj = JSVAL_TO_OBJECT(jsdval->val);
 
     JSAutoCompartment ac(cx, obj);
 
     if(!JS_GetPropertyDescArray(cx, obj, &pda))
     {
-        return JS_FALSE;
+        return false;
     }
 
     for(i = 0; i < pda.length; i++)
     {
         JSDProperty* prop = _newProperty(jsdc, &pda.array[i], 0);
         if(!prop)
         {
             _freeProps(jsdc, jsdval);
--- a/js/jsd/jsd_xpc.cpp
+++ b/js/jsd/jsd_xpc.cpp
@@ -555,30 +555,30 @@ jsds_CallHookProc (JSDContext* jsdc, JSD
             gJsds->GetFunctionHook(getter_AddRefs(hook));
             break;
 
         default:
             NS_ASSERTION (0, "Unknown hook type.");
     }
     
     if (!hook)
-        return JS_TRUE;
+        return true;
 
     if (!jsds_FilterHook (jsdc, jsdthreadstate))
-        return JS_FALSE;
+        return false;
 
     JSDStackFrameInfo *native_frame = JSD_GetStackFrame (jsdc, jsdthreadstate);
     nsCOMPtr<jsdIStackFrame> frame =
         dont_AddRef(jsdStackFrame::FromPtr(jsdc, jsdthreadstate, native_frame));
     gJsds->DoPause(nullptr, true);
     hook->OnCall(frame, type);    
     gJsds->DoUnPause(nullptr, true);
     jsdStackFrame::InvalidateAll();
 
-    return JS_TRUE;
+    return true;
 }
 
 static uint32_t
 jsds_ExecutionHookProc (JSDContext* jsdc, JSDThreadState* jsdthreadstate,
                         unsigned type, void* callerdata, jsval* rval)
 {
     nsCOMPtr<jsdIExecutionHook> hook(0);
     uint32_t hook_rv = JSD_HOOK_RETURN_CONTINUE;
--- a/js/jsd/jsdebug.cpp
+++ b/js/jsd/jsdebug.cpp
@@ -33,17 +33,17 @@ JSD_DebuggerOff(JSDContext* jsdc)
     JSD_ASSERT_VALID_CONTEXT(jsdc);
     jsd_DebuggerOff(jsdc);
 }
 
 JSD_PUBLIC_API(void)
 JSD_DebuggerPause(JSDContext* jsdc)
 {
     JSD_ASSERT_VALID_CONTEXT(jsdc);
-    jsd_DebuggerPause(jsdc, JS_FALSE);
+    jsd_DebuggerPause(jsdc, false);
 }
 
 JSD_PUBLIC_API(void)
 JSD_DebuggerUnpause(JSDContext* jsdc)
 {
     JSD_ASSERT_VALID_CONTEXT(jsdc);
     jsd_DebuggerUnpause(jsdc);
 }
@@ -770,17 +770,17 @@ JSD_EvaluateUCScriptInStackFrame(JSDCont
 {
     JSD_ASSERT_VALID_CONTEXT(jsdc);
     JS_ASSERT(bytes);
     JS_ASSERT(length);
     JS_ASSERT(filename);
 
     return jsd_EvaluateUCScriptInStackFrame(jsdc, jsdthreadstate,jsdframe,
                                             bytes, length, filename, lineno,
-                                            JS_TRUE, rval);
+                                            true, rval);
 }
 
 JSD_PUBLIC_API(JSBool)
 JSD_AttemptUCScriptInStackFrame(JSDContext* jsdc,
                                 JSDThreadState* jsdthreadstate,
                                 JSDStackFrameInfo* jsdframe,
                                 const jschar *bytes, unsigned length,
                                 const char *filename, unsigned lineno,
@@ -788,51 +788,51 @@ JSD_AttemptUCScriptInStackFrame(JSDConte
 {
     JSD_ASSERT_VALID_CONTEXT(jsdc);
     JS_ASSERT(bytes);
     JS_ASSERT(length);
     JS_ASSERT(filename);
 
     return jsd_EvaluateUCScriptInStackFrame(jsdc, jsdthreadstate,jsdframe,
                                             bytes, length, filename, lineno,
-                                            JS_FALSE, rval);
+                                            false, rval);
 }
 
 JSD_PUBLIC_API(JSBool)
 JSD_EvaluateScriptInStackFrame(JSDContext* jsdc,
                                JSDThreadState* jsdthreadstate,
                                JSDStackFrameInfo* jsdframe,
                                const char *bytes, unsigned length,
                                const char *filename, unsigned lineno, JS::MutableHandleValue rval)
 {
     JSD_ASSERT_VALID_CONTEXT(jsdc);
     JS_ASSERT(bytes);
     JS_ASSERT(length);
     JS_ASSERT(filename);
 
     return jsd_EvaluateScriptInStackFrame(jsdc, jsdthreadstate,jsdframe,
                                           bytes, length,
-                                          filename, lineno, JS_TRUE, rval);
+                                          filename, lineno, true, rval);
 }
 
 JSD_PUBLIC_API(JSBool)
 JSD_AttemptScriptInStackFrame(JSDContext* jsdc,
                               JSDThreadState* jsdthreadstate,
                               JSDStackFrameInfo* jsdframe,
                               const char *bytes, unsigned length,
                               const char *filename, unsigned lineno, JS::MutableHandleValue rval)
 {
     JSD_ASSERT_VALID_CONTEXT(jsdc);
     JS_ASSERT(bytes);
     JS_ASSERT(length);
     JS_ASSERT(filename);
 
     return jsd_EvaluateScriptInStackFrame(jsdc, jsdthreadstate,jsdframe,
                                           bytes, length,
-                                          filename, lineno, JS_FALSE, rval);
+                                          filename, lineno, false, rval);
 }
 
 JSD_PUBLIC_API(JSString*)
 JSD_ValToStringInStackFrame(JSDContext* jsdc,
                             JSDThreadState* jsdthreadstate,
                             JSDStackFrameInfo* jsdframe,
                             jsval val)
 {
@@ -876,19 +876,19 @@ JSD_GetErrorReporter(JSDContext*        
 }
 
 /***************************************************************************/
 
 JSD_PUBLIC_API(JSBool)
 JSD_IsLockingAndThreadIdSupported()
 {
 #ifdef JSD_THREADSAFE
-    return JS_TRUE;
+    return true;
 #else
-    return JS_FALSE;
+    return false;
 #endif
 }
 
 JSD_PUBLIC_API(JSDStaticLock*)
 JSD_CreateLock()
 {
 #ifdef JSD_THREADSAFE
     return jsd_CreateLock();
@@ -914,27 +914,27 @@ JSD_Unlock(JSDStaticLock* lock)
 }
 
 JSD_PUBLIC_API(JSBool)
 JSD_IsLocked(JSDStaticLock* lock)
 {
 #if defined(JSD_THREADSAFE) && defined(DEBUG)
     return jsd_IsLocked(lock);
 #else
-    return JS_TRUE;
+    return true;
 #endif
 }
 
 JSD_PUBLIC_API(JSBool)
 JSD_IsUnlocked(JSDStaticLock* lock)
 {
 #if defined(JSD_THREADSAFE) && defined(DEBUG)
     return ! jsd_IsLocked(lock);
 #else
-    return JS_TRUE;
+    return true;
 #endif
 }
 
 JSD_PUBLIC_API(void*)
 JSD_CurrentThread()
 {
     return JSD_CURRENT_THREAD();
 }
--- a/js/jsd/jsdebug.h
+++ b/js/jsd/jsdebug.h
@@ -413,17 +413,17 @@ JSD_GetScriptBaseLineNumber(JSDContext* 
 /*
 * Get the count of source lines associated with this script (1 or greater)
 */
 extern JSD_PUBLIC_API(unsigned)
 JSD_GetScriptLineExtent(JSDContext* jsdc, JSDScript *jsdscript);
 
 /*
 * Declaration of callback for notification of script creation and destruction.
-* 'creating' is JS_TRUE if creating new script, JS_FALSE if destroying existing
+* 'creating' is true if creating new script, false if destroying existing
 * script (callback called just before actual destruction).
 * 'callerdata' is what was passed to JSD_SetScriptHook to set the hook.
 */
 typedef void
 (* JSD_ScriptHookProc)(JSDContext* jsdc,
                        JSDScript*  jsdscript,
                        JSBool      creating,
                        void*       callerdata);
@@ -678,17 +678,17 @@ JSD_AppendUCSourceText(JSDContext*     j
  *   jsdsrc = jsd_NewSourceText(jsdc, url);
  *   if(jsdsrc)
  *       jsdsrc = jsd_AppendSourceText(jsdc, jsdsrc,
  *                                     text, length, JSD_SOURCE_PARTIAL);
  *   if(jsdsrc)
  *       jsdsrc = jsd_AppendSourceText(jsdc, jsdsrc,
  *                                     NULL, 0, JSD_SOURCE_COMPLETED);
  *   JSD_UNLOCK_SOURCE_TEXT(jsdc);
- *   return jsdsrc ? JS_TRUE : JS_FALSE;
+ *   return jsdsrc ? true : false;
  */
 extern JSD_PUBLIC_API(JSBool)
 JSD_AddFullSourceText(JSDContext* jsdc,
                       const char* text,       /* *not* zero terminated */
                       size_t      length,
                       const char* url);
 
 /***************************************************************************/
@@ -722,17 +722,17 @@ typedef unsigned
 /* possible 'type' params for JSD_CallHookProc */
 #define JSD_HOOK_TOPLEVEL_START  0   /* about to evaluate top level script */
 #define JSD_HOOK_TOPLEVEL_END    1   /* done evaluting top level script    */
 #define JSD_HOOK_FUNCTION_CALL   2   /* about to call a function           */
 #define JSD_HOOK_FUNCTION_RETURN 3   /* done calling function              */
 
 /*
 * Implement a callback of this form in order to hook function call/returns.
-* Return JS_TRUE from a TOPLEVEL_START or FUNCTION_CALL type call hook if you
+* Return true from a TOPLEVEL_START or FUNCTION_CALL type call hook if you
 * want to hear about the TOPLEVEL_END or FUNCTION_RETURN too.  Return value is
 * ignored to TOPLEVEL_END and FUNCTION_RETURN type hooks.
 */
 typedef JSBool
 (* JSD_CallHookProc)(JSDContext*     jsdc,
                      JSDThreadState* jsdthreadstate,
                      unsigned           type,
                      void*           callerdata);
@@ -960,17 +960,17 @@ JSD_IsStackFrameDebugger(JSDContext* jsd
 */
 extern JSD_PUBLIC_API(JSBool)
 JSD_IsStackFrameConstructing(JSDContext* jsdc,
                              JSDThreadState* jsdthreadstate,
                              JSDStackFrameInfo* jsdframe);
 
 /*
 * Evaluate the given unicode source code in the context of the given stack frame.
-* returns JS_TRUE and puts result in rval on success, JS_FALSE on failure.
+* returns true and puts result in rval on success, false on failure.
 * NOTE: The ErrorReporter hook might be called if this fails.
 */
 extern JSD_PUBLIC_API(JSBool)
 JSD_EvaluateUCScriptInStackFrame(JSDContext* jsdc,
                                  JSDThreadState* jsdthreadstate,
                                  JSDStackFrameInfo* jsdframe,
                                  const jschar *bytes, unsigned length,
                                  const char *filename, unsigned lineno,
@@ -1094,17 +1094,17 @@ JSD_Lock(JSDStaticLock* lock);
 /*
 * Release lock for this thread (or decrement the counter if JSD_Lock
 * was previous called more than once).
 */
 extern JSD_PUBLIC_API(void)
 JSD_Unlock(JSDStaticLock* lock);
 
 /*
-* For debugging only if not (JS_THREADSAFE AND DEBUG) then returns JS_TRUE
+* For debugging only if not (JS_THREADSAFE AND DEBUG) then returns true
 *    So JSD_IsLocked(lock) may not equal !JSD_IsUnlocked(lock)
 */
 extern JSD_PUBLIC_API(JSBool)
 JSD_IsLocked(JSDStaticLock* lock);
 
 /*
 * See above...
 */
@@ -1359,17 +1359,17 @@ JSD_GetScriptForValue(JSDContext* jsdc, 
  * XXX these must stay the same as the JSPD_ flags in jsdbgapi.h
  */
 #define JSDPD_ENUMERATE  JSPD_ENUMERATE    /* visible to for/in loop */
 #define JSDPD_READONLY   JSPD_READONLY     /* assignment is error */
 #define JSDPD_PERMANENT  JSPD_PERMANENT    /* property cannot be deleted */
 #define JSDPD_ALIAS      JSPD_ALIAS        /* property has an alias id */
 #define JSDPD_EXCEPTION  JSPD_EXCEPTION    /* exception occurred looking up */
                                            /* proprety, value is exception  */
-#define JSDPD_ERROR      JSPD_ERROR        /* native getter returned JS_FALSE */
+#define JSDPD_ERROR      JSPD_ERROR        /* native getter returned false */
                                            /* without throwing an exception */
 /* this is not one of the JSPD_ flags in jsdbgapi.h  - careful not to overlap*/
 #define JSDPD_HINTED     0x800             /* found via explicit lookup */
 
 /*
 * Release this JSDProperty
 * *** new for version 1.1 ****
 */
--- a/js/jsd/jshash.cpp
+++ b/js/jsd/jshash.cpp
@@ -174,24 +174,24 @@ Resize(JSHashTable *ht, uint32_t newshif
     size_t nold = NBUCKETS(ht);
 
     JS_ASSERT(newshift < JS_HASH_BITS);
 
     nb = (size_t)1 << (JS_HASH_BITS - newshift);
 
     /* Integer overflow protection. */
     if (nb > (size_t)-1 / sizeof(JSHashEntry*))
-        return JS_FALSE;
+        return false;
     nb *= sizeof(JSHashEntry*);
 
     oldbuckets = ht->buckets;
     ht->buckets = (JSHashEntry**)ht->allocOps->allocTable(ht->allocPriv, nb);
     if (!ht->buckets) {
         ht->buckets = oldbuckets;
-        return JS_FALSE;
+        return false;
     }
     memset(ht->buckets, 0, nb);
 
     ht->shift = newshift;
     nentries = ht->nentries;
 
     for (i = 0; nentries != 0; i++) {
         for (he = oldbuckets[i]; he; he = next) {
@@ -210,17 +210,17 @@ Resize(JSHashTable *ht, uint32_t newshif
             *hep = he;
         }
     }
 #ifdef DEBUG
     memset(oldbuckets, 0xDB, nold * sizeof oldbuckets[0]);
 #endif
     ht->allocOps->freeTable(ht->allocPriv, oldbuckets,
                             nold * sizeof oldbuckets[0]);
-    return JS_TRUE;
+    return true;
 }
 
 JSHashEntry *
 JS_HashTableRawAdd(JSHashTable *ht, JSHashEntry **&hep,
                    JSHashNumber keyHash, const void *key, void *value)
 {
     uint32_t n;
     JSHashEntry *he;
@@ -293,21 +293,21 @@ JSBool
 JS_HashTableRemove(JSHashTable *ht, const void *key)
 {
     JSHashNumber keyHash;
     JSHashEntry *he, **hep;
 
     keyHash = ht->keyHash(key);
     hep = JS_HashTableRawLookup(ht, keyHash, key);
     if ((he = *hep) == NULL)
-        return JS_FALSE;
+        return false;
 
     /* Hit; remove element */
     JS_HashTableRawRemove(ht, hep, he);
-    return JS_TRUE;
+    return true;
 }
 
 void *
 JS_HashTableLookup(JSHashTable *ht, const void *key)
 {
     JSHashNumber keyHash;
     JSHashEntry *he, **hep;
 
--- a/js/public/Value.h
+++ b/js/public/Value.h
@@ -432,17 +432,17 @@ JSVAL_TO_BOOLEAN_IMPL(jsval_layout l)
 {
     return l.s.payload.boo;
 }
 
 static inline jsval_layout
 BOOLEAN_TO_JSVAL_IMPL(JSBool b)
 {
     jsval_layout l;
-    MOZ_ASSERT(b == JS_TRUE || b == JS_FALSE);
+    MOZ_ASSERT(b == JS_TRUE_DEPRECATED || b == JS_FALSE_DEPRECATED);
     l.s.tag = JSVAL_TAG_BOOLEAN;
     l.s.payload.boo = b;
     return l;
 }
 
 static inline JSBool
 JSVAL_IS_MAGIC_IMPL(jsval_layout l)
 {
@@ -659,17 +659,17 @@ JSVAL_TO_BOOLEAN_IMPL(jsval_layout l)
 {
     return (JSBool)l.asBits;
 }
 
 static inline jsval_layout
 BOOLEAN_TO_JSVAL_IMPL(JSBool b)
 {
     jsval_layout l;
-    MOZ_ASSERT(b == JS_TRUE || b == JS_FALSE);
+    MOZ_ASSERT(b == JS_TRUE_DEPRECATED || b == JS_FALSE_DEPRECATED);
     l.asBits = ((uint64_t)(uint32_t)b) | JSVAL_SHIFTED_TAG_BOOLEAN;
     return l;
 }
 
 static inline JSBool
 JSVAL_IS_MAGIC_IMPL(jsval_layout l)
 {
     return (l.asBits >> JSVAL_TAG_SHIFT) == JSVAL_TAG_MAGIC;
--- a/js/src/builtin/Profilers.cpp
+++ b/js/src/builtin/Profilers.cpp
@@ -72,54 +72,54 @@ StartOSXProfiling(const char *profileNam
     }
     return true;
 }
 #endif
 
 JS_PUBLIC_API(JSBool)
 JS_StartProfiling(const char *profileName)
 {
-    JSBool ok = JS_TRUE;
+    JSBool ok = true;
 #ifdef __APPLE__
     ok = StartOSXProfiling(profileName);
 #endif
 #ifdef __linux__
     if (!js_StartPerf())
-        ok = JS_FALSE;
+        ok = false;
 #endif
     return ok;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_StopProfiling(const char *profileName)
 {
-    JSBool ok = JS_TRUE;
+    JSBool ok = true;
 #ifdef __APPLE__
 #ifdef MOZ_SHARK
     Shark::Stop();
 #endif
 #ifdef MOZ_INSTRUMENTS
     Instruments::Stop(profileName);
 #endif
 #endif
 #ifdef __linux__
     if (!js_StopPerf())
-        ok = JS_FALSE;
+        ok = false;
 #endif
     return ok;
 }
 
 /*
  * Start or stop whatever platform- and configuration-specific profiling
  * backends are available.
  */
 static JSBool
 ControlProfilers(bool toState)
 {
-    JSBool ok = JS_TRUE;
+    JSBool ok = true;
 
     if (! Probes::ProfilingActive && toState) {
 #ifdef __APPLE__
 #if defined(MOZ_SHARK) || defined(MOZ_INSTRUMENTS)
         const char* profiler;
 #ifdef MOZ_SHARK
         ok = Shark::Start();
         profiler = "Shark";
@@ -131,32 +131,32 @@ ControlProfilers(bool toState)
         if (!ok) {
             UnsafeError("Failed to start %s", profiler);
         }
 #endif
 #endif
 #ifdef MOZ_CALLGRIND
         if (! js_StartCallgrind()) {
             UnsafeError("Failed to start Callgrind");
-            ok = JS_FALSE;
+            ok = false;
         }
 #endif
     } else if (Probes::ProfilingActive && ! toState) {
 #ifdef __APPLE__
 #ifdef MOZ_SHARK
         Shark::Stop();
 #endif
 #ifdef MOZ_INSTRUMENTS
         Instruments::Pause();
 #endif
 #endif
 #ifdef MOZ_CALLGRIND
         if (! js_StopCallgrind()) {
             UnsafeError("failed to stop Callgrind");
-            ok = JS_FALSE;
+            ok = false;
         }
 #endif
     }
 
     Probes::ProfilingActive = toState;
 
     return ok;
 }
@@ -179,17 +179,17 @@ JS_PUBLIC_API(JSBool)
 JS_ResumeProfilers(const char *profileName)
 {
     return ControlProfilers(true);
 }
 
 JS_PUBLIC_API(JSBool)
 JS_DumpProfile(const char *outfile, const char *profileName)
 {
-    JSBool ok = JS_TRUE;
+    JSBool ok = true;
 #ifdef MOZ_CALLGRIND
     js_DumpCallgrind(outfile);
 #endif
     return ok;
 }
 
 #ifdef MOZ_PROFILING
 
--- a/js/src/ctypes/CTypes.cpp
+++ b/js/src/ctypes/CTypes.cpp
@@ -1532,17 +1532,17 @@ static JS_ALWAYS_INLINE bool IsNegative(
 }
 
 // Implicitly convert val to bool, allowing JSBool, int, and double
 // arguments numerically equal to 0 or 1.
 static bool
 jsvalToBool(JSContext* cx, jsval val, bool* result)
 {
   if (JSVAL_IS_BOOLEAN(val)) {
-    *result = JSVAL_TO_BOOLEAN(val) != JS_FALSE;
+    *result = JSVAL_TO_BOOLEAN(val);
     return true;
   }
   if (JSVAL_IS_INT(val)) {
     int32_t i = JSVAL_TO_INT(val);
     *result = i != 0;
     return i == 0 || i == 1;
   }
   if (JSVAL_IS_DOUBLE(val)) {
@@ -2221,17 +2221,17 @@ ImplicitConvert(JSContext* cx,
       sourceType = CDataFinalizer::GetCType(cx, sourceData);
 
       CDataFinalizer::Private *p = (CDataFinalizer::Private *)
         JS_GetPrivate(sourceData);
 
       if (!p) {
         // We have called |dispose| or |forget| already.
         JS_ReportError(cx, "Attempting to convert an empty CDataFinalizer");
-        return JS_FALSE;
+        return false;
       }
 
       // If the types are equal, copy the buffer contained within the CData.
       if (CType::TypesEqual(sourceType, targetType)) {
         memmove(buffer, p->cargs, p->cargs_size);
         return true;
       }
     }
@@ -2598,17 +2598,17 @@ ExplicitConvert(JSContext* cx, HandleVal
 
   TypeCode type = CType::GetTypeCode(targetType);
 
   switch (type) {
   case TYPE_bool: {
     // Convert according to the ECMAScript ToBoolean() function.
     JSBool result;
     ASSERT_OK(JS_ValueToBoolean(cx, val, &result));
-    *static_cast<bool*>(buffer) = result != JS_FALSE;
+    *static_cast<bool*>(buffer) = result != false;
     break;
   }
 #define DEFINE_INT_TYPE(name, type, ffiType)                                   \
   case TYPE_##name: {                                                          \
     /* Convert numeric values with a C-style cast, and */                      \
     /* allow conversion from a base-10 or base-16 string. */                   \
     type result;                                                               \
     if (!jsvalToIntegerExplicit(val, &result) &&                               \
@@ -3118,31 +3118,31 @@ CType::ConstructData(JSContext* cx,
 
 JSBool
 CType::ConstructBasic(JSContext* cx,
                       HandleObject obj,
                       const CallArgs& args)
 {
   if (args.length() > 1) {
     JS_ReportError(cx, "CType constructor takes zero or one argument");
-    return JS_FALSE;
+    return false;
   }
 
   // construct a CData object
   RootedObject result(cx, CData::Create(cx, obj, NullPtr(), NULL, true));
   if (!result)
-    return JS_FALSE;
+    return false;
 
   if (args.length() == 1) {
     if (!ExplicitConvert(cx, args[0], obj, CData::GetData(result)))
-      return JS_FALSE;
+      return false;
   }
 
   args.rval().setObject(*result);
-  return JS_TRUE;
+  return true;
 }
 
 JSObject*
 CType::Create(JSContext* cx,
               HandleObject typeProto,
               HandleObject dataProto,
               TypeCode type,
               JSString* name_,
@@ -3591,69 +3591,69 @@ CType::GetProtoFromType(JSContext* cx, J
   return JSVAL_TO_OBJECT(result);
 }
 
 JSBool
 CType::PrototypeGetter(JSContext* cx, HandleObject obj, HandleId idval, MutableHandleValue vp)
 {
   if (!(CType::IsCType(obj) || CType::IsCTypeProto(obj))) {
     JS_ReportError(cx, "not a CType or CTypeProto");
-    return JS_FALSE;
+    return false;
   }
 
   unsigned slot = CType::IsCTypeProto(obj) ? (unsigned) SLOT_OURDATAPROTO
                                            : (unsigned) SLOT_PROTO;
   vp.set(JS_GetReservedSlot(obj, slot));
   JS_ASSERT(!JSVAL_IS_PRIMITIVE(vp) || JSVAL_IS_VOID(vp));
-  return JS_TRUE;
+  return true;
 }
 
 JSBool
 CType::NameGetter(JSContext* cx, HandleObject obj, HandleId idval, MutableHandleValue vp)
 {
   if (!CType::IsCType(obj)) {
     JS_ReportError(cx, "not a CType");
-    return JS_FALSE;
+    return false;
   }
 
   JSString* name = CType::GetName(cx, obj);
   if (!name)
-    return JS_FALSE;
+    return false;
 
   vp.setString(name);
-  return JS_TRUE;
+  return true;
 }
 
 JSBool
 CType::SizeGetter(JSContext* cx, HandleObject obj, HandleId idval, MutableHandleValue vp)
 {
   if (!CType::IsCType(obj)) {
     JS_ReportError(cx, "not a CType");
-    return JS_FALSE;
+    return false;
   }
 
   vp.set(JS_GetReservedSlot(obj, SLOT_SIZE));
   JS_ASSERT(JSVAL_IS_NUMBER(vp) || JSVAL_IS_VOID(vp));
-  return JS_TRUE;
+  return true;
 }
 
 JSBool
 CType::PtrGetter(JSContext* cx, HandleObject obj, HandleId idval, MutableHandleValue vp)
 {
   if (!CType::IsCType(obj)) {
     JS_ReportError(cx, "not a CType");
-    return JS_FALSE;
+    return false;
   }
 
   JSObject* pointerType = PointerType::CreateInternal(cx, obj);
   if (!pointerType)
-    return JS_FALSE;
+    return false;
 
   vp.setObject(*pointerType);
-  return JS_TRUE;
+  return true;
 }
 
 bool
 CType::CreateArray(JSContext* cx, unsigned argc, jsval* vp)
 {
   CallArgs args = CallArgsFromVp(argc, vp);
   RootedObject baseType(cx, JS_THIS_OBJECT(cx, vp));
   if (!baseType)
@@ -3750,32 +3750,32 @@ CType::HasInstance(JSContext* cx, Handle
 {
   JS_ASSERT(CType::IsCType(obj));
 
   jsval slot = JS_GetReservedSlot(obj, SLOT_PROTO);
   JS::Rooted<JSObject*> prototype(cx, &slot.toObject());
   JS_ASSERT(prototype);
   JS_ASSERT(CData::IsCDataProto(prototype));
 
-  *bp = JS_FALSE;
+  *bp = false;
   if (JSVAL_IS_PRIMITIVE(v))
-    return JS_TRUE;
+    return true;
 
   RootedObject proto(cx, &v.toObject());
   for (;;) {
     if (!JS_GetPrototype(cx, proto, &proto))
-      return JS_FALSE;
+      return false;
     if (!proto)
       break;
     if (proto == prototype) {
-      *bp = JS_TRUE;
+      *bp = true;
       break;
     }
   }
-  return JS_TRUE;
+  return true;
 }
 
 static JSObject*
 CType::GetGlobalCTypes(JSContext* cx, JSObject* objArg)
 {
   JS_ASSERT(CType::IsCType(objArg));
 
   RootedObject obj(cx, objArg);
@@ -3909,58 +3909,58 @@ PointerType::CreateInternal(JSContext* c
 
 JSBool
 PointerType::ConstructData(JSContext* cx,
                            HandleObject obj,
                            const CallArgs& args)
 {
   if (!CType::IsCType(obj) || CType::GetTypeCode(obj) != TYPE_pointer) {
     JS_ReportError(cx, "not a PointerType");
-    return JS_FALSE;
+    return false;
   }
 
   if (args.length() > 3) {
     JS_ReportError(cx, "constructor takes 0, 1, 2, or 3 arguments");
-    return JS_FALSE;
+    return false;
   }
 
   RootedObject result(cx, CData::Create(cx, obj, NullPtr(), NULL, true));
   if (!result)
-    return JS_FALSE;
+    return false;
 
   // Set return value early, must not observe *vp after
   args.rval().setObject(*result);
 
   // There are 3 things that we might be creating here:
   // 1 - A null pointer (no arguments)
   // 2 - An initialized pointer (1 argument)
   // 3 - A closure (1-3 arguments)
   //
   // The API doesn't give us a perfect way to distinguish 2 and 3, but the
   // heuristics we use should be fine.
 
   //
   // Case 1 - Null pointer
   //
   if (args.length() == 0)
-    return JS_TRUE;
+    return true;
 
   // Analyze the arguments a bit to decide what to do next.
   RootedObject baseObj(cx, PointerType::GetBaseType(obj));
   bool looksLikeClosure = CType::GetTypeCode(baseObj) == TYPE_function &&
                           args[0].isObject() &&
                           JS_ObjectIsCallable(cx, &args[0].toObject());
 
   //
   // Case 2 - Initialized pointer
   //
   if (!looksLikeClosure) {
     if (args.length() != 1) {
       JS_ReportError(cx, "first argument must be a function");
-      return JS_FALSE;
+      return false;
     }
     return ExplicitConvert(cx, args[0], obj, CData::GetData(result));
   }
 
   //
   // Case 3 - Closure
   //
 
@@ -3969,17 +3969,17 @@ PointerType::ConstructData(JSContext* cx
   // wish to pass the third argument.
   RootedObject thisObj(cx, NULL);
   if (args.length() >= 2) {
     if (args[1].isNull()) {
       thisObj = NULL;
     } else if (!JSVAL_IS_PRIMITIVE(args[1])) {
       thisObj = &args[1].toObject();
     } else if (!JS_ValueToObject(cx, args[1], thisObj.address())) {
-      return JS_FALSE;
+      return false;
     }
   }
 
   // The third argument is an optional error sentinel that js-ctypes will return
   // if an exception is raised while executing the closure. The type must match
   // the return type of the callback.
   jsval errVal = JSVAL_VOID;
   if (args.length() == 3)
@@ -4002,22 +4002,22 @@ PointerType::GetBaseType(JSObject* obj)
 JSBool
 PointerType::TargetTypeGetter(JSContext* cx,
                               HandleObject obj,
                               HandleId idval,
                               MutableHandleValue vp)
 {
   if (!CType::IsCType(obj) || CType::GetTypeCode(obj) != TYPE_pointer) {
     JS_ReportError(cx, "not a PointerType");
-    return JS_FALSE;
+    return false;
   }
 
   vp.set(JS_GetReservedSlot(obj, SLOT_TARGET_T));
   JS_ASSERT(vp.isObject());
-  return JS_TRUE;
+  return true;
 }
 
 bool
 PointerType::IsNull(JSContext* cx, unsigned argc, jsval* vp)
 {
   CallArgs args = CallArgsFromVp(argc, vp);
   JSObject* obj = JS_THIS_OBJECT(cx, vp);
   if (!obj)
@@ -4039,45 +4039,45 @@ PointerType::IsNull(JSContext* cx, unsig
   return true;
 }
 
 JSBool
 PointerType::OffsetBy(JSContext* cx, const CallArgs& args, int offset)
 {
   JSObject* obj = JS_THIS_OBJECT(cx, args.base());
   if (!obj)
-    return JS_FALSE;
+    return false;
   if (!CData::IsCData(obj)) {
     JS_ReportError(cx, "not a CData");
-    return JS_FALSE;
+    return false;
   }
 
   RootedObject typeObj(cx, CData::GetCType(obj));
   if (CType::GetTypeCode(typeObj) != TYPE_pointer) {
     JS_ReportError(cx, "not a PointerType");
-    return JS_FALSE;
+    return false;
   }
 
   RootedObject baseType(cx, PointerType::GetBaseType(typeObj));
   if (!CType::IsSizeDefined(baseType)) {
     JS_ReportError(cx, "cannot modify pointer of undefined size");
-    return JS_FALSE;
+    return false;
   }
 
   size_t elementSize = CType::GetSize(baseType);
   char* data = static_cast<char*>(*static_cast<void**>(CData::GetData(obj)));
   void* address = data + offset * elementSize;
 
   // Create a PointerType CData object containing the new address.
   JSObject* result = CData::Create(cx, typeObj, NullPtr(), &address, true);
   if (!result)
-    return JS_FALSE;
+    return false;
 
   args.rval().setObject(*result);
-  return JS_TRUE;
+  return true;
 }
 
 bool
 PointerType::Increment(JSContext* cx, unsigned argc, jsval* vp)
 {
   CallArgs args = CallArgsFromVp(argc, vp);
   return OffsetBy(cx, args, 1);
 }
@@ -4092,75 +4092,75 @@ PointerType::Decrement(JSContext* cx, un
 JSBool
 PointerType::ContentsGetter(JSContext* cx,
                             HandleObject obj,
                             HandleId idval,
                             MutableHandleValue vp)
 {
   if (!CData::IsCData(obj)) {
     JS_ReportError(cx, "not a CData");
-    return JS_FALSE;
+    return false;
   }
 
   // Get pointer type and base type.
   JSObject* typeObj = CData::GetCType(obj);
   if (CType::GetTypeCode(typeObj) != TYPE_pointer) {
     JS_ReportError(cx, "not a PointerType");
-    return JS_FALSE;
+    return false;
   }
 
   RootedObject baseType(cx, GetBaseType(typeObj));
   if (!CType::IsSizeDefined(baseType)) {
     JS_ReportError(cx, "cannot get contents of undefined size");
-    return JS_FALSE;
+    return false;
   }
 
   void* data = *static_cast<void**>(CData::GetData(obj));
   if (data == NULL) {
     JS_ReportError(cx, "cannot read contents of null pointer");
-    return JS_FALSE;
+    return false;
   }
 
   RootedValue result(cx);
   if (!ConvertToJS(cx, baseType, NullPtr(), data, false, false, result.address()))
-    return JS_FALSE;
+    return false;
 
   vp.set(result);
-  return JS_TRUE;
+  return true;
 }
 
 JSBool
 PointerType::ContentsSetter(JSContext* cx,
                             HandleObject obj,
                             HandleId idval,
                             JSBool strict,
                             MutableHandleValue vp)
 {
   if (!CData::IsCData(obj)) {
     JS_ReportError(cx, "not a CData");
-    return JS_FALSE;
+    return false;
   }
 
   // Get pointer type and base type.
   JSObject* typeObj = CData::GetCType(obj);
   if (CType::GetTypeCode(typeObj) != TYPE_pointer) {
     JS_ReportError(cx, "not a PointerType");
-    return JS_FALSE;
+    return false;
   }
 
   JSObject* baseType = GetBaseType(typeObj);
   if (!CType::IsSizeDefined(baseType)) {
     JS_ReportError(cx, "cannot set contents of undefined size");
-    return JS_FALSE;
+    return false;
   }
 
   void* data = *static_cast<void**>(CData::GetData(obj));
   if (data == NULL) {
     JS_ReportError(cx, "cannot write contents to null pointer");
-    return JS_FALSE;
+    return false;
   }
 
   return ImplicitConvert(cx, vp, baseType, data, false, NULL);
 }
 
 /*******************************************************************************
 ** ArrayType implementation
 *******************************************************************************/
@@ -4256,35 +4256,35 @@ JSBool
 ArrayType::ConstructData(JSContext* cx,
                          HandleObject obj_,
                          const CallArgs& args)
 {
   RootedObject obj(cx, obj_); // Make a mutable version
 
   if (!CType::IsCType(obj) || CType::GetTypeCode(obj) != TYPE_array) {
     JS_ReportError(cx, "not an ArrayType");
-    return JS_FALSE;
+    return false;
   }
 
   // Decide whether we have an object to initialize from. We'll override this
   // if we get a length argument instead.
   bool convertObject = args.length() == 1;
 
   // Check if we're an array of undefined length. If we are, allow construction
   // with a length argument, or with an actual JS array.
   if (CType::IsSizeDefined(obj)) {
     if (args.length() > 1) {
       JS_ReportError(cx, "constructor takes zero or one argument");
-      return JS_FALSE;
+      return false;
     }
 
   } else {
     if (args.length() != 1) {
       JS_ReportError(cx, "constructor takes one argument");
-      return JS_FALSE;
+      return false;
     }
 
     RootedObject baseType(cx, GetBaseType(obj));
 
     size_t length;
     if (jsvalToSize(cx, args[0], false, &length)) {
       // Have a length, rather than an object to initialize from.
       convertObject = false;
@@ -4292,17 +4292,17 @@ ArrayType::ConstructData(JSContext* cx,
     } else if (!JSVAL_IS_PRIMITIVE(args[0])) {
       // We were given an object with a .length property.
       // This could be a JS array, or a CData array.
       RootedObject arg(cx, &args[0].toObject());
       RootedValue lengthVal(cx);
       if (!JS_GetProperty(cx, arg, "length", &lengthVal) ||
           !jsvalToSize(cx, lengthVal, false, &length)) {
         JS_ReportError(cx, "argument must be an array object or length");
-        return JS_FALSE;
+        return false;
       }
 
     } else if (args[0].isString()) {
       // We were given a string. Size the array to the appropriate length,
       // including space for the terminator.
       JSString* sourceString = args[0].toString();
       size_t sourceLength = sourceString->length();
       const jschar* sourceChars = sourceString->getChars(cx);
@@ -4325,37 +4325,37 @@ ArrayType::ConstructData(JSContext* cx,
         length = sourceLength + 1;
         break;
       default:
         return TypeError(cx, "array", args[0]);
       }
 
     } else {
       JS_ReportError(cx, "argument must be an array object or length");
-      return JS_FALSE;
+      return false;
     }
 
     // Construct a new ArrayType of defined length, for the new CData object.
     obj = CreateInternal(cx, baseType, length, true);
     if (!obj)
-      return JS_FALSE;
+      return false;
   }
 
   JSObject* result = CData::Create(cx, obj, NullPtr(), NULL, true);
   if (!result)
-    return JS_FALSE;
+    return false;
 
   args.rval().setObject(*result);
 
   if (convertObject) {
     if (!ExplicitConvert(cx, args[0], obj, CData::GetData(result)))
-      return JS_FALSE;
-  }
-
-  return JS_TRUE;
+      return false;
+  }
+
+  return true;
 }
 
 JSObject*
 ArrayType::GetBaseType(JSObject* obj)
 {
   JS_ASSERT(CType::IsCType(obj));
   JS_ASSERT(CType::GetTypeCode(obj) == TYPE_array);
 
@@ -4448,108 +4448,108 @@ ArrayType::BuildFFIType(JSContext* cx, J
   return ffiType.forget();
 }
 
 JSBool
 ArrayType::ElementTypeGetter(JSContext* cx, HandleObject obj, HandleId idval, MutableHandleValue vp)
 {
   if (!CType::IsCType(obj) || CType::GetTypeCode(obj) != TYPE_array) {
     JS_ReportError(cx, "not an ArrayType");
-    return JS_FALSE;
+    return false;
   }
 
   vp.set(JS_GetReservedSlot(obj, SLOT_ELEMENT_T));
   JS_ASSERT(!JSVAL_IS_PRIMITIVE(vp));
-  return JS_TRUE;
+  return true;
 }
 
 JSBool
 ArrayType::LengthGetter(JSContext* cx, HandleObject obj_, HandleId idval, MutableHandleValue vp)
 {
   JSObject *obj = obj_;
 
   // This getter exists for both CTypes and CDatas of the ArrayType persuasion.
   // If we're dealing with a CData, get the CType from it.
   if (CData::IsCData(obj))
     obj = CData::GetCType(obj);
 
   if (!CType::IsCType(obj) || CType::GetTypeCode(obj) != TYPE_array) {
     JS_ReportError(cx, "not an ArrayType");
-    return JS_FALSE;
+    return false;
   }
 
   vp.set(JS_GetReservedSlot(obj, SLOT_LENGTH));
   JS_ASSERT(vp.isNumber() || vp.isUndefined());
-  return JS_TRUE;
+  return true;
 }
 
 JSBool
 ArrayType::Getter(JSContext* cx, HandleObject obj, HandleId idval, MutableHandleValue vp)
 {
   // This should never happen, but we'll check to be safe.
   if (!CData::IsCData(obj)) {
     JS_ReportError(cx, "not a CData");
-    return JS_FALSE;
+    return false;
   }
 
   // Bail early if we're not an ArrayType. (This setter is present for all
   // CData, regardless of CType.)
   JSObject* typeObj = CData::GetCType(obj);
   if (CType::GetTypeCode(typeObj) != TYPE_array)
-    return JS_TRUE;
+    return true;
 
   // Convert the index to a size_t and bounds-check it.
   size_t index;
   size_t length = GetLength(typeObj);
   bool ok = jsidToSize(cx, idval, true, &index);
   int32_t dummy;
   if (!ok && JSID_IS_STRING(idval) && !StringToInteger(cx, JSID_TO_STRING(idval), &dummy)) {
     // String either isn't a number, or doesn't fit in size_t.
     // Chances are it's a regular property lookup, so return.
-    return JS_TRUE;
+    return true;
   }
   if (!ok || index >= length) {
     JS_ReportError(cx, "invalid index");
-    return JS_FALSE;
+    return false;
   }
 
   RootedObject baseType(cx, GetBaseType(typeObj));
   size_t elementSize = CType::GetSize(baseType);
   char* data = static_cast<char*>(CData::GetData(obj)) + elementSize * index;
   return ConvertToJS(cx, baseType, obj, data, false, false, vp.address());
 }
 
 JSBool
 ArrayType::Setter(JSContext* cx, HandleObject obj, HandleId idval, JSBool strict, MutableHandleValue vp)
 {
   // This should never happen, but we'll check to be safe.
   if (!CData::IsCData(obj)) {
     JS_ReportError(cx, "not a CData");
-    return JS_FALSE;
+    return false;
   }
 
   // Bail early if we're not an ArrayType. (This setter is present for all
   // CData, regardless of CType.)
   JSObject* typeObj = CData::GetCType(obj);
   if (CType::GetTypeCode(typeObj) != TYPE_array)
-    return JS_TRUE;
+    return true;
 
   // Convert the index to a size_t and bounds-check it.
   size_t index;
   size_t length = GetLength(typeObj);
   bool ok = jsidToSize(cx, idval, true, &index);
   int32_t dummy;
   if (!ok && JSID_IS_STRING(idval) && !StringToInteger(cx, JSID_TO_STRING(idval), &dummy)) {
     // String either isn't a number, or doesn't fit in size_t.
     // Chances are it's a regular property lookup, so return.
-    return JS_TRUE;
+    return true;
   }
   if (!ok || index >= length) {
     JS_ReportError(cx, "invalid index");
-    return JS_FALSE;
+    return false;
   }
 
   JSObject* baseType = GetBaseType(typeObj);
   size_t elementSize = CType::GetSize(baseType);
   char* data = static_cast<char*>(CData::GetData(obj)) + elementSize * index;
   return ImplicitConvert(cx, vp, baseType, data, false, NULL);
 }
 
@@ -4754,85 +4754,85 @@ StructType::DefineInternal(JSContext* cx
 
   uint32_t len;
   ASSERT_OK(JS_GetArrayLength(cx, fieldsObj, &len));
 
   // Get the common prototype for CData objects of this type from
   // ctypes.CType.prototype.
   RootedObject dataProto(cx, CType::GetProtoFromType(cx, typeObj, SLOT_STRUCTDATAPROTO));
   if (!dataProto)
-    return JS_FALSE;
+    return false;
 
   // Set up the 'prototype' and 'prototype.constructor' properties.
   // The prototype will reflect the struct fields as properties on CData objects
   // created from this type.
   RootedObject prototype(cx, JS_NewObject(cx, &sCDataProtoClass, dataProto, NULL));
   if (!prototype)
-    return JS_FALSE;
+    return false;
 
   if (!JS_DefineProperty(cx, prototype, "constructor", OBJECT_TO_JSVAL(typeObj),
          NULL, NULL, JSPROP_READONLY | JSPROP_PERMANENT))
-    return JS_FALSE;
+    return false;
 
   // Create a FieldInfoHash to stash on the type object, and an array to root
   // its constituents. (We cannot simply stash the hash in a reserved slot now
   // to get GC safety for free, since if anything in this function fails we
   // do not want to mutate 'typeObj'.)
   AutoPtr<FieldInfoHash> fields(cx->new_<FieldInfoHash>());
   Array<jsval, 16> fieldRootsArray;
   if (!fields || !fields->init(len) || !fieldRootsArray.appendN(JSVAL_VOID, len)) {
     JS_ReportOutOfMemory(cx);
-    return JS_FALSE;
+    return false;
   }
   js::AutoArrayRooter fieldRoots(cx, fieldRootsArray.length(),
     fieldRootsArray.begin());
 
   // Process the field types.
   size_t structSize, structAlign;
   if (len != 0) {
     structSize = 0;
     structAlign = 0;
 
     for (uint32_t i = 0; i < len; ++i) {
       RootedValue item(cx);
       if (!JS_GetElement(cx, fieldsObj, i, &item))
-        return JS_FALSE;
+        return false;
 
       RootedObject fieldType(cx, NULL);
       JSFlatString* flat = ExtractStructField(cx, item, fieldType.address());
       if (!flat)
-        return JS_FALSE;
+        return false;
       Rooted<JSStableString*> name(cx, flat->ensureStable(cx));
       if (!name)
-        return JS_FALSE;
+        return false;
       fieldRootsArray[i] = OBJECT_TO_JSVAL(fieldType);
 
       // Make sure each field name is unique
       FieldInfoHash::AddPtr entryPtr = fields->lookupForAdd(name);
       if (entryPtr) {
         JS_ReportError(cx, "struct fields must have unique names");
-        return JS_FALSE;
+        return false;
       }
 
       // Add the field to the StructType's 'prototype' property.
       if (!JS_DefineUCProperty(cx, prototype,
              name->chars().get(), name->length(), JSVAL_VOID,
              StructType::FieldGetter, StructType::FieldSetter,
              JSPROP_SHARED | JSPROP_ENUMERATE | JSPROP_PERMANENT))
-        return JS_FALSE;
+        return false;
 
       size_t fieldSize = CType::GetSize(fieldType);
       size_t fieldAlign = CType::GetAlignment(fieldType);
       size_t fieldOffset = Align(structSize, fieldAlign);
       // Check for overflow. Since we hold invariant that fieldSize % fieldAlign
       // be zero, we can safely check fieldOffset + fieldSize without first
       // checking fieldOffset for overflow.
       if (fieldOffset + fieldSize < structSize) {
         JS_ReportError(cx, "size overflow");
-        return JS_FALSE;
+        return false;
       }
 
       // Add field name to the hash
       FieldInfo info;
       info.mType = fieldType;
       info.mIndex = i;
       info.mOffset = fieldOffset;
       ASSERT_OK(fields->add(entryPtr, name, info));
@@ -4843,41 +4843,41 @@ StructType::DefineInternal(JSContext* cx
       if (fieldAlign > structAlign)
         structAlign = fieldAlign;
     }
 
     // Pad the struct tail according to struct alignment.
     size_t structTail = Align(structSize, structAlign);
     if (structTail < structSize) {
       JS_ReportError(cx, "size overflow");
-      return JS_FALSE;
+      return false;
     }
     structSize = structTail;
 
   } else {
     // Empty structs are illegal in C, but are legal and have a size of
     // 1 byte in C++. We're going to allow them, and trick libffi into
     // believing this by adding a char member. The resulting struct will have
     // no getters or setters, and will be initialized to zero.
     structSize = 1;
     structAlign = 1;
   }
 
   RootedValue sizeVal(cx);
   if (!SizeTojsval(cx, structSize, sizeVal.address()))
-    return JS_FALSE;
+    return false;
 
   JS_SetReservedSlot(typeObj, SLOT_FIELDINFO, PRIVATE_TO_JSVAL(fields.forget()));
 
   JS_SetReservedSlot(typeObj, SLOT_SIZE, sizeVal);
   JS_SetReservedSlot(typeObj, SLOT_ALIGN, INT_TO_JSVAL(structAlign));
   //if (!JS_FreezeObject(cx, prototype)0 // XXX fixme - see bug 541212!
   //  return false;
   JS_SetReservedSlot(typeObj, SLOT_PROTO, OBJECT_TO_JSVAL(prototype));
-  return JS_TRUE;
+  return true;
 }
 
 ffi_type*
 StructType::BuildFFIType(JSContext* cx, JSObject* obj)
 {
   JS_ASSERT(CType::IsCType(obj));
   JS_ASSERT(CType::GetTypeCode(obj) == TYPE_struct);
   JS_ASSERT(CType::IsSizeDefined(obj));
@@ -4990,56 +4990,56 @@ StructType::Define(JSContext* cx, unsign
 
 JSBool
 StructType::ConstructData(JSContext* cx,
                           HandleObject obj,
                           const CallArgs& args)
 {
   if (!CType::IsCType(obj) || CType::GetTypeCode(obj) != TYPE_struct) {
     JS_ReportError(cx, "not a StructType");
-    return JS_FALSE;
+    return false;
   }
 
   if (!CType::IsSizeDefined(obj)) {
     JS_ReportError(cx, "cannot construct an opaque StructType");
-    return JS_FALSE;
+    return false;
   }
 
   JSObject* result = CData::Create(cx, obj, NullPtr(), NULL, true);
   if (!result)
-    return JS_FALSE;
+    return false;
 
   args.rval().setObject(*result);
 
   if (args.length() == 0)
-    return JS_TRUE;
+    return true;
 
   char* buffer = static_cast<char*>(CData::GetData(result));
   const FieldInfoHash* fields = GetFieldInfo(obj);
 
   if (args.length() == 1) {
     // There are two possible interpretations of the argument:
     // 1) It may be an object '{ ... }' with properties representing the
     //    struct fields intended to ExplicitConvert wholesale to our StructType.
     // 2) If the struct contains one field, the arg may be intended to
     //    ImplicitConvert directly to that arg's CType.
     // Thankfully, the conditions for these two possibilities to succeed
     // are mutually exclusive, so we can pick the right one.
 
     // Try option 1) first.
     if (ExplicitConvert(cx, args[0], obj, buffer))
-      return JS_TRUE;
+      return true;
 
     if (fields->count() != 1)
-      return JS_FALSE;
+      return false;
 
     // If ExplicitConvert failed, and there is no pending exception, then assume
     // hard failure (out of memory, or some other similarly serious condition).
     if (!JS_IsExceptionPending(cx))
-      return JS_FALSE;
+      return false;
 
     // Otherwise, assume soft failure, and clear the pending exception so that we
     // can throw a different one as required.
     JS_ClearPendingException(cx);
 
     // Fall through to try option 2).
   }
 
@@ -5047,25 +5047,25 @@ StructType::ConstructData(JSContext* cx,
   // ImplicitConvert each field.
   if (args.length() == fields->count()) {
     for (FieldInfoHash::Range r = fields->all(); !r.empty(); r.popFront()) {
       const FieldInfo& field = r.front().value;
       STATIC_ASSUME(field.mIndex < fields->count());  /* Quantified invariant */
       if (!ImplicitConvert(cx, args[field.mIndex], field.mType,
              buffer + field.mOffset,
              false, NULL))
-        return JS_FALSE;
+        return false;
     }
 
-    return JS_TRUE;
+    return true;
   }
 
   JS_ReportError(cx, "constructor takes 0, 1, or %u arguments",
     fields->count());
-  return JS_FALSE;
+  return false;
 }
 
 const FieldInfoHash*
 StructType::GetFieldInfo(JSObject* obj)
 {
   JS_ASSERT(CType::IsCType(obj));
   JS_ASSERT(CType::GetTypeCode(obj) == TYPE_struct);
 
@@ -5128,81 +5128,81 @@ StructType::BuildFieldsArray(JSContext* 
   return fieldsProp;
 }
 
 JSBool
 StructType::FieldsArrayGetter(JSContext* cx, HandleObject obj, HandleId idval, MutableHandleValue vp)
 {
   if (!CType::IsCType(obj) || CType::GetTypeCode(obj) != TYPE_struct) {
     JS_ReportError(cx, "not a StructType");
-    return JS_FALSE;
+    return false;
   }
 
   vp.set(JS_GetReservedSlot(obj, SLOT_FIELDS));
 
   if (!CType::IsSizeDefined(obj)) {
     JS_ASSERT(JSVAL_IS_VOID(vp));
-    return JS_TRUE;
+    return true;
   }
 
   if (JSVAL_IS_VOID(vp)) {
     // Build the 'fields' array lazily.
     JSObject* fields = BuildFieldsArray(cx, obj);
     if (!fields)
-      return JS_FALSE;
+      return false;
     JS_SetReservedSlot(obj, SLOT_FIELDS, OBJECT_TO_JSVAL(fields));
 
     vp.setObject(*fields);
   }
 
   JS_ASSERT(!JSVAL_IS_PRIMITIVE(vp) &&
             JS_IsArrayObject(cx, JSVAL_TO_OBJECT(vp)));
-  return JS_TRUE;
+  return true;
 }
 
 JSBool
 StructType::FieldGetter(JSContext* cx, HandleObject obj, HandleId idval, MutableHandleValue vp)
 {
   if (!CData::IsCData(obj)) {
     JS_ReportError(cx, "not a CData");
-    return JS_FALSE;
+    return false;
   }
 
   JSObject* typeObj = CData::GetCType(obj);
   if (CType::GetTypeCode(typeObj) != TYPE_struct) {
     JS_ReportError(cx, "not a StructType");
-    return JS_FALSE;
+    return false;
   }
 
   const FieldInfo* field = LookupField(cx, typeObj, JSID_TO_FLAT_STRING(idval));
   if (!field)
-    return JS_FALSE;
+    return false;
 
   char* data = static_cast<char*>(CData::GetData(obj)) + field->mOffset;
   RootedObject fieldType(cx, field->mType);
   return ConvertToJS(cx, fieldType, obj, data, false, false, vp.address());
 }
 
 JSBool
 StructType::FieldSetter(JSContext* cx, HandleObject obj, HandleId idval, JSBool strict, MutableHandleValue vp)
 {
   if (!CData::IsCData(obj)) {
     JS_ReportError(cx, "not a CData");
-    return JS_FALSE;
+    return false;
   }
 
   JSObject* typeObj = CData::GetCType(obj);
   if (CType::GetTypeCode(typeObj) != TYPE_struct) {
     JS_ReportError(cx, "not a StructType");
-    return JS_FALSE;
+    return false;
   }
 
   const FieldInfo* field = LookupField(cx, typeObj, JSID_TO_FLAT_STRING(idval));
   if (!field)
-    return JS_FALSE;
+    return false;
 
   char* data = static_cast<char*>(CData::GetData(obj)) + field->mOffset;
   return ImplicitConvert(cx, vp, field->mType, data, false, NULL);
 }
 
 bool
 StructType::AddressOfField(JSContext* cx, unsigned argc, jsval* vp)
 {
@@ -5652,27 +5652,27 @@ FunctionType::ConstructData(JSContext* c
 {
   JS_ASSERT(CType::GetTypeCode(typeObj) == TYPE_function);
 
   PRFuncPtr* data = static_cast<PRFuncPtr*>(CData::GetData(dataObj));
 
   FunctionInfo* fninfo = FunctionType::GetFunctionInfo(typeObj);
   if (fninfo->mIsVariadic) {
     JS_ReportError(cx, "Can't declare a variadic callback function");
-    return JS_FALSE;
+    return false;
   }
   if (GetABICode(fninfo->mABI) == ABI_WINAPI) {
     JS_ReportError(cx, "Can't declare a ctypes.winapi_abi callback function, "
                    "use ctypes.stdcall_abi instead");
-    return JS_FALSE;
+    return false;
   }
 
   RootedObject closureObj(cx, CClosure::Create(cx, typeObj, fnObj, thisObj, errVal, data));
   if (!closureObj)
-    return JS_FALSE;
+    return false;
 
   // Set the closure object as the referent of the new CData object.
   JS_SetReservedSlot(dataObj, SLOT_REFERENT, OBJECT_TO_JSVAL(closureObj));
 
   // Seal the CData object, to prevent modification of the function pointer.
   // This permanently associates this object with the closure, and avoids
   // having to do things like reset SLOT_REFERENT when someone tries to
   // change the pointer value.
@@ -5888,86 +5888,86 @@ FunctionType::GetFunctionInfo(JSObject* 
   return static_cast<FunctionInfo*>(JSVAL_TO_PRIVATE(slot));
 }
 
 static JSBool
 CheckFunctionType(JSContext* cx, JSObject* obj)
 {
   if (!CType::IsCType(obj) || CType::GetTypeCode(obj) != TYPE_function) {
     JS_ReportError(cx, "not a FunctionType");
-    return JS_FALSE;
-  }
-  return JS_TRUE;
+    return false;
+  }
+  return true;
 }
 
 JSBool
 FunctionType::ArgTypesGetter(JSContext* cx, HandleObject obj, HandleId idval, MutableHandleValue vp)
 {
   if (!CheckFunctionType(cx, obj))
-    return JS_FALSE;
+    return false;
 
   // Check if we have a cached argTypes array.
   vp.set(JS_GetReservedSlot(obj, SLOT_ARGS_T));
   if (!JSVAL_IS_VOID(vp))
-    return JS_TRUE;
+    return true;
 
   FunctionInfo* fninfo = GetFunctionInfo(obj);
   size_t len = fninfo->mArgTypes.length();
 
   // Prepare a new array.
   Array<jsval, 16> vec;
   if (!vec.resize(len))
-    return JS_FALSE;
+    return false;
 
   for (size_t i = 0; i < len; ++i)
     vec[i] = OBJECT_TO_JSVAL(fninfo->mArgTypes[i]);
 
   RootedObject argTypes(cx, JS_NewArrayObject(cx, len, vec.begin()));
   if (!argTypes)
-    return JS_FALSE;
+    return false;
 
   // Seal and cache it.
   if (!JS_FreezeObject(cx, argTypes))
-    return JS_FALSE;
+    return false;
   JS_SetReservedSlot(obj, SLOT_ARGS_T, OBJECT_TO_JSVAL(argTypes));
 
   vp.setObject(*argTypes);
-  return JS_TRUE;
+  return true;
 }
 
 JSBool
 FunctionType::ReturnTypeGetter(JSContext* cx, HandleObject obj, HandleId idval, MutableHandleValue vp)
 {
   if (!CheckFunctionType(cx, obj))
-    return JS_FALSE;
+    return false;
 
   // Get the returnType object from the FunctionInfo.
   vp.setObject(*GetFunctionInfo(obj)->mReturnType);
-  return JS_TRUE;
+  return true;
 }
 
 JSBool
 FunctionType::ABIGetter(JSContext* cx, HandleObject obj, HandleId idval, MutableHandleValue vp)
 {
   if (!CheckFunctionType(cx, obj))
-    return JS_FALSE;
+    return false;
 
   // Get the abi object from the FunctionInfo.
   vp.setObject(*GetFunctionInfo(obj)->mABI);
-  return JS_TRUE;
+  return true;
 }
 
 JSBool
 FunctionType::IsVariadicGetter(JSContext* cx, HandleObject obj, HandleId idval, MutableHandleValue vp)
 {
   if (!CheckFunctionType(cx, obj))
-    return JS_FALSE;
+    return false;
 
   vp.setBoolean(GetFunctionInfo(obj)->mIsVariadic);
-  return JS_TRUE;
+  return true;
 }
 
 /*******************************************************************************
 ** CClosure implementation
 *******************************************************************************/
 
 JSObject*
 CClosure::Create(JSContext* cx,
@@ -6402,33 +6402,33 @@ CData::IsCDataProto(JSObject* obj)
   return JS_GetClass(obj) == &sCDataProtoClass;
 }
 
 JSBool
 CData::ValueGetter(JSContext* cx, HandleObject obj, HandleId idval, MutableHandleValue vp)
 {
   if (!IsCData(obj)) {
     JS_ReportError(cx, "not a CData");
-    return JS_FALSE;
+    return false;
   }
 
   // Convert the value to a primitive; do not create a new CData object.
   RootedObject ctype(cx, GetCType(obj));
   if (!ConvertToJS(cx, ctype, NullPtr(), GetData(obj), true, false, vp.address()))
-    return JS_FALSE;
-
-  return JS_TRUE;
+    return false;
+
+  return true;
 }
 
 JSBool
 CData::ValueSetter(JSContext* cx, HandleObject obj, HandleId idval, JSBool strict, MutableHandleValue vp)
 {
   if (!IsCData(obj)) {
     JS_ReportError(cx, "not a CData");
-    return JS_FALSE;
+    return false;
   }
 
   return ImplicitConvert(cx, vp, GetCType(obj), GetData(obj), false, NULL);
 }
 
 bool
 CData::Address(JSContext* cx, unsigned argc, jsval* vp)
 {
@@ -6691,34 +6691,34 @@ CData::ToSource(JSContext* cx, unsigned 
   return true;
 }
 
 JSBool
 CData::ErrnoGetter(JSContext* cx, HandleObject obj, HandleId, MutableHandleValue vp)
 {
   if (!IsCTypesGlobal(obj)) {
     JS_ReportError(cx, "this is not not global object ctypes");
-    return JS_FALSE;
+    return false;
   }
 
   vp.set(JS_GetReservedSlot(obj, SLOT_ERRNO));
-  return JS_TRUE;
+  return true;
 }
 
 #if defined(XP_WIN)
 JSBool
 CData::LastErrorGetter(JSContext* cx, HandleObject obj, HandleId, MutableHandleValue vp)
 {
   if (!IsCTypesGlobal(obj)) {
     JS_ReportError(cx, "not global object ctypes");
-    return JS_FALSE;
+    return false;
   }
 
   vp.set(JS_GetReservedSlot(obj, SLOT_LASTERROR));
-  return JS_TRUE;
+  return true;
 }
 #endif // defined(XP_WIN)
 
 bool
 CDataFinalizer::Methods::ToSource(JSContext *cx, unsigned argc, jsval *vp)
 {
   CallArgs args = CallArgsFromVp(argc, vp);
   RootedObject objThis(cx, JS_THIS_OBJECT(cx, vp));
--- a/js/src/ion/arm/Trampoline-arm.cpp
+++ b/js/src/ion/arm/Trampoline-arm.cpp
@@ -315,17 +315,17 @@ IonRuntime::generateEnterJIT(JSContext *
     // We're using a load-double here.  In order for that to work,
     // the data needs to be stored in two consecutive registers,
     // make sure this is the case
     //   ASSERT(JSReturnReg_Type.code() == JSReturnReg_Data.code()+1);
     //   aasm->as_extdtr(IsStore, 64, true, Offset,
     //                   JSReturnReg_Data, EDtrAddr(r5, EDtrOffImm(0)));
 
     // Restore non-volatile registers and return.
-    GenerateReturn(masm, JS_TRUE);
+    GenerateReturn(masm, true);
 
     Linker linker(masm);
     return linker.newCode(cx, JSC::OTHER_CODE);
 }
 
 IonCode *
 IonRuntime::generateInvalidator(JSContext *cx)
 {
--- a/js/src/jsapi-tests/testClassGetter.cpp
+++ b/js/src/jsapi-tests/testClassGetter.cpp
@@ -10,17 +10,17 @@
 #include "jsapi-tests/tests.h"
 
 int called_test_fn;
 int called_test_prop_get;
 
 static JSBool test_prop_get( JSContext *cx, JS::HandleObject obj, JS::HandleId id, JS::MutableHandleValue vp )
 {
     called_test_prop_get++;
-    return JS_TRUE;
+    return true;
 }
 
 static bool
 PTest(JSContext* cx, unsigned argc, jsval *vp);
 
 static JSClass ptestClass = {
     "PTest",
     JSCLASS_HAS_PRIVATE,
--- a/js/src/jsapi-tests/testDebugger.cpp
+++ b/js/src/jsapi-tests/testDebugger.cpp
@@ -21,17 +21,17 @@ callCountHook(JSContext *cx, JSAbstractF
     JS::RootedValue thisv(cx);
     frame.getThisValue(cx, &thisv); // assert if fp is incomplete
 
     return cx;  // any non-null value causes the hook to be called again after
 }
 
 BEGIN_TEST(testDebugger_bug519719)
 {
-    CHECK(JS_SetDebugMode(cx, JS_TRUE));
+    CHECK(JS_SetDebugMode(cx, true));
     JS_SetCallHook(rt, callCountHook, NULL);
     EXEC("function call(fn) { fn(0); }\n"
          "function f(g) { for (var i = 0; i < 9; i++) call(g); }\n"
          "f(Math.sin);\n"    // record loop, starting in f
          "f(Math.cos);\n");  // side exit in f -> call
     CHECK_EQUAL(callCount[0], 20);
     CHECK_EQUAL(callCount[1], 20);
     return true;
@@ -49,17 +49,17 @@ nonStrictThisHook(JSContext *cx, JSAbstr
         *allWrapped = *allWrapped && !JSVAL_IS_PRIMITIVE(thisv);
     }
     return NULL;
 }
 
 BEGIN_TEST(testDebugger_getThisNonStrict)
 {
     bool allWrapped = true;
-    CHECK(JS_SetDebugMode(cx, JS_TRUE));
+    CHECK(JS_SetDebugMode(cx, true));
     JS_SetCallHook(rt, nonStrictThisHook, (void *) &allWrapped);
     EXEC("function nonstrict() { }\n"
          "Boolean.prototype.nonstrict = nonstrict;\n"
          "String.prototype.nonstrict = nonstrict;\n"
          "Number.prototype.nonstrict = nonstrict;\n"
          "Object.prototype.nonstrict = nonstrict;\n"
          "nonstrict.call(true);\n"
          "true.nonstrict();\n"
@@ -88,17 +88,17 @@ strictThisHook(JSContext *cx, JSAbstract
         *anyWrapped = *anyWrapped || !JSVAL_IS_PRIMITIVE(thisv);
     }
     return NULL;
 }
 
 BEGIN_TEST(testDebugger_getThisStrict)
 {
     bool anyWrapped = false;
-    CHECK(JS_SetDebugMode(cx, JS_TRUE));
+    CHECK(JS_SetDebugMode(cx, true));
     JS_SetCallHook(rt, strictThisHook, (void *) &anyWrapped);
     EXEC("function strict() { 'use strict'; }\n"
          "Boolean.prototype.strict = strict;\n"
          "String.prototype.strict = strict;\n"
          "Number.prototype.strict = strict;\n"
          "strict.call(true);\n"
          "true.strict();\n"
          "strict.call('');\n"
--- a/js/src/jsapi-tests/testDefineGetterSetterNonEnumerable.cpp
+++ b/js/src/jsapi-tests/testDefineGetterSetterNonEnumerable.cpp
@@ -40,17 +40,17 @@ BEGIN_TEST(testDefineGetterSetterNonEnum
                             JSPROP_GETTER | JSPROP_SETTER | JSPROP_ENUMERATE));
 
     CHECK(JS_DefineProperty(cx, vObject, PROPERTY_NAME,
                             JSVAL_VOID,
                             JS_DATA_TO_FUNC_PTR(JSPropertyOp, (JSObject*) funGetObj),
                             JS_DATA_TO_FUNC_PTR(JSStrictPropertyOp, (JSObject*) funSetObj),
                             JSPROP_GETTER | JSPROP_SETTER | JSPROP_PERMANENT));
 
-    JSBool found = JS_FALSE;
+    JSBool found = false;
     unsigned attrs = 0;
     CHECK(JS_GetPropertyAttributes(cx, vObject, PROPERTY_NAME, &attrs, &found));
     CHECK(found);
     CHECK(attrs & JSPROP_GETTER);
     CHECK(attrs & JSPROP_SETTER);
     CHECK(attrs & JSPROP_PERMANENT);
     CHECK(!(attrs & JSPROP_ENUMERATE));
 
--- a/js/src/jsapi-tests/testIndexToString.cpp
+++ b/js/src/jsapi-tests/testIndexToString.cpp
@@ -59,17 +59,17 @@ BEGIN_TEST(testIndexToString)
     for (size_t i = 0, sz = ArrayLength(tests); i < sz; i++) {
         uint32_t u = tests[i].num;
         JSString *str = js::IndexToString(cx, u);
         CHECK(str);
 
         if (!js::StaticStrings::hasUint(u))
             CHECK(cx->compartment()->dtoaCache.lookup(10, u) == str);
 
-        JSBool match = JS_FALSE;
+        JSBool match = false;
         CHECK(JS_StringEqualsAscii(cx, str, tests[i].expected, &match));
         CHECK(match);
     }
 
     return true;
 }
 END_TEST(testIndexToString)
 
--- a/js/src/jsapi-tests/testJSEvaluateScript.cpp
+++ b/js/src/jsapi-tests/testJSEvaluateScript.cpp
@@ -13,37 +13,37 @@ BEGIN_TEST(testJSEvaluateScript)
     CHECK(options & JSOPTION_VAROBJFIX);
 
     static const char src[] = "var x = 5;";
 
     JS::RootedValue retval(cx);
     CHECK(JS_EvaluateScript(cx, obj, src, sizeof(src) - 1, __FILE__, __LINE__,
                             retval.address()));
 
-    JSBool hasProp = JS_TRUE;
+    JSBool hasProp = true;
     CHECK(JS_AlreadyHasOwnProperty(cx, obj, "x", &hasProp));
     CHECK(!hasProp);
 
-    hasProp = JS_FALSE;
+    hasProp = false;
     CHECK(JS_HasProperty(cx, global, "x", &hasProp));
     CHECK(hasProp);
 
     // Now do the same thing, but without JSOPTION_VAROBJFIX
     JS_SetOptions(cx, options & ~JSOPTION_VAROBJFIX);
 
     static const char src2[] = "var y = 5;";
 
     CHECK(JS_EvaluateScript(cx, obj, src2, sizeof(src2) - 1, __FILE__, __LINE__,
                             retval.address()));
 
-    hasProp = JS_FALSE;
+    hasProp = false;
     CHECK(JS_AlreadyHasOwnProperty(cx, obj, "y", &hasProp));
     CHECK(hasProp);
 
-    hasProp = JS_TRUE;
+    hasProp = true;
     CHECK(JS_AlreadyHasOwnProperty(cx, global, "y", &hasProp));
     CHECK(!hasProp);
 
     return true;
 }
 END_TEST(testJSEvaluateScript)
 
 
--- a/js/src/jsapi-tests/testOps.cpp
+++ b/js/src/jsapi-tests/testOps.cpp
@@ -9,19 +9,19 @@
 
 #include "jsapi-tests/tests.h"
 
 static JSBool
 my_convert(JSContext* context, JS::HandleObject obj, JSType type, JS::MutableHandleValue rval)
 {
     if (type == JSTYPE_VOID || type == JSTYPE_STRING || type == JSTYPE_NUMBER || type == JSTYPE_BOOLEAN) {
         rval.set(JS_NumberValue(123));
-        return JS_TRUE;
+        return true;
     }
-    return JS_FALSE;
+    return false;
 }
 
 static JSClass myClass = {
     "MyClass",
     0,
     JS_PropertyStub, JS_DeletePropertyStub, JS_PropertyStub, JS_StrictPropertyStub,
     JS_EnumerateStub, JS_ResolveStub, my_convert
 };
@@ -33,17 +33,17 @@ createMyObject(JSContext* context, unsig
 
     //JS_GC(context); //<- if we make GC here, all is ok
 
     JSObject* myObject = JS_NewObject(context, &myClass, NULL, NULL);
     *vp = OBJECT_TO_JSVAL(myObject);
 
     JS_EndRequest(context);
 
-    return JS_TRUE;
+    return true;
 }
 
 static const JSFunctionSpec s_functions[] =
 {
     JS_FN("createMyObject", createMyObject, 0, 0),
     JS_FS_END
 };
 
--- a/js/src/jsapi-tests/testPropCache.cpp
+++ b/js/src/jsapi-tests/testPropCache.cpp
@@ -8,17 +8,17 @@
 #include "jsapi-tests/tests.h"
 
 static int g_counter;
 
 static JSBool
 CounterAdd(JSContext *cx, JS::HandleObject obj, JS::HandleId id, JS::MutableHandleValue vp)
 {
     g_counter++;
-    return JS_TRUE;
+    return true;
 }
 
 static JSClass CounterClass = {
     "Counter",  /* name */
     0,  /* flags */
     CounterAdd, JS_DeletePropertyStub, JS_PropertyStub, JS_StrictPropertyStub,
     JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub
 };
--- a/js/src/jsapi-tests/testSetProperty.cpp
+++ b/js/src/jsapi-tests/testSetProperty.cpp
@@ -6,17 +6,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jsapi-tests/tests.h"
 
 static JSBool
 nativeGet(JSContext *cx, JS::HandleObject obj, JS::HandleId id, JS::MutableHandleValue vp)
 {
     vp.set(INT_TO_JSVAL(17));
-    return JS_TRUE;
+    return true;
 }
 
 BEGIN_TEST(testSetProperty_NativeGetterStubSetter)
 {
     JS::RootedObject obj(cx, JS_NewObject(cx, NULL, NULL, NULL));
     CHECK(obj);
     JS::RootedValue vobj(cx, OBJECT_TO_JSVAL(obj));
 
--- a/js/src/jsapi-tests/testSourcePolicy.cpp
+++ b/js/src/jsapi-tests/testSourcePolicy.cpp
@@ -26,17 +26,17 @@ END_TEST(testBug795104)
 
 const char *simpleSource = "var x = 4;";
 
 static void
 newScriptHook(JSContext *cx, const char *fn, unsigned lineno,
               JSScript *script, JSFunction *fun, void *data)
 {
     if (!JS_StringEqualsAscii(cx, script->sourceData(cx), simpleSource, (JSBool *)data))
-        *((JSBool *)data) = JS_FALSE;
+        *((JSBool *)data) = false;
 }
 
 BEGIN_TEST(testScriptSourceReentrant)
 {
     JS::CompileOptions opts(cx);
     JSBool match = false;
     JS_SetNewScriptHook(rt, newScriptHook, &match);
     CHECK(JS::Evaluate(cx, global, opts, simpleSource, strlen(simpleSource), NULL));
--- a/js/src/jsapi-tests/testTrap.cpp
+++ b/js/src/jsapi-tests/testTrap.cpp
@@ -40,17 +40,17 @@ BEGIN_TEST(testTrap_gc)
 
     // execute
     JS::RootedValue v2(cx);
     CHECK(JS_ExecuteScript(cx, global, script, v2.address()));
     CHECK(v2.isObject());
     CHECK_EQUAL(emptyTrapCallCount, 0);
 
     // Enable debug mode
-    CHECK(JS_SetDebugMode(cx, JS_TRUE));
+    CHECK(JS_SetDebugMode(cx, true));
 
     static const char trapClosureText[] = "some trap closure";
 
     // scope JSScript  usage to make sure that it is not used after
     // JS_ExecuteScript. This way we avoid using Anchor.
     JS::RootedString trapClosure(cx);
     {
         jsbytecode *line2 = JS_LineNumberToPC(cx, script, 1);
--- a/js/src/jsapi-tests/tests.h
+++ b/js/src/jsapi-tests/tests.h
@@ -239,28 +239,28 @@ class JSAPITest
   protected:
     static JSBool
     print(JSContext *cx, unsigned argc, jsval *vp)
     {
         jsval *argv = JS_ARGV(cx, vp);
         for (unsigned i = 0; i < argc; i++) {
             JSString *str = JS_ValueToString(cx, argv[i]);
             if (!str)
-                return JS_FALSE;
+                return false;
             char *bytes = JS_EncodeString(cx, str);
             if (!bytes)
-                return JS_FALSE;
+                return false;
             printf("%s%s", i ? " " : "", bytes);
             JS_free(cx, bytes);
         }
 
         putchar('\n');
         fflush(stdout);
         JS_SET_RVAL(cx, vp, JSVAL_VOID);
-        return JS_TRUE;
+        return true;
     }
 
     bool definePrint();
 
     virtual JSRuntime * createRuntime() {
         JSRuntime *rt = JS_NewRuntime(8L * 1024 * 1024, JS_USE_HELPER_THREADS);
         if (!rt)
             return NULL;
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -128,18 +128,18 @@ JS::detail::CallMethodIfWrapped(JSContex
 #ifdef JS_USE_JSID_STRUCT_TYPES
 const jsid JSID_VOID  = { size_t(JSID_TYPE_VOID) };
 const jsid JSID_EMPTY = { size_t(JSID_TYPE_OBJECT) };
 #endif
 
 const jsval JSVAL_NULL  = IMPL_TO_JSVAL(BUILD_JSVAL(JSVAL_TAG_NULL,      0));
 const jsval JSVAL_ZERO  = IMPL_TO_JSVAL(BUILD_JSVAL(JSVAL_TAG_INT32,     0));
 const jsval JSVAL_ONE   = IMPL_TO_JSVAL(BUILD_JSVAL(JSVAL_TAG_INT32,     1));
-const jsval JSVAL_FALSE = IMPL_TO_JSVAL(BUILD_JSVAL(JSVAL_TAG_BOOLEAN,   JS_FALSE));
-const jsval JSVAL_TRUE  = IMPL_TO_JSVAL(BUILD_JSVAL(JSVAL_TAG_BOOLEAN,   JS_TRUE));
+const jsval JSVAL_FALSE = IMPL_TO_JSVAL(BUILD_JSVAL(JSVAL_TAG_BOOLEAN,   false));
+const jsval JSVAL_TRUE  = IMPL_TO_JSVAL(BUILD_JSVAL(JSVAL_TAG_BOOLEAN,   true));
 const jsval JSVAL_VOID  = IMPL_TO_JSVAL(BUILD_JSVAL(JSVAL_TAG_UNDEFINED, 0));
 const HandleValue JS::NullHandleValue =
     HandleValue::fromMarkedLocation(&JSVAL_NULL);
 const HandleValue JS::UndefinedHandleValue =
     HandleValue::fromMarkedLocation(&JSVAL_VOID);
 
 const jsid voidIdValue = JSID_VOID;
 const jsid emptyIdValue = JSID_EMPTY;
@@ -245,109 +245,109 @@ JS_ConvertArgumentsVA(JSContext *cx, uns
     JSString *str;
     RootedObject obj(cx);
     RootedValue val(cx);
 
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
     assertSameCompartment(cx, JSValueArray(argv - 2, argc + 2));
     sp = argv;
-    required = JS_TRUE;
+    required = true;
     while ((c = *format++) != '\0') {
         if (isspace(c))
             continue;
         if (c == '/') {
-            required = JS_FALSE;
+            required = false;
             continue;
         }
         if (sp == argv + argc) {
             if (required) {
                 if (JSFunction *fun = ReportIfNotFunction(cx, argv[-2])) {
                     char numBuf[12];
                     JS_snprintf(numBuf, sizeof numBuf, "%u", argc);
                     JSAutoByteString funNameBytes;
                     if (const char *name = GetFunctionNameBytes(cx, fun, &funNameBytes)) {
                         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_MORE_ARGS_NEEDED,
                                              name, numBuf, (argc == 1) ? "" : "s");
                     }
                 }
-                return JS_FALSE;
+                return false;
             }
             break;
         }
         switch (c) {
           case 'b':
             *va_arg(ap, JSBool *) = ToBoolean(*sp);
             break;
           case 'c':
             if (!JS_ValueToUint16(cx, *sp, va_arg(ap, uint16_t *)))
-                return JS_FALSE;
+                return false;
             break;
           case 'i':
             if (!JS_ValueToECMAInt32(cx, *sp, va_arg(ap, int32_t *)))
-                return JS_FALSE;
+                return false;
             break;
           case 'u':
             if (!JS_ValueToECMAUint32(cx, *sp, va_arg(ap, uint32_t *)))
-                return JS_FALSE;
+                return false;
             break;
           case 'j':
             if (!JS_ValueToInt32(cx, *sp, va_arg(ap, int32_t *)))
-                return JS_FALSE;
+                return false;
             break;
           case 'd':
             if (!JS_ValueToNumber(cx, *sp, va_arg(ap, double *)))
-                return JS_FALSE;
+                return false;
             break;
           case 'I':
             if (!JS_ValueToNumber(cx, *sp, &d))
-                return JS_FALSE;
+                return false;
             *va_arg(ap, double *) = ToInteger(d);
             break;
           case 'S':
           case 'W':
             val = *sp;
             str = ToString<CanGC>(cx, val);
             if (!str)
-                return JS_FALSE;
+                return false;
             *sp = STRING_TO_JSVAL(str);
             if (c == 'W') {
                 JSStableString *stable = str->ensureStable(cx);
                 if (!stable)
-                    return JS_FALSE;
+                    return false;
                 *va_arg(ap, const jschar **) = stable->chars().get();
             } else {
                 *va_arg(ap, JSString **) = str;
             }
             break;
           case 'o':
             if (!js_ValueToObjectOrNull(cx, *sp, &obj))
-                return JS_FALSE;
+                return false;
             *sp = OBJECT_TO_JSVAL(obj);
             *va_arg(ap, JSObject **) = obj;
             break;
           case 'f':
             obj = ReportIfNotFunction(cx, *sp);
             if (!obj)
-                return JS_FALSE;
+                return false;
             *sp = OBJECT_TO_JSVAL(obj);
             *va_arg(ap, JSFunction **) = &obj->as<JSFunction>();
             break;
           case 'v':
             *va_arg(ap, jsval *) = *sp;
             break;
           case '*':
             break;
           default:
             JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_CHAR, format);
-            return JS_FALSE;
+            return false;
         }
         sp++;
     }
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_ConvertValue(JSContext *cx, jsval valueArg, JSType type, jsval *vp)
 {
     RootedValue value(cx, valueArg);
     JSBool ok;
     RootedObject obj(cx);
@@ -355,17 +355,17 @@ JS_ConvertValue(JSContext *cx, jsval val
     double d;
 
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
     assertSameCompartment(cx, value);
     switch (type) {
       case JSTYPE_VOID:
         *vp = JSVAL_VOID;
-        ok = JS_TRUE;
+        ok = true;
         break;
       case JSTYPE_OBJECT:
         ok = js_ValueToObjectOrNull(cx, value, &obj);
         if (ok)
             *vp = OBJECT_TO_JSVAL(obj);
         break;
       case JSTYPE_FUNCTION:
         *vp = value;
@@ -380,22 +380,22 @@ JS_ConvertValue(JSContext *cx, jsval val
         break;
       case JSTYPE_NUMBER:
         ok = JS_ValueToNumber(cx, value, &d);
         if (ok)
             *vp = DOUBLE_TO_JSVAL(d);
         break;
       case JSTYPE_BOOLEAN:
         *vp = BooleanValue(ToBoolean(value));
-        return JS_TRUE;
+        return true;
       default: {
         char numBuf[12];
         JS_snprintf(numBuf, sizeof numBuf, "%d", (int)type);
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_TYPE, numBuf);
-        ok = JS_FALSE;
+        ok = false;
         break;
       }
     }
     return ok;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_ValueToObject(JSContext *cx, jsval valueArg, JSObject **objpArg)
@@ -544,17 +544,17 @@ JS_ValueToUint16(JSContext *cx, jsval va
 
 JS_PUBLIC_API(JSBool)
 JS_ValueToBoolean(JSContext *cx, jsval value, JSBool *bp)
 {
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
     assertSameCompartment(cx, value);
     *bp = ToBoolean(value);
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSType)
 JS_TypeOfValue(JSContext *cx, jsval valueArg)
 {
     RootedValue value(cx, valueArg);
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
@@ -2267,19 +2267,19 @@ DumpNotify(JSTracer *trc, void **thingp,
 static JSBool
 DumpNode(JSDumpingTracer *dtrc, FILE* fp, JSHeapDumpNode *node)
 {
     JSHeapDumpNode *prev, *following;
     size_t chainLimit;
     enum { MAX_PARENTS_TO_PRINT = 10 };
 
     JS_GetTraceThingInfo(dtrc->buffer, sizeof dtrc->buffer,
-                         &dtrc->base, node->thing, node->kind, JS_TRUE);
+                         &dtrc->base, node->thing, node->kind, true);
     if (fprintf(fp, "%p %-22s via ", node->thing, dtrc->buffer) < 0)
-        return JS_FALSE;
+        return false;
 
     /*
      * We need to print the parent chain in the reverse order. To do it in
      * O(N) time where N is the chain length we first reverse the chain while
      * searching for the top and then print each node while restoring the
      * chain order.
      */
     chainLimit = MAX_PARENTS_TO_PRINT;
@@ -2288,17 +2288,17 @@ DumpNode(JSDumpingTracer *dtrc, FILE* fp
         following = node->parent;
         node->parent = prev;
         prev = node;
         node = following;
         if (!node)
             break;
         if (chainLimit == 0) {
             if (fputs("...", fp) < 0)
-                return JS_FALSE;
+                return false;
             break;
         }
         --chainLimit;
     }
 
     node = prev;
     prev = following;
     bool ok = true;
@@ -2307,17 +2307,17 @@ DumpNode(JSDumpingTracer *dtrc, FILE* fp
         if (ok) {
             if (!prev) {
                 /* Print edge from some runtime root or startThing. */
                 if (fputs(node->edgeName, fp) < 0)
                     ok = false;
             } else {
                 JS_GetTraceThingInfo(dtrc->buffer, sizeof dtrc->buffer,
                                      &dtrc->base, prev->thing, prev->kind,
-                                     JS_FALSE);
+                                     false);
                 if (fprintf(fp, "(%p %s).%s",
                            prev->thing, dtrc->buffer, node->edgeName) < 0) {
                     ok = false;
                 }
             }
         }
         following = node->parent;
         node->parent = prev;
@@ -2372,17 +2372,17 @@ JS_DumpHeap(JSRuntime *rt, FILE *fp, voi
             if (dtrc.ok &&
                 depth < maxDepth &&
                 (thingToFind != node->thing || !thingToFindWasTraced)) {
                 dtrc.parentNode = node;
                 children = NULL;
                 dtrc.lastNodep = &children;
                 JS_TraceChildren(&dtrc.base, node->thing, node->kind);
                 if (thingToFind == node->thing)
-                    thingToFindWasTraced = JS_TRUE;
+                    thingToFindWasTraced = true;
                 if (children != NULL) {
                     ++depth;
                     node = children;
                     continue;
                 }
             }
         }
 
@@ -2670,17 +2670,17 @@ JS_ValueToId(JSContext *cx, jsval valueA
 
 JS_PUBLIC_API(JSBool)
 JS_IdToValue(JSContext *cx, jsid id, jsval *vp)
 {
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
     *vp = IdToJsval(id);
     assertSameCompartment(cx, *vp);
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_DefaultValue(JSContext *cx, JSObject *objArg, JSType hint, jsval *vp)
 {
     RootedObject obj(cx, objArg);
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
@@ -2693,42 +2693,42 @@ JS_DefaultValue(JSContext *cx, JSObject 
 
     *vp = value;
     return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_PropertyStub(JSContext *cx, HandleObject obj, HandleId id, MutableHandleValue vp)
 {
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_StrictPropertyStub(JSContext *cx, HandleObject obj, HandleId id, JSBool strict, MutableHandleValue vp)
 {
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_DeletePropertyStub(JSContext *cx, HandleObject obj, HandleId id, JSBool *succeeded)
 {
     *succeeded = true;
     return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_EnumerateStub(JSContext *cx, HandleObject obj)
 {
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_ResolveStub(JSContext *cx, HandleObject obj, HandleId id)
 {
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_ConvertStub(JSContext *cx, HandleObject obj, JSType type, MutableHandleValue vp)
 {
     JS_ASSERT(type != JSTYPE_OBJECT && type != JSTYPE_FUNCTION);
     JS_ASSERT(obj);
     return DefaultValue(cx, obj, type, vp);
@@ -2829,17 +2829,17 @@ JS_GetPrototype(JSContext *cx, JS::Handl
 
 JS_PUBLIC_API(JSBool)
 JS_SetPrototype(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<JSObject*> proto)
 {
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
     assertSameCompartment(cx, obj, proto);
 
-    return SetClassAndProto(cx, obj, obj->getClass(), proto, JS_FALSE);
+    return SetClassAndProto(cx, obj, obj->getClass(), proto, false);
 }
 
 JS_PUBLIC_API(JSObject *)
 JS_GetParent(JSObject *obj)
 {
     JS_ASSERT(!obj->is<ScopeObject>());
     return obj->getParent();
 }
@@ -2882,17 +2882,17 @@ JS_GetConstructor(JSContext *cx, JSObjec
 }
 
 JS_PUBLIC_API(JSBool)
 JS_GetObjectId(JSContext *cx, JSObject *obj, jsid *idp)
 {
     AssertHeapIsIdle(cx);
     assertSameCompartment(cx, obj);
     *idp = OBJECT_TO_JSID(obj);
-    return JS_TRUE;
+    return true;
 }
 
 class AutoHoldZone
 {
   public:
     explicit AutoHoldZone(Zone *zone
                           MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
       : holdp(&zone->hold)
@@ -3111,17 +3111,17 @@ LookupPropertyById(JSContext *cx, Handle
 
 static JSBool
 LookupResult(JSContext *cx, HandleObject obj, HandleObject obj2, HandleId id,
              HandleShape shape, MutableHandleValue vp)
 {
     if (!shape) {
         /* XXX bad API: no way to tell "not defined" from "void value" */
         vp.setUndefined();
-        return JS_TRUE;
+        return true;
     }
 
     if (!obj2->isNative()) {
         if (obj2->is<ProxyObject>()) {
             AutoPropertyDescriptorRooter desc(cx);
             if (!Proxy::getPropertyDescriptor(cx, obj2, id, &desc, 0))
                 return false;
             if (!(desc.attrs & JSPROP_SHARED)) {
@@ -3268,28 +3268,28 @@ JS_AlreadyHasOwnPropertyById(JSContext *
     CHECK_REQUEST(cx);
     assertSameCompartment(cx, obj, id);
 
     if (!obj->isNative()) {
         RootedObject obj2(cx);
         RootedShape prop(cx);
 
         if (!LookupPropertyById(cx, obj, id, 0, &obj2, &prop))
-            return JS_FALSE;
+            return false;
         *foundp = (obj == obj2);
-        return JS_TRUE;
+        return true;
     }
 
     if (JSID_IS_INT(id) && obj->containsDenseElement(JSID_TO_INT(id))) {
         *foundp = true;
-        return JS_TRUE;
+        return true;
     }
 
     *foundp = obj->nativeContains(cx, id);
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_AlreadyHasOwnElement(JSContext *cx, JSObject *objArg, uint32_t index, JSBool *foundp)
 {
     RootedObject obj(cx, objArg);
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
@@ -3453,17 +3453,17 @@ DefineProperty(JSContext *cx, HandleObje
     RootedId id(cx);
 
     if (attrs & JSPROP_INDEX) {
         id = INT_TO_JSID(intptr_t(name));
         attrs &= ~JSPROP_INDEX;
     } else {
         JSAtom *atom = Atomize(cx, name, strlen(name));
         if (!atom)
-            return JS_FALSE;
+            return false;
         id = AtomToId(atom);
     }
 
     return DefinePropertyById(cx, obj, id, value, getter, setter, attrs, flags, tinyid);
 }
 
 JS_PUBLIC_API(JSBool)
 JS_DefineProperty(JSContext *cx, JSObject *objArg, const char *name, jsval valueArg,
@@ -3566,17 +3566,17 @@ JS_DefineConstDoubles(JSContext *cx, JSO
     RootedObject obj(cx, objArg);
     JSBool ok;
     unsigned attrs;
 
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
     JSPropertyOpWrapper noget = GetterWrapper(NULL);
     JSStrictPropertyOpWrapper noset = SetterWrapper(NULL);
-    for (ok = JS_TRUE; cds->name; cds++) {
+    for (ok = true; cds->name; cds++) {
         Value value = DoubleValue(cds->dval);
         attrs = cds->flags;
         if (!attrs)
             attrs = JSPROP_READONLY | JSPROP_PERMANENT;
         ok = DefineProperty(cx, obj, cds->name, value, noget, noset, attrs, 0, 0);
         if (!ok)
             break;
     }
@@ -3600,25 +3600,25 @@ JS_DefineProperties(JSContext *cx, JSObj
 static JSBool
 GetPropertyDescriptorById(JSContext *cx, HandleObject obj, HandleId id, unsigned flags,
                           JSBool own, PropertyDescriptor *desc)
 {
     RootedObject obj2(cx);
     RootedShape shape(cx);
 
     if (!LookupPropertyById(cx, obj, id, flags, &obj2, &shape))
-        return JS_FALSE;
+        return false;
 
     if (!shape || (own && obj != obj2)) {
         desc->obj = NULL;
         desc->attrs = 0;
         desc->getter = NULL;
         desc->setter = NULL;
         desc->value.setUndefined();
-        return JS_TRUE;
+        return true;
     }
 
     desc->obj = obj2;
     if (obj2->isNative()) {
         if (IsImplicitDenseElement(shape)) {
             desc->attrs = JSPROP_ENUMERATE;
             desc->getter = NULL;
             desc->setter = NULL;
@@ -3650,31 +3650,31 @@ GetPropertyDescriptorById(JSContext *cx,
 
 JS_PUBLIC_API(JSBool)
 JS_GetPropertyDescriptorById(JSContext *cx, JSObject *objArg, jsid idArg, unsigned flags,
                              JSPropertyDescriptor *desc_)
 {
     RootedObject obj(cx, objArg);
     RootedId id(cx, idArg);
     AutoPropertyDescriptorRooter desc(cx);
-    if (!GetPropertyDescriptorById(cx, obj, id, flags, JS_FALSE, &desc))
+    if (!GetPropertyDescriptorById(cx, obj, id, flags, false, &desc))
         return false;
     *desc_ = desc;
     return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_GetPropertyAttrsGetterAndSetterById(JSContext *cx, JSObject *objArg, jsid idArg,
                                        unsigned *attrsp, JSBool *foundp,
                                        JSPropertyOp *getterp, JSStrictPropertyOp *setterp)
 {
     RootedObject obj(cx, objArg);
     RootedId id(cx, idArg);
     AutoPropertyDescriptorRooter desc(cx);
-    if (!GetPropertyDescriptorById(cx, obj, id, 0, JS_FALSE, &desc))
+    if (!GetPropertyDescriptorById(cx, obj, id, 0, false, &desc))
         return false;
 
     *attrsp = desc.attrs;
     *foundp = (desc.obj != NULL);
     if (getterp)
         *getterp = desc.getter;
     if (setterp)
         *setterp = desc.setter;
@@ -4512,17 +4512,17 @@ js_generic_native_method_dispatcher(JSCo
     CallArgs args = CallArgsFromVp(argc, vp);
 
     const JSFunctionSpec *fs = (JSFunctionSpec *)
         vp->toObject().as<JSFunction>().getExtendedSlot(0).toPrivate();
     JS_ASSERT((fs->flags & JSFUN_GENERIC_NATIVE) != 0);
 
     if (argc < 1) {
         js_ReportMissingArg(cx, args.calleev(), 0);
-        return JS_FALSE;
+        return false;
     }
 
     /*
      * Copy all actual (argc) arguments down over our |this| parameter, vp[1],
      * which is almost always the class constructor object, e.g. Array.  Then
      * call the corresponding prototype native method with our first argument
      * passed as |this|.
      */
@@ -4543,39 +4543,39 @@ JS_DefineFunctions(JSContext *cx, JSObje
     assertSameCompartment(cx, objArg);
 
     RootedObject obj(cx, objArg);
     RootedObject ctor(cx);
 
     for (; fs->name; fs++) {
         RootedAtom atom(cx, Atomize(cx, fs->name, strlen(fs->name)));
         if (!atom)
-            return JS_FALSE;
+            return false;
 
         Rooted<jsid> id(cx, AtomToId(atom));
 
         /*
          * Define a generic arity N+1 static method for the arity N prototype
          * method if flags contains JSFUN_GENERIC_NATIVE.
          */
         unsigned flags = fs->flags;
         if (flags & JSFUN_GENERIC_NATIVE) {
             if (!ctor) {
                 ctor = JS_GetConstructor(cx, obj);
                 if (!ctor)
-                    return JS_FALSE;
+                    return false;
             }
 
             flags &= ~JSFUN_GENERIC_NATIVE;
             JSFunction *fun = DefineFunction(cx, ctor, id,
                                              js_generic_native_method_dispatcher,
                                              fs->nargs + 1, flags,
                                              JSFunction::ExtendedFinalizeKind);
             if (!fun)
-                return JS_FALSE;
+                return false;
 
             /*
              * As jsapi.h notes, fs must point to storage that lives as long
              * as fun->object lives.
              */
             fun->setExtendedSlot(0, PrivateValue(const_cast<JSFunctionSpec*>(fs)));
         }
 
@@ -4593,48 +4593,48 @@ JS_DefineFunctions(JSContext *cx, JSObje
              * in. Self-hosted functions can access each other via their names,
              * but not via the builtin classes they get installed into.
              */
             if (cx->runtime()->isSelfHostingGlobal(cx->global()))
                 continue;
 
             RootedAtom shAtom(cx, Atomize(cx, fs->selfHostedName, strlen(fs->selfHostedName)));
             if (!shAtom)
-                return JS_FALSE;
+                return false;
             RootedPropertyName shName(cx, shAtom->asPropertyName());
             RootedValue funVal(cx);
             if (!cx->runtime()->maybeWrappedSelfHostedFunction(cx, shName, &funVal))
-                return JS_FALSE;
+                return false;
             if (!funVal.isUndefined()) {
                 if (!JSObject::defineProperty(cx, obj, atom->asPropertyName(), funVal,
                                              NULL, NULL, flags & ~JSFUN_FLAGS_MASK))
                 {
-                    return JS_FALSE;
+                    return false;
                 }
             } else {
                 JSFunction *fun = DefineFunction(cx, obj, id, /* native = */ NULL, fs->nargs, 0,
                                                  JSFunction::ExtendedFinalizeKind, SingletonObject);
                 if (!fun)
-                    return JS_FALSE;
+                    return false;
                 fun->setIsSelfHostedBuiltin();
                 fun->setExtendedSlot(0, PrivateValue(const_cast<JSFunctionSpec*>(fs)));
                 funVal.setObject(*fun);
             }
             RootedObject holder(cx, cx->global()->intrinsicsHolder());
             if (!JSObject::defineProperty(cx, holder, shName, funVal))
-                return JS_FALSE;
+                return false;
         } else {
             JSFunction *fun = DefineFunction(cx, obj, id, fs->call.op, fs->nargs, flags);
             if (!fun)
-                return JS_FALSE;
+                return false;
             if (fs->call.info)
                 fun->setJitInfo(fs->call.info);
         }
     }
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSFunction *)
 JS_DefineFunction(JSContext *cx, JSObject *objArg, const char *name, JSNative call,
                   unsigned nargs, unsigned attrs)
 {
     RootedObject obj(cx, objArg);
     JS_THREADSAFE_ASSERT(cx->compartment() != cx->runtime()->atomsCompartment);
@@ -4921,38 +4921,38 @@ JS_BufferIsCompilableUnit(JSContext *cx,
     JSExceptionState *exnState;
     JSErrorReporter older;
 
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
     assertSameCompartment(cx, obj);
     jschar *chars = JS::UTF8CharsToNewTwoByteCharsZ(cx, JS::UTF8Chars(utf8, length), &length).get();
     if (!chars)
-        return JS_TRUE;
+        return true;
 
     /*
      * Return true on any out-of-memory error, so our caller doesn't try to
      * collect more buffered source.
      */
-    result = JS_TRUE;
+    result = true;
     exnState = JS_SaveExceptionState(cx);
     {
         CompileOptions options(cx);
         options.setCompileAndGo(false);
         Parser<frontend::FullParseHandler> parser(cx, &cx->tempLifoAlloc(),
                                                   options, chars, length,
                                                   /* foldConstants = */ true, NULL, NULL);
         older = JS_SetErrorReporter(cx, NULL);
         if (!parser.parse(obj) && parser.isUnexpectedEOF()) {
             /*
              * We ran into an error. If it was because we ran out of
              * source, we return false so our caller knows to try to
              * collect more buffered source.
              */
-            result = JS_FALSE;
+            result = false;
         }
         JS_SetErrorReporter(cx, older);
     }
     js_free(chars);
     JS_RestoreExceptionState(cx, exnState);
     return result;
 }
 
@@ -6455,20 +6455,20 @@ JS_IsExceptionPending(JSContext *cx)
 }
 
 JS_PUBLIC_API(JSBool)
 JS_GetPendingException(JSContext *cx, jsval *vp)
 {
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
     if (!cx->isExceptionPending())
-        return JS_FALSE;
+        return false;
     *vp = cx->getPendingException();
     assertSameCompartment(cx, *vp);
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(void)
 JS_SetPendingException(JSContext *cx, jsval valueArg)
 {
     RootedValue value(cx, valueArg);
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
@@ -6713,23 +6713,23 @@ JS_DescribeScriptedCaller(JSContext *cx,
 {
     if (script)
         *script = NULL;
     if (lineno)
         *lineno = 0;
 
     NonBuiltinScriptFrameIter i(cx);
     if (i.done())
-        return JS_FALSE;
+        return false;
 
     if (script)
         *script = i.script();
     if (lineno)
         *lineno = js::PCToLineNumber(i.script(), i.pc());
-    return JS_TRUE;
+    return true;
 }
 
 #ifdef JS_THREADSAFE
 static PRStatus
 CallOnce(void *func)
 {
     JSInitCallback init = JS_DATA_TO_FUNC_PTR(JSInitCallback, func);
     return init() ? PR_SUCCESS : PR_FAILURE;
@@ -6741,17 +6741,17 @@ JS_CallOnce(JSCallOnceType *once, JSInit
 {
 #ifdef JS_THREADSAFE
     return PR_CallOnceWithArg(once, CallOnce, JS_FUNC_TO_DATA_PTR(void *, func)) == PR_SUCCESS;
 #else
     if (!*once) {
         *once = true;
         return func();
     } else {
-        return JS_TRUE;
+        return true;
     }
 #endif
 }
 
 AutoGCRooter::AutoGCRooter(JSContext *cx, ptrdiff_t tag)
   : down(ContextFriendFields::get(cx)->autoGCRooters),
     tag_(tag),
     stackTop(&ContextFriendFields::get(cx)->autoGCRooters)
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -814,17 +814,17 @@ typedef JSBool
  *    state pointed at by statep is destroyed and *statep is set to JSVAL_NULL
  *    if there are no properties left to enumerate.
  *
  *  JSENUMERATE_DESTROY
  *    Destroy the opaque iterator state previously allocated in *statep by a
  *    call to this function when enum_op was JSENUMERATE_INIT or
  *    JSENUMERATE_INIT_ALL.
  *
- * The return value is used to indicate success, with a value of JS_FALSE
+ * The return value is used to indicate success, with a value of false
  * indicating failure.
  */
 typedef JSBool
 (* JSNewEnumerateOp)(JSContext *cx, JS::Handle<JSObject*> obj, JSIterateOp enum_op,
                      JS::MutableHandle<JS::Value> statep, JS::MutableHandle<jsid> idp);
 
 /*
  * The old-style JSClass.enumerate op should define all lazy properties not
@@ -912,17 +912,17 @@ struct JSStringFinalizer {
  * is either a string or an int jsval.
  */
 typedef JSBool
 (* JSCheckAccessOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
                     JSAccessMode mode, JS::MutableHandle<JS::Value> vp);
 
 /*
  * Check whether v is an instance of obj.  Return false on error or exception,
- * true on success with JS_TRUE in *bp if v is an instance of obj, JS_FALSE in
+ * true on success with true in *bp if v is an instance of obj, false in
  * *bp otherwise.
  */
 typedef JSBool
 (* JSHasInstanceOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::MutableHandle<JS::Value> vp,
                     JSBool *bp);
 
 /*
  * Function type for trace operation of the class called to enumerate all
@@ -3335,17 +3335,17 @@ JS_DefinePropertyById(JSContext *cx, JSO
 
 extern JS_PUBLIC_API(JSBool)
 JS_DefineOwnProperty(JSContext *cx, JSObject *obj, jsid id, jsval descriptor, JSBool *bp);
 
 /*
  * Determine the attributes (JSPROP_* flags) of a property on a given object.
  *
  * If the object does not have a property by that name, *foundp will be
- * JS_FALSE and the value of *attrsp is undefined.
+ * false and the value of *attrsp is undefined.
  */
 extern JS_PUBLIC_API(JSBool)
 JS_GetPropertyAttributes(JSContext *cx, JSObject *obj, const char *name,
                          unsigned *attrsp, JSBool *foundp);
 
 /*
  * The same, but if the property is native, return its getter and setter via
  * *getterp and *setterp, respectively (and only if the out parameter pointer
@@ -3364,17 +3364,17 @@ JS_GetPropertyAttrsGetterAndSetterById(J
                                        unsigned *attrsp, JSBool *foundp,
                                        JSPropertyOp *getterp,
                                        JSStrictPropertyOp *setterp);
 
 /*
  * Set the attributes of a property on a given object.
  *
  * If the object does not have a property by that name, *foundp will be
- * JS_FALSE and nothing will be altered.
+ * false and nothing will be altered.
  */
 extern JS_PUBLIC_API(JSBool)
 JS_SetPropertyAttributes(JSContext *cx, JSObject *obj, const char *name,
                          unsigned attrs, JSBool *foundp);
 
 extern JS_PUBLIC_API(JSBool)
 JS_DefinePropertyWithTinyId(JSContext *cx, JSObject *obj, const char *name,
                             int8_t tinyid, jsval value,
@@ -3590,17 +3590,17 @@ JS_DefineUCProperty(JSContext *cx, JSObj
                     const jschar *name, size_t namelen, jsval value,
                     JSPropertyOp getter, JSStrictPropertyOp setter,
                     unsigned attrs);
 
 /*
  * Determine the attributes (JSPROP_* flags) of a property on a given object.
  *
  * If the object does not have a property by that name, *foundp will be
- * JS_FALSE and the value of *attrsp is undefined.
+ * false and the value of *attrsp is undefined.
  */
 extern JS_PUBLIC_API(JSBool)
 JS_GetUCPropertyAttributes(JSContext *cx, JSObject *obj,
                            const jschar *name, size_t namelen,
                            unsigned *attrsp, JSBool *foundp);
 
 /*
  * The same, but if the property is native, return its getter and setter via
@@ -3613,17 +3613,17 @@ JS_GetUCPropertyAttrsGetterAndSetter(JSC
                                      unsigned *attrsp, JSBool *foundp,
                                      JSPropertyOp *getterp,
                                      JSStrictPropertyOp *setterp);
 
 /*
  * Set the attributes of a property on a given object.
  *
  * If the object does not have a property by that name, *foundp will be
- * JS_FALSE and nothing will be altered.
+ * false and nothing will be altered.
  */
 extern JS_PUBLIC_API(JSBool)
 JS_SetUCPropertyAttributes(JSContext *cx, JSObject *obj,
                            const jschar *name, size_t namelen,
                            unsigned attrs, JSBool *foundp);
 
 
 extern JS_PUBLIC_API(JSBool)
@@ -3963,19 +3963,19 @@ JS_DefineFunctionById(JSContext *cx, JSO
 /*
  * Clone a top-level function into a new scope. This function will dynamically
  * fail if funobj was lexically nested inside some other function.
  */
 extern JS_PUBLIC_API(JSObject *)
 JS_CloneFunctionObject(JSContext *cx, JSObject *funobj, JSObject *parent);
 
 /*
- * Given a buffer, return JS_FALSE if the buffer might become a valid
+ * Given a buffer, return false if the buffer might become a valid
  * javascript statement with the addition of more lines.  Otherwise return
- * JS_TRUE.  The intent is to support interactive compilation - accumulate
+ * true.  The intent is to support interactive compilation - accumulate
  * lines in a buffer until JS_BufferIsCompilableUnit is true, then pass it to
  * the compiler.
  */
 extern JS_PUBLIC_API(JSBool)
 JS_BufferIsCompilableUnit(JSContext *cx, JSObject *obj, const char *utf8, size_t length);
 
 extern JS_PUBLIC_API(JSScript *)
 JS_CompileScript(JSContext *cx, JSObject *obj,
@@ -4409,17 +4409,17 @@ JS_FileEscapedString(FILE *fp, JSString 
  * JS_GetFlatStringChars. Note, though, that this is purely a syntactic
  * distinction: the input and output of JS_FlattenString are the same actual
  * GC-thing so only one needs to be rooted. If a JSString is known to be flat,
  * JS_ASSERT_STRING_IS_FLAT can be used to make a debug-checked cast. Example:
  *
  *   // in a fallible context
  *   JSFlatString *fstr = JS_FlattenString(cx, str);
  *   if (!fstr)
- *     return JS_FALSE;
+ *     return false;
  *   JS_ASSERT(fstr == JS_ASSERT_STRING_IS_FLAT(str));
  *
  *   // in an infallible context, for the same 'str'
  *   const jschar *chars = JS_GetFlatStringChars(fstr)
  *   JS_ASSERT(chars);
  *
  * The CharsZ APIs guarantee that the returned array has a null character at
  * chars[length]. This can require additional copying so clients should prefer
@@ -4508,17 +4508,17 @@ JS_ConcatStrings(JSContext *cx, JSString
 /*
  * For JS_DecodeBytes, set *dstlenp to the size of the destination buffer before
  * the call; on return, *dstlenp contains the number of jschars actually stored.
  * To determine the necessary destination buffer size, make a sizing call that
  * passes NULL for dst.
  *
  * On errors, the functions report the error. In that case, *dstlenp contains
  * the number of characters or bytes transferred so far.  If cx is NULL, no
- * error is reported on failure, and the functions simply return JS_FALSE.
+ * error is reported on failure, and the functions simply return false.
  *
  * NB: This function does not store an additional zero byte or jschar after the
  * transcoded string.
  */
 JS_PUBLIC_API(JSBool)
 JS_DecodeBytes(JSContext *cx, const char *src, size_t srclen, jschar *dst,
                size_t *dstlenp);
 
--- a/js/src/jscntxt.cpp
+++ b/js/src/jscntxt.cpp
@@ -493,21 +493,21 @@ js_ReportErrorVA(JSContext *cx, unsigned
 {
     char *message;
     jschar *ucmessage;
     size_t messagelen;
     JSErrorReport report;
     JSBool warning;
 
     if (checkReportFlags(cx, &flags))
-        return JS_TRUE;
+        return true;
 
     message = JS_vsmprintf(format, ap);
     if (!message)
-        return JS_FALSE;
+        return false;
     messagelen = strlen(message);
 
     PodZero(&report);
     report.flags = flags;
     report.errorNumber = JSMSG_USER_DEFINED_ERROR;
     report.ucmessage = ucmessage = InflateString(cx, message, &messagelen);
     PopulateReportBlame(cx, &report);
 
@@ -662,17 +662,17 @@ js_ExpandErrorArguments(JSContext *cx, J
              * null it out to act as the caboose when we free the
              * pointers later.
              */
             if (messageArgsPassed) {
                 JS_ASSERT(!reportp->messageArgs[argCount]);
             } else {
                 reportp->messageArgs = cx->pod_malloc<const jschar*>(argCount + 1);
                 if (!reportp->messageArgs)
-                    return JS_FALSE;
+                    return false;
                 /* NULL-terminate for easy copying. */
                 reportp->messageArgs[argCount] = NULL;
             }
             for (i = 0; i < argCount; i++) {
                 if (messageArgsPassed) {
                     /* Do nothing. */
                 } else if (argumentsType == ArgumentsAreASCII) {
                     char *charArg = va_arg(ap, char *);
@@ -763,17 +763,17 @@ js_ExpandErrorArguments(JSContext *cx, J
         const char *defaultErrorMessage
             = "No error message available for error number %d";
         size_t nbytes = strlen(defaultErrorMessage) + 16;
         *messagep = cx->pod_malloc<char>(nbytes);
         if (!*messagep)
             goto error;
         JS_snprintf(*messagep, nbytes, defaultErrorMessage, errorNumber);
     }
-    return JS_TRUE;
+    return true;
 
 error:
     if (!messageArgsPassed && reportp->messageArgs) {
         /* free the arguments only if we allocated them */
         if (argumentsType == ArgumentsAreASCII) {
             i = 0;
             while (reportp->messageArgs[i])
                 js_free((void *)reportp->messageArgs[i++]);
@@ -784,40 +784,40 @@ error:
     if (reportp->ucmessage) {
         js_free((void *)reportp->ucmessage);
         reportp->ucmessage = NULL;
     }
     if (*messagep) {
         js_free((void *)*messagep);
         *messagep = NULL;
     }
-    return JS_FALSE;
+    return false;
 }
 
 JSBool
 js_ReportErrorNumberVA(JSContext *cx, unsigned flags, JSErrorCallback callback,
                        void *userRef, const unsigned errorNumber,
                        ErrorArgumentsType argumentsType, va_list ap)
 {
     JSErrorReport report;
     char *message;
     JSBool warning;
 
     if (checkReportFlags(cx, &flags))
-        return JS_TRUE;
+        return true;
     warning = JSREPORT_IS_WARNING(flags);
 
     PodZero(&report);
     report.flags = flags;
     report.errorNumber = errorNumber;
     PopulateReportBlame(cx, &report);
 
     if (!js_ExpandErrorArguments(cx, callback, userRef, errorNumber,
                                  &message, &report, argumentsType, ap)) {
-        return JS_FALSE;
+        return false;
     }
 
     ReportError(cx, message, &report, callback, userRef);
 
     if (message)
         js_free(message);
     if (report.messageArgs) {
         /*
@@ -903,17 +903,17 @@ JSBool
 js_ReportIsNullOrUndefined(JSContext *cx, int spindex, HandleValue v,
                            HandleString fallback)
 {
     char *bytes;
     JSBool ok;
 
     bytes = DecompileValueGenerator(cx, spindex, v, fallback);
     if (!bytes)
-        return JS_FALSE;
+        return false;
 
     if (strcmp(bytes, js_undefined_str) == 0 ||
         strcmp(bytes, js_null_str) == 0) {
         ok = JS_ReportErrorFlagsAndNumber(cx, JSREPORT_ERROR,
                                           js_GetErrorMessage, NULL,
                                           JSMSG_NO_PROPERTIES, bytes,
                                           NULL, NULL);
     } else if (v.isUndefined()) {
@@ -962,17 +962,17 @@ js_ReportValueErrorFlags(JSContext *cx, 
 {
     char *bytes;
     JSBool ok;
 
     JS_ASSERT(js_ErrorFormatString[errorNumber].argCount >= 1);
     JS_ASSERT(js_ErrorFormatString[errorNumber].argCount <= 3);
     bytes = DecompileValueGenerator(cx, spindex, v, fallback);
     if (!bytes)
-        return JS_FALSE;
+        return false;
 
     ok = JS_ReportErrorFlagsAndNumber(cx, flags, js_GetErrorMessage,
                                       NULL, errorNumber, bytes, arg1, arg2);
     js_free(bytes);
     return ok;
 }
 
 const JSErrorFormatString js_ErrorFormatString[JSErr_Limit] = {
--- a/js/src/jsdate.cpp
+++ b/js/src/jsdate.cpp
@@ -564,17 +564,17 @@ static const int ttb[] = {
     10000 + 8 * 60, 10000 + 7 * 60     /* PST/PDT */
 };
 
 /* helper for date_parse */
 static JSBool
 date_regionMatches(const char* s1, int s1off, const jschar* s2, int s2off,
                    int count, int ignoreCase)
 {
-    JSBool result = JS_FALSE;
+    JSBool result = false;
     /* return true if matches, otherwise, false */
 
     while (count > 0 && s1[s1off] && s2[s2off]) {
         if (ignoreCase) {
             if (unicode::ToLowerCase(s1[s1off]) != unicode::ToLowerCase(s2[s2off]))
                 break;
         } else {
             if ((jschar)s1[s1off] != s2[s2off]) {
@@ -582,17 +582,17 @@ date_regionMatches(const char* s1, int s
             }
         }
         s1off++;
         s2off++;
         count--;
     }
 
     if (count == 0) {
-        result = JS_TRUE;
+        result = true;
     }
 
     return result;
 }
 
 /* find UTC time from given date... no 1900 correction! */
 static double
 date_msecFromDate(double year, double mon, double mday, double hour,
@@ -610,21 +610,21 @@ date_msecFromArgs(JSContext *cx, CallArg
     unsigned loop;
     double array[MAXARGS];
     double msec_time;
 
     for (loop = 0; loop < MAXARGS; loop++) {
         if (loop < args.length()) {
             double d;
             if (!ToNumber(cx, args[loop], &d))
-                return JS_FALSE;
+                return false;
             /* return NaN if any arg is not finite */
             if (!IsFinite(d)) {
                 *rval = js_NaN;
-                return JS_TRUE;
+                return true;
             }
             array[loop] = ToInteger(d);
         } else {
             if (loop == 2) {
                 array[loop] = 1; /* Default the date argument to 1. */
             } else {
                 array[loop] = 0;
             }
@@ -633,17 +633,17 @@ date_msecFromArgs(JSContext *cx, CallArg
 
     /* adjust 2-digit years into the 20th century */
     if (array[0] >= 0 && array[0] <= 99)
         array[0] += 1900;
 
     msec_time = date_msecFromDate(array[0], array[1], array[2],
                                   array[3], array[4], array[5], array[6]);
     *rval = msec_time;
-    return JS_TRUE;
+    return true;
 }
 
 /*
  * See ECMA 15.9.4.[3-10];
  */
 static bool
 date_UTC(JSContext *cx, unsigned argc, Value *vp)
 {
@@ -714,17 +714,17 @@ static JSBool
 ndigits(size_t n, size_t *result, const jschar *s, size_t* i, size_t limit)
 {
     size_t init = *i;
 
     if (digits(result, s, i, Min(limit, init+n)))
         return ((*i - init) == n);
 
     *i = init;
-    return JS_FALSE;
+    return false;
 }
 
 static int
 DaysInMonth(int year, int month)
 {
     bool leap = IsLeapYear(year);
     int result = int(DayFromMonth(month, leap) - DayFromMonth(month - 1, leap));
     return result;
@@ -798,17 +798,17 @@ date_parseISOString(JSLinearString *str,
     int dateMul = 1;
     size_t year = 1970;
     size_t month = 1;
     size_t day = 1;
     size_t hour = 0;
     size_t min = 0;
     size_t sec = 0;
     double frac = 0;
-    bool isLocalTime = JS_FALSE;
+    bool isLocalTime = false;
     size_t tzHour = 0;
     size_t tzMin = 0;
 
 #define PEEK(ch) (i < limit && s[i] == ch)
 
 #define NEED(ch)                                                     \
     JS_BEGIN_MACRO                                                   \
         if (i >= limit || s[i] != ch) { goto syntax; } else { ++i; } \
@@ -871,17 +871,17 @@ date_parseISOString(JSLinearString *str,
         /*
          * Non-standard extension to the ISO date format (permitted by ES5):
          * allow "-0700" as a time zone offset, not just "-07:00".
          */
         if (PEEK(':'))
           ++i;
         NEED_NDIGITS(2, tzMin);
     } else {
-        isLocalTime = JS_TRUE;
+        isLocalTime = true;
     }
 
  done:
     if (year > 275943 // ceil(1e8/365) + 1970
         || (month == 0 || month > 12)
         || (day == 0 || day > size_t(DaysInMonth(year,month)))
         || hour > 24
         || ((hour == 24) && (min > 0 || sec > 0))
@@ -907,22 +907,22 @@ date_parseISOString(JSLinearString *str,
                             + (tzMin * msPerMinute)));
     }
 
     if (msec < -8.64e15 || msec > 8.64e15)
         goto syntax;
 
     *result = msec;
 
-    return JS_TRUE;
+    return true;
 
  syntax:
     /* syntax error */
     *result = 0;
-    return JS_FALSE;
+    return false;
 
 #undef PEEK
 #undef NEED
 #undef DONE_UNLESS
 #undef NEED_NDIGITS
 }
 
 static JSBool
@@ -938,22 +938,22 @@ date_parseString(JSLinearString *str, do
     int mday = -1;
     int hour = -1;
     int min = -1;
     int sec = -1;
     int c = -1;
     int n = -1;
     int tzoffset = -1;
     int prevc = 0;
-    JSBool seenplusminus = JS_FALSE;
+    JSBool seenplusminus = false;
     int temp;
-    JSBool seenmonthname = JS_FALSE;
+    JSBool seenmonthname = false;
 
     if (date_parseISOString(str, result, dtInfo))
-        return JS_TRUE;
+        return true;
 
     s = str->chars();
     limit = str->length();
     if (limit == 0)
         goto syntax;
     while (i < limit) {
         c = s[i];
         i++;
@@ -987,17 +987,17 @@ date_parseString(JSLinearString *str, do
              * works */
 
             /* uses of seenplusminus allow : in TZA, so Java
              * no-timezone style of GMT+4:30 works
              */
 
             if ((prevc == '+' || prevc == '-')/*  && year>=0 */) {
                 /* make ':' case below change tzoffset */
-                seenplusminus = JS_TRUE;
+                seenplusminus = true;
 
                 /* offset */
                 if (n < 24)
                     n = n * 60; /* EG. "GMT-3" */
                 else
                     n = n % 100 + n / 100 * 60; /* eg "GMT-0430" */
                 if (prevc == '+')       /* plus means east of GMT */
                     n = -n;
@@ -1079,17 +1079,17 @@ date_parseString(JSLinearString *str, do
                                 }
                             }
                         } else if (action <= 13) { /* month! */
                             /* Adjust mon to be 1-based until the final values
                                for mon, mday and year are adjusted below */
                             if (seenmonthname) {
                                 goto syntax;
                             }
-                            seenmonthname = JS_TRUE;
+                            seenmonthname = true;
                             temp = /*byte*/ (action - 2) + 1;
 
                             if (mon < 0) {
                                 mon = temp;
                             } else if (mday < 0) {
                                 mday = mon;
                                 mon = temp;
                             } else if (year < 0) {
@@ -1184,22 +1184,22 @@ date_parseString(JSLinearString *str, do
 
     if (tzoffset == -1) { /* no time zone specified, have to use local */
         msec = UTC(msec, dtInfo);
     } else {
         msec += tzoffset * msPerMinute;
     }
 
     *result = msec;
-    return JS_TRUE;
+    return true;
 
 syntax:
     /* syntax error */
     *result = 0;
-    return JS_FALSE;
+    return false;
 }
 
 static bool
 date_parse(JSContext *cx, unsigned argc, Value *vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
     if (args.length() == 0) {
         vp->setDouble(js_NaN);
@@ -2580,36 +2580,36 @@ date_format(JSContext *cx, double date, 
         if (PRMJ_FormatTime(tzbuf, sizeof tzbuf, "(%Z)", &split) != 0) {
 
             /* Decide whether to use the resulting timezone string.
              *
              * Reject it if it contains any non-ASCII, non-alphanumeric
              * characters.  It's then likely in some other character
              * encoding, and we probably won't display it correctly.
              */
-            usetz = JS_TRUE;
+            usetz = true;
             tzlen = strlen(tzbuf);
             if (tzlen > 100) {
-                usetz = JS_FALSE;
+                usetz = false;
             } else {
                 for (i = 0; i < tzlen; i++) {
                     jschar c = tzbuf[i];
                     if (c > 127 ||
                         !(isalpha(c) || isdigit(c) ||
                           c == ' ' || c == '(' || c == ')')) {
-                        usetz = JS_FALSE;
+                        usetz = false;
                     }
                 }
             }
 
             /* Also reject it if it's not parenthesized or if it's '()'. */
             if (tzbuf[0] != '(' || tzbuf[1] == ')')
-                usetz = JS_FALSE;
+                usetz = false;
         } else
-            usetz = JS_FALSE;
+            usetz = false;
 
         switch (format) {
           case FORMATSPEC_FULL:
             /*
              * Avoid dependence on PRMJ_FormatTimeUSEnglish, because it
              * requires a PRMJTime... which only has 16-bit years.  Sub-ECMA.
              */
             /* Tue Oct 31 2000 09:41:40 GMT-0800 (PST) */
--- a/js/src/jsdbgapi.cpp
+++ b/js/src/jsdbgapi.cpp
@@ -209,17 +209,17 @@ CheckDebugMode(JSContext *cx)
 
 JS_PUBLIC_API(JSBool)
 JS_SetSingleStepMode(JSContext *cx, JSScript *scriptArg, JSBool singleStep)
 {
     RootedScript script(cx, scriptArg);
     assertSameCompartment(cx, script);
 
     if (!CheckDebugMode(cx))
-        return JS_FALSE;
+        return false;
 
     return script->setStepModeFlag(cx, singleStep);
 }
 
 JS_PUBLIC_API(JSBool)
 JS_SetTrap(JSContext *cx, JSScript *scriptArg, jsbytecode *pc, JSTrapHandler handler, jsval closureArg)
 {
     RootedScript script(cx, scriptArg);
@@ -276,17 +276,17 @@ JS_PUBLIC_API(JSBool)
 JS_ClearInterrupt(JSRuntime *rt, JSInterruptHook *hoop, void **closurep)
 {
     if (hoop)
         *hoop = rt->debugHooks.interruptHook;
     if (closurep)
         *closurep = rt->debugHooks.interruptHookData;
     rt->debugHooks.interruptHook = 0;
     rt->debugHooks.interruptHookData = 0;
-    return JS_TRUE;
+    return true;
 }
 
 /************************************************************************/
 
 JS_PUBLIC_API(JSBool)
 JS_SetWatchPoint(JSContext *cx, JSObject *obj_, jsid id_,
                  JSWatchPointHandler handler, JSObject *closure_)
 {
@@ -402,22 +402,22 @@ JS_EndPC(JSContext *cx, JSScript *script
 JS_PUBLIC_API(JSBool)
 JS_GetLinePCs(JSContext *cx, JSScript *script,
               unsigned startLine, unsigned maxLines,
               unsigned* count, unsigned** retLines, jsbytecode*** retPCs)
 {
     size_t len = (script->length > maxLines ? maxLines : script->length);
     unsigned *lines = cx->pod_malloc<unsigned>(len);
     if (!lines)
-        return JS_FALSE;
+        return false;
 
     jsbytecode **pcs = cx->pod_malloc<jsbytecode*>(len);
     if (!pcs) {
         js_free(lines);
-        return JS_FALSE;
+        return false;
     }
 
     unsigned lineno = script->lineno;
     unsigned offset = 0;
     unsigned i = 0;
     for (jssrcnote *sn = script->notes(); !SN_IS_TERMINATOR(sn); sn = SN_NEXT(sn)) {
         offset += SN_DELTA(sn);
         SrcNoteType type = (SrcNoteType) SN_TYPE(sn);
@@ -442,17 +442,17 @@ JS_GetLinePCs(JSContext *cx, JSScript *s
     else
         js_free(lines);
 
     if (retPCs)
         *retPCs = pcs;
     else
         js_free(pcs);
 
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(unsigned)
 JS_GetFunctionArgumentCount(JSContext *cx, JSFunction *fun)
 {
     return fun->nargs;
 }
 
@@ -658,17 +658,17 @@ GetPropertyDesc(JSContext *cx, JSObject 
         cx->setPendingException(lastException);
 
     pd->flags |= (shape->enumerable() ? JSPD_ENUMERATE : 0)
               |  (!shape->writable()  ? JSPD_READONLY  : 0)
               |  (!shape->configurable() ? JSPD_PERMANENT : 0);
     pd->spare = 0;
     pd->alias = JSVAL_VOID;
 
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_GetPropertyDescArray(JSContext *cx, JSObject *obj_, JSPropertyDescArray *pda)
 {
     RootedObject obj(cx, obj_);
 
     assertSameCompartment(cx, obj);
@@ -774,57 +774,57 @@ JS_PutPropertyDescArray(JSContext *cx, J
 
 /************************************************************************/
 
 JS_PUBLIC_API(JSBool)
 JS_SetDebuggerHandler(JSRuntime *rt, JSDebuggerHandler handler, void *closure)
 {
     rt->debugHooks.debuggerHandler = handler;
     rt->debugHooks.debuggerHandlerData = closure;
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_SetSourceHandler(JSRuntime *rt, JSSourceHandler handler, void *closure)
 {
     rt->debugHooks.sourceHandler = handler;
     rt->debugHooks.sourceHandlerData = closure;
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_SetExecuteHook(JSRuntime *rt, JSInterpreterHook hook, void *closure)
 {
     rt->debugHooks.executeHook = hook;
     rt->debugHooks.executeHookData = closure;
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_SetCallHook(JSRuntime *rt, JSInterpreterHook hook, void *closure)
 {
     rt->debugHooks.callHook = hook;
     rt->debugHooks.callHookData = closure;
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_SetThrowHook(JSRuntime *rt, JSThrowHook hook, void *closure)
 {
     rt->debugHooks.throwHook = hook;
     rt->debugHooks.throwHookData = closure;
-    return JS_TRUE;
+    return true;
 }
 
 JS_PUBLIC_API(JSBool)
 JS_SetDebugErrorHook(JSRuntime *rt, JSDebugErrorHook hook, void *closure)
 {
     rt->debugHooks.debugErrorHook = hook;
     rt->debugHooks.debugErrorHookData = closure;
-    return JS_TRUE;
+    return true;
 }
 
 /************************************************************************/
 
 JS_PUBLIC_API(const JSDebugHooks *)
 JS_GetGlobalDebugHooks(JSRuntime *rt)
 {
     return &rt->debugHooks;
@@ -936,24 +936,24 @@ js_CallContextDebugHandler(JSContext *cx
     NonBuiltinScriptFrameIter iter(cx);
     JS_ASSERT(!iter.done());
 
     RootedValue rval(cx);
     RootedScript script(cx, iter.script());
     switch (js::CallContextDebugHandler(cx, script, iter.pc(), rval.address())) {
       case JSTRAP_ERROR:
         JS_ClearPendingException(cx);
-        return JS_FALSE;
+        return false;
       case JSTRAP_THROW:
         JS_SetPendingException(cx, rval);
-        return JS_FALSE;
+        return false;
       case JSTRAP_RETURN:
       case JSTRAP_CONTINUE:
       default:
-        return JS_TRUE;
+        return true;
     }
 }
 
 JS_PUBLIC_API(JS::StackDescription *)
 JS::DescribeStack(JSContext *cx, unsigned maxFrames)
 {
     Vector<FrameDescription> frames(cx);
 
--- a/js/src/jsdbgapi.h
+++ b/js/src/jsdbgapi.h
@@ -255,17 +255,17 @@ typedef struct JSPropertyDesc {
 } JSPropertyDesc;
 
 #define JSPD_ENUMERATE  0x01    /* visible to for/in loop */
 #define JSPD_READONLY   0x02    /* assignment is error */
 #define JSPD_PERMANENT  0x04    /* property cannot be deleted */
 #define JSPD_ALIAS      0x08    /* property has an alias id */
 #define JSPD_EXCEPTION  0x40    /* exception occurred fetching the property, */
                                 /* value is exception */
-#define JSPD_ERROR      0x80    /* native getter returned JS_FALSE without */
+#define JSPD_ERROR      0x80    /* native getter returned false without */
                                 /* throwing an exception */
 
 typedef struct JSPropertyDescArray {
     uint32_t        length;     /* number of elements in array */
     JSPropertyDesc  *array;     /* alloc'd by Get, freed by Put */
 } JSPropertyDescArray;
 
 typedef struct JSScopeProperty JSScopeProperty;
@@ -353,18 +353,18 @@ class JS_PUBLIC_API(JSBrokenFrameIterato
 
 /*
  * This hook captures high level script execution and function calls (JS or
  * native).  It is used by JS_SetExecuteHook to hook top level scripts and by
  * JS_SetCallHook to hook function calls.  It will get called twice per script
  * or function call: just before execution begins and just after it finishes.
  * In both cases the 'current' frame is that of the executing code.
  *
- * The 'before' param is JS_TRUE for the hook invocation before the execution
- * and JS_FALSE for the invocation after the code has run.
+ * The 'before' param is true for the hook invocation before the execution
+ * and false for the invocation after the code has run.
  *
  * The 'ok' param is significant only on the post execution invocation to
  * signify whether or not the code completed 'normally'.
  *
  * The 'closure' param is as passed to JS_SetExecuteHook or JS_SetCallHook
  * for the 'before'invocation, but is whatever value is returned from that
  * invocation for the 'after' invocation. Thus, the hook implementor *could*
  * allocate a structure in the 'before' invocation and return a pointer to that
--- a/js/src/jsdtoa.cpp
+++ b/js/src/jsdtoa.cpp
@@ -107,49 +107,49 @@ js_dtostr(DtoaState *state, char *buffer
     js_memcpy(buffer + 2, numBegin, nDigits);
     freedtoa(PASS_STATE numBegin);
     numBegin = buffer + 2; /* +2 leaves space for sign and/or decimal point */
     numEnd = numBegin + nDigits;
     *numEnd = '\0';
 
     /* If Infinity, -Infinity, or NaN, return the string regardless of mode. */
     if (decPt != 9999) {
-        JSBool exponentialNotation = JS_FALSE;
+        JSBool exponentialNotation = false;
         int minNDigits = 0;  /* Min number of significant digits required */
         char *p;
         char *q;
 
         switch (mode) {
             case DTOSTR_STANDARD:
                 if (decPt < -5 || decPt > 21)
-                    exponentialNotation = JS_TRUE;
+                    exponentialNotation = true;
                 else
                     minNDigits = decPt;
                 break;
 
             case DTOSTR_FIXED:
                 if (precision >= 0)
                     minNDigits = decPt + precision;
                 else
                     minNDigits = decPt;
                 break;
 
             case DTOSTR_EXPONENTIAL:
                 JS_ASSERT(precision > 0);
                 minNDigits = precision;
                 /* Fall through */
             case DTOSTR_STANDARD_EXPONENTIAL:
-                exponentialNotation = JS_TRUE;
+                exponentialNotation = true;
                 break;
 
             case DTOSTR_PRECISION:
                 JS_ASSERT(precision > 0);
                 minNDigits = precision;
                 if (decPt < -5 || decPt > precision)
-                    exponentialNotation = JS_TRUE;
+                    exponentialNotation = true;
                 break;
         }
 
         /* If the number has fewer than minNDigits, end-pad it with zeros. */
         if (nDigits < minNDigits) {
             p = numBegin + minNDigits;
             nDigits = minNDigits;
             do {
@@ -417,17 +417,17 @@ js_dtobasestr(DtoaState *state, int base
         if (!s)
             goto nomem2;
         /* At this point we have the following:
          *   s = 2^s2;
          *   1 > df = b/2^s2 > 0;
          *   (d - prevDouble(d))/2 = mlo/2^s2;
          *   (nextDouble(d) - d)/2 = mhi/2^s2. */
 
-        done = JS_FALSE;
+        done = false;
         do {
             int32_t j, j1;
             Bigint *delta;
 
             b = multadd(PASS_STATE b, base, 0);
             if (!b)
                 goto nomem2;
             digit = quorem2(b, s2);
@@ -454,17 +454,17 @@ js_dtobasestr(DtoaState *state, int base
             j1 = delta->sign ? 1 : cmp(b, delta);
             Bfree(PASS_STATE delta);
             /* j1 is b/2^s2 compared with 1 - mhi/2^s2. */
 
 #ifndef ROUND_BIASED
             if (j1 == 0 && !(word1(d) & 1)) {
                 if (j > 0)
                     digit++;
-                done = JS_TRUE;
+                done = true;
             } else
 #endif
             if (j < 0 || (j == 0
 #ifndef ROUND_BIASED
                 && !(word1(d) & 1)
 #endif
                 )) {
                 if (j1 > 0) {
@@ -473,20 +473,20 @@ js_dtobasestr(DtoaState *state, int base
                     b = lshift(PASS_STATE b, 1);
                     if (!b)
                         goto nomem2;
                     j1 = cmp(b, s);
                     if (j1 > 0) /* The even test (|| (j1 == 0 && (digit & 1))) is not here because it messes up odd base output
                                  * such as 3.5 in base 3.  */
                         digit++;
                 }
-                done = JS_TRUE;
+                done = true;
             } else if (j1 > 0) {
                 digit++;
-                done = JS_TRUE;
+                done = true;
             }
             JS_ASSERT(digit < (uint32_t)base);
             *p++ = BASEDIGIT(digit);
         } while (!done);
         Bfree(PASS_STATE b);
         Bfree(PASS_STATE s);
         if (mlo != mhi)
             Bfree(PASS_STATE mlo);
--- a/js/src/jsexn.h
+++ b/js/src/jsexn.h
@@ -19,18 +19,18 @@
 extern JSObject *
 js_InitExceptionClasses(JSContext *cx, js::HandleObject obj);
 
 /*
  * Given a JSErrorReport, check to see if there is an exception associated with
  * the error number.  If there is, then create an appropriate exception object,
  * set it as the pending exception, and set the JSREPORT_EXCEPTION flag on the
  * error report.  Exception-aware host error reporters should probably ignore
- * error reports so flagged.  Returns JS_TRUE if an associated exception is
- * found and set, JS_FALSE otherwise.
+ * error reports so flagged.  Returns true if an associated exception is
+ * found and set, false otherwise.
  */
 extern JSBool
 js_ErrorToException(JSContext *cx, const char *message, JSErrorReport *reportp,
                     JSErrorCallback callback, void *userRef);
 
 /*
  * Called if a JS API call to js_Execute or js_InternalCall fails; calls the
  * error reporter with the error report associated with any uncaught exception
--- a/js/src/jsfun.cpp
+++ b/js/src/jsfun.cpp
@@ -819,17 +819,17 @@ js_fun_call(JSContext *cx, unsigned argc
 
         argc--;
         argv++;
     }
 
     /* Allocate stack space for fval, obj, and the args. */
     InvokeArgs args(cx);
     if (!args.init(argc))
-        return JS_FALSE;
+        return false;
 
     /* Push fval, thisv, and the args. */
     args.setCallee(fval);
     args.setThis(thisv);
     PodCopy(args.array(), argv, argc);
 
     bool ok = Invoke(cx, args);
     *vp = args.rval();
--- a/js/src/jsnum.cpp
+++ b/js/src/jsnum.cpp
@@ -294,35 +294,35 @@ num_isFinite(JSContext *cx, unsigned arg
 
 static bool
 num_parseFloat(JSContext *cx, unsigned argc, Value *vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
 
     if (args.length() == 0) {
         args.rval().setDouble(js_NaN);
-        return JS_TRUE;
+        return true;
     }
     JSString *str = ToString<CanGC>(cx, args[0]);
     if (!str)
-        return JS_FALSE;
+        return false;
     const jschar *bp = str->getChars(cx);
     if (!bp)
-        return JS_FALSE;
+        return false;
     const jschar *end = bp + str->length();
     const jschar *ep;
     double d;
     if (!js_strtod(cx, bp, end, &ep, &d))
-        return JS_FALSE;
+        return false;
     if (ep == bp) {
         args.rval().setDouble(js_NaN);
-        return JS_TRUE;
+        return true;
     }
     args.rval().setDouble(d);
-    return JS_TRUE;
+    return true;
 }
 
 /* ES5 15.1.2.2. */
 bool
 js::num_parseInt(JSContext *cx, unsigned argc, Value *vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
 
@@ -1372,17 +1372,17 @@ js::NumberValueToStringBuffer(JSContext 
     ToCStringBuf cbuf;
     const char *cstr;
     if (v.isInt32()) {
         cstr = IntToCString(&cbuf, v.toInt32());
     } else {
         cstr = NumberToCString(cx, &cbuf, v.toDouble());
         if (!cstr) {
             JS_ReportOutOfMemory(cx);
-            return JS_FALSE;
+            return false;
         }
     }
 
     /*
      * Inflate to jschar string.  The input C-string characters are < 127, so
      * even if jschars are UTF-8, all chars should map to one jschar.
      */
     size_t cstrlen = strlen(cstr);
@@ -1680,17 +1680,17 @@ js_strtod(ThreadSafeContext *cx, const j
 
     const jschar *s1 = SkipSpace(s, send);
     size_t length = send - s1;
 
     /* Use cbuf to avoid malloc */
     if (length >= sizeof cbuf) {
         cstr = (char *) cx->malloc_(length + 1);
         if (!cstr)
-           return JS_FALSE;
+           return false;
     } else {
         cstr = cbuf;
     }
 
     for (i = 0; i != length; i++) {
         if (s1[i] >> 8)
             break;
         cstr[i] = (char)s1[i];
@@ -1712,10 +1712,10 @@ js_strtod(ThreadSafeContext *cx, const j
             d = js_NegativeInfinity;
     }
 
     i = estr - cstr;
     if (cstr != cbuf)
         js_free(cstr);
     *ep = i ? s1 + i : s;
     *dp = d;
-    return JS_TRUE;
+    return true;
 }
--- a/js/src/jsobj.cpp
+++ b/js/src/jsobj.cpp
@@ -537,17 +537,17 @@ Reject(JSContext *cx, unsigned errorNumb
 
 static JSBool
 Reject(JSContext *cx, JSObject *obj, unsigned errorNumber, bool throwError, bool *rval)
 {
     if (throwError)
         return Throw(cx, obj, errorNumber);
 
     *rval = false;
-    return JS_TRUE;
+    return true;
 }
 
 static bool
 Reject(JSContext *cx, HandleId id, unsigned errorNumber, bool throwError, bool *rval)
 {
     if (throwError)
         return Throw(cx, id, errorNumber);
 
@@ -603,17 +603,17 @@ static JSBool
 DefinePropertyOnObject(JSContext *cx, HandleObject obj, HandleId id, const PropDesc &desc,
                        bool throwError, bool *rval)
 {
     /* 8.12.9 step 1. */
     RootedShape shape(cx);
     RootedObject obj2(cx);
     JS_ASSERT(!obj->getOps()->lookupGeneric);
     if (!HasOwnProperty<CanGC>(cx, NULL, obj, id, &obj2, &shape))
-        return JS_FALSE;
+        return false;
 
     JS_ASSERT(!obj->getOps()->defineProperty);
 
     /* 8.12.9 steps 2-4. */
     if (!shape) {
         bool extensible;
         if (!JSObject::isExtensible(cx, obj, &extensible))
             return false;
@@ -634,17 +634,17 @@ DefinePropertyOnObject(JSContext *cx, Ha
 
         /*
          * Getters and setters are just like watchpoints from an access
          * control point of view.
          */
         RootedValue dummy(cx);
         unsigned dummyAttrs;
         if (!CheckAccess(cx, obj, id, JSACC_WATCH, &dummy, &dummyAttrs))
-            return JS_FALSE;
+            return false;
 
         RootedValue tmp(cx, UndefinedValue());
         return baseops::DefineGeneric(cx, obj, id, tmp,
                                       desc.getter(), desc.setter(), desc.attributes());
     }
 
     /* 8.12.9 steps 5-6 (note 5 is merely a special case of 6). */
     RootedValue v(cx, UndefinedValue());
@@ -719,17 +719,17 @@ DefinePropertyOnObject(JSContext *cx, Ha
                     (!shape->hasDefaultGetter() || !shape->hasDefaultSetter()) &&
                     desc.isDataDescriptor() &&
                     (desc.hasWritable() ? desc.writable() : shape->writable()))
                 {
                     return Reject(cx, JSMSG_CANT_REDEFINE_PROP, throwError, id, rval);
                 }
 
                 if (!js_NativeGet(cx, obj, obj2, shape, 0, &v))
-                    return JS_FALSE;
+                    return false;
             }
 
             if (desc.isDataDescriptor()) {
                 if (!shapeDataDescriptor)
                     break;
 
                 bool same;
                 if (desc.hasValue()) {
@@ -865,17 +865,17 @@ DefinePropertyOnObject(JSContext *cx, Ha
         JS_ASSERT(desc.isAccessorDescriptor());
 
         /*
          * Getters and setters are just like watchpoints from an access
          * control point of view.
          */
         RootedValue dummy(cx);
         if (!CheckAccess(cx, obj2, id, JSACC_WATCH, &dummy, &attrs))
-             return JS_FALSE;
+             return false;
 
         /* 8.12.9 step 12. */
         unsigned changed = 0;
         if (desc.hasConfigurable())
             changed |= JSPROP_PERMANENT;
         if (desc.hasEnumerable())
             changed |= JSPROP_ENUMERATE;
         if (desc.hasGet())
@@ -3147,17 +3147,17 @@ js_FindClassObject(ExclusiveContext *cx,
     if (protoKey != JSProto_Null) {
         JS_ASSERT(JSProto_Null < protoKey);
         JS_ASSERT(protoKey < JSProto_LIMIT);
         RootedObject cobj(cx);
         if (!js_GetClassObject(cx, cx->global(), protoKey, &cobj))
             return false;
         if (cobj) {
             vp.set(ObjectValue(*cobj));
-            return JS_TRUE;
+            return true;
         }
         id = NameToId(ClassName(protoKey, cx));
     } else {
         JSAtom *atom = Atomize(cx, clasp->name, strlen(clasp->name));
         if (!atom)
             return false;
         id = AtomToId(atom);
     }
@@ -4150,38 +4150,38 @@ GetPropertyHelperInline(JSContext *cx,
                 return true;
 
             /* Don't warn repeatedly for the same script. */
             if (!script || script->warnedAboutUndefinedProp)
                 return true;
 
             /* We may just be checking if that object has an iterator. */
             if (JSID_IS_ATOM(id, cx->names().iteratorIntrinsic))
-                return JS_TRUE;
+                return true;
 
             /* Do not warn about tests like (obj[prop] == undefined). */
             if (cx->resolveFlags == RESOLVE_INFER) {
                 pc += js_CodeSpec[op].length;
                 if (Detecting(cx, script, pc))
-                    return JS_TRUE;
+                    return true;
             }
 
             unsigned flags = JSREPORT_WARNING | JSREPORT_STRICT;
             script->warnedAboutUndefinedProp = true;
 
             /* Ok, bad undefined property reference: whine about it. */
             RootedValue val(cx, IdToValue(id));
             if (!js_ReportValueErrorFlags(cx, flags, JSMSG_UNDEFINED_PROP,
                                           JSDVG_IGNORE_STACK, val, NullPtr(),
                                           NULL, NULL))
             {
                 return false;
             }
         }
-        return JS_TRUE;
+        return true;
     }
 
     if (!obj2->isNative()) {
         if (!allowGC)
             return false;
         HandleObject obj2Handle = MaybeRooted<JSObject*, allowGC>::toHandle(obj2);
         HandleObject receiverHandle = MaybeRooted<JSObject*, allowGC>::toHandle(receiver);
         HandleId idHandle = MaybeRooted<jsid, allowGC>::toHandle(id);
@@ -4193,19 +4193,19 @@ GetPropertyHelperInline(JSContext *cx,
 
     if (IsImplicitDenseElement(shape)) {
         vp.set(obj2->getDenseElement(JSID_TO_INT(id)));
         return true;
     }
 
     /* This call site is hot -- use the always-inlined variant of js_NativeGet(). */
     if (!NativeGetInline<allowGC>(cx, obj, receiver, obj2, shape, getHow, vp))
-        return JS_FALSE;
-
-    return JS_TRUE;
+        return false;
+
+    return true;
 }
 
 bool
 js::GetPropertyHelper(JSContext *cx, HandleObject obj, HandleId id, uint32_t getHow, MutableHandleValue vp)
 {
     return GetPropertyHelperInline<CanGC>(cx, obj, obj, id, getHow, vp);
 }
 
@@ -4605,28 +4605,28 @@ baseops::SetPropertyHelper(JSContext *cx
             JS_ASSERT(shape->isDataDescriptor());
 
             if (!shape->writable()) {
                 /* Error in strict mode code, warn with extra warnings options, otherwise do nothing. */
                 if (strict)
                     return JSObject::reportReadOnly(cx, id, JSREPORT_ERROR);
                 if (cx->hasExtraWarningsOption())
                     return JSObject::reportReadOnly(cx, id, JSREPORT_STRICT | JSREPORT_WARNING);
-                return JS_TRUE;
+                return true;
             }
         }
 
         attrs = shape->attributes();
         if (pobj != obj) {
             /*
              * We found id in a prototype object: prepare to share or shadow.
              */
             if (!shape->shadowable()) {
                 if (shape->hasDefaultSetter() && !shape->hasGetterValue())
-                    return JS_TRUE;
+                    return true;
 
                 return shape->set(cx, obj, receiver, strict, vp);
             }
 
             /*
              * Preserve attrs except JSPROP_SHARED, getter, and setter when
              * shadowing any property that has no slot (is shared). We must
              * clear the shared attribute for the shadowing shape so that the
@@ -5008,26 +5008,26 @@ js::CheckAccess(JSContext *cx, JSObject 
 
     writing = (mode & JSACC_WRITE) != 0;
     switch (mode & JSACC_TYPEMASK) {
       case JSACC_PROTO:
         pobj = obj;
         if (!writing) {
             RootedObject proto(cx);
             if (!JSObject::getProto(cx, obj, &proto))
-                return JS_FALSE;
+                return false;
             vp.setObjectOrNull(proto);
         }
         *attrsp = JSPROP_PERMANENT;
         break;
 
       default:
         RootedShape shape(cx);
         if (!JSObject::lookupGeneric(cx, obj, id, &pobj, &shape))
-            return JS_FALSE;
+            return false;
         if (!shape) {
             if (!writing)
                 vp.setUndefined();
             *attrsp = 0;
             pobj = obj;
             break;
         }
 
@@ -5277,17 +5277,17 @@ js_ReportGetterOnlyAssignment(JSContext 
                                         JSMSG_GETTER_ONLY);
 }
 
 JS_FRIEND_API(JSBool)
 js_GetterOnlyPropertyStub(JSContext *cx, HandleObject obj, HandleId id, JSBool strict,
                           MutableHandleValue vp)
 {
     JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_GETTER_ONLY);
-    return JS_FALSE;
+    return false;
 }
 
 #ifdef DEBUG
 
 /*
  * Routines to print out values during debugging.  These are FRIEND_API to help
  * the debugger find them and to support temporarily hacking js_Dump* calls
  * into other code.
--- a/js/src/json.cpp
+++ b/js/src/json.cpp
@@ -137,24 +137,24 @@ class StringifyContext
 
 static JSBool Str(JSContext *cx, const Value &v, StringifyContext *scx);
 
 static JSBool
 WriteIndent(JSContext *cx, StringifyContext *scx, uint32_t limit)
 {
     if (!scx->gap.empty()) {
         if (!scx->sb.append('\n'))
-            return JS_FALSE;
+            return false;
         for (uint32_t i = 0; i < limit; i++) {
             if (!scx->sb.append(scx->gap.begin(), scx->gap.end()))
-                return JS_FALSE;
+                return false;
         }
     }
 
-    return JS_TRUE;
+    return true;
 }
 
 template<typename KeyType>
 class KeyStringifier {
 };
 
 template<>
 class KeyStringifier<uint32_t> {
@@ -283,17 +283,17 @@ JO(JSContext *cx, HandleObject obj, Stri
     if (!detect.init())
         return false;
     if (detect.foundCycle()) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_CYCLIC_VALUE, js_object_str);
         return false;
     }
 
     if (!scx->sb.append('{'))
-        return JS_FALSE;
+        return false;
 
     /* Steps 5-7. */
     Maybe<AutoIdVector> ids;
     const AutoIdVector *props;
     if (scx->replacer && !scx->replacer->isCallable()) {
         JS_ASSERT(JS_IsArrayObject(cx, scx->replacer));
         props = &scx->propertyList;
     } else {
@@ -373,62 +373,62 @@ JA(JSContext *cx, HandleObject obj, Stri
     if (!detect.init())
         return false;
     if (detect.foundCycle()) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_CYCLIC_VALUE, js_object_str);
         return false;
     }
 
     if (!scx->sb.append('['))
-        return JS_FALSE;
+        return false;
 
     /* Step 6. */
     uint32_t length;
     if (!GetLengthProperty(cx, obj, &length))
-        return JS_FALSE;
+        return false;
 
     /* Steps 7-10. */
     if (length != 0) {
         /* Steps 4, 10b(i). */
         if (!WriteIndent(cx, scx, scx->depth))
-            return JS_FALSE;
+            return false;
 
         /* Steps 7-10. */
         RootedValue outputValue(cx);
         for (uint32_t i = 0; i < length; i++) {
             /*
              * Steps 8a-8c.  Again note how the call to the spec's Str method
              * is broken up into getting the property, running it past toJSON
              * and the replacer and maybe unboxing, and interpreting some
              * values as |null| in separate steps.
              */
             if (!JSObject::getElement(cx, obj, obj, i, &outputValue))
-                return JS_FALSE;
+                return false;
             if (!PreprocessValue(cx, obj, i, &outputValue, scx))
-                return JS_FALSE;
+                return false;
             if (IsFilteredValue(outputValue)) {
                 if (!scx->sb.append("null"))
-                    return JS_FALSE;
+                    return false;
             } else {
                 if (!Str(cx, outputValue, scx))
-                    return JS_FALSE;
+                    return false;
             }
 
             /* Steps 3, 4, 10b(i). */
             if (i < length - 1) {
                 if (!scx->sb.append(','))
-                    return JS_FALSE;
+                    return false;
                 if (!WriteIndent(cx, scx, scx->depth))
-                    return JS_FALSE;
+                    return false;
             }
         }
 
         /* Step 10(b)(iii). */
         if (!WriteIndent(cx, scx, scx->depth - 1))
-            return JS_FALSE;
+            return false;
     }
 
     return scx->sb.append(']');
 }
 
 static JSBool
 Str(JSContext *cx, const Value &v, StringifyContext *scx)
 {
@@ -785,17 +785,17 @@ js::ParseJSONWithReviver(JSContext *cx, 
     return true;
 }
 
 #if JS_HAS_TOSOURCE
 static bool
 json_toSource(JSContext *cx, unsigned argc, Value *vp)
 {
     vp->setString(cx->names().JSON);
-    return JS_TRUE;
+    return true;
 }
 #endif
 
 /* ES5 15.12.2. */
 static bool
 json_parse(JSContext *cx, unsigned argc, Value *vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
--- a/js/src/jsopcode.cpp
+++ b/js/src/jsopcode.cpp
@@ -383,65 +383,65 @@ js_DisassembleAtPC(JSContext *cx, JSScri
                 sp->put("   ");
             if (script->hasAnalysis() && script->analysis()->maybeCode(next))
                 Sprint(sp, "%05u ", script->analysis()->getCode(next).stackDepth);
             else
                 sp->put("      ");
         }
         len = js_Disassemble1(cx, script, next, next - script->code, lines, sp);
         if (!len)
-            return JS_FALSE;
+            return false;
         next += len;
     }
-    return JS_TRUE;
+    return true;
 }
 
 JSBool
 js_Disassemble(JSContext *cx, HandleScript script, JSBool lines, Sprinter *sp)
 {
     return js_DisassembleAtPC(cx, script, lines, NULL, false, sp);
 }
 
 JS_FRIEND_API(JSBool)
 js_DumpPC(JSContext *cx)
 {
     js::gc::AutoSuppressGC suppressGC(cx);
     Sprinter sprinter(cx);
     if (!sprinter.init())
-        return JS_FALSE;
+        return false;
     ScriptFrameIter iter(cx);
     RootedScript script(cx, iter.script());
     JSBool ok = js_DisassembleAtPC(cx, script, true, iter.pc(), false, &sprinter);
     fprintf(stdout, "%s", sprinter.string());
     return ok;
 }
 
 JS_FRIEND_API(JSBool)
 js_DumpScript(JSContext *cx, JSScript *scriptArg)
 {
     js::gc::AutoSuppressGC suppressGC(cx);
     Sprinter sprinter(cx);
     if (!sprinter.init())
-        return JS_FALSE;
+        return false;
     RootedScript script(cx, scriptArg);
     JSBool ok = js_Disassemble(cx, script, true, &sprinter);
     fprintf(stdout, "%s", sprinter.string());
     return ok;
 }
 
 /*
  * Useful to debug ReconstructPCStack.
  */
 JS_FRIEND_API(JSBool)
 js_DumpScriptDepth(JSContext *cx, JSScript *scriptArg, jsbytecode *pc)
 {
     js::gc::AutoSuppressGC suppressGC(cx);
     Sprinter sprinter(cx);
     if (!sprinter.init())
-        return JS_FALSE;
+        return false;
     RootedScript script(cx, scriptArg);
     JSBool ok = js_DisassembleAtPC(cx, script, true, pc, true, &sprinter);
     fprintf(stdout, "%s", sprinter.string());
     return ok;
 }
 
 static char *
 QuoteString(Sprinter *sp, JSString *str, uint32_t quote);
--- a/js/src/jspubtd.h
+++ b/js/src/jspubtd.h
@@ -37,17 +37,17 @@ struct Zone;
 
 } /* namespace JS */
 
 /*
  * In release builds, jsid is defined to be an integral type. This
  * prevents many bugs from being caught at compile time. E.g.:
  *
  *  jsid id = ...
- *  if (id == JS_TRUE)  // error
+ *  if (id)             // error
  *    ...
  *
  *  size_t n = id;      // error
  *
  * To catch more errors, jsid is given a struct type in C++ debug builds.
  * Struct assignment and (in C++) operator== allow correct code to be mostly
  * oblivious to the change. This feature can be explicitly disabled in debug
  * builds by defining JS_NO_JSVAL_JSID_STRUCT_TYPES.
--- a/js/src/jsreflect.cpp
+++ b/js/src/jsreflect.cpp
@@ -2952,129 +2952,129 @@ ASTSerializer::moduleOrFunctionBody(Pars
 static bool
 reflect_parse(JSContext *cx, uint32_t argc, jsval *vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
 
     if (args.length() < 1) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_MORE_ARGS_NEEDED,
                              "Reflect.parse", "0", "s");
-        return JS_FALSE;
+        return false;
     }
 
     RootedString src(cx, ToString<CanGC>(cx, args[0]));
     if (!src)
-        return JS_FALSE;
+        return false;
 
     ScopedJSFreePtr<char> filename;
     uint32_t lineno = 1;
     bool loc = true;
 
     RootedObject builder(cx);
 
     RootedValue arg(cx, args.get(1));
 
     if (!arg.isNullOrUndefined()) {
         if (!arg.isObject()) {
             js_ReportValueErrorFlags(cx, JSREPORT_ERROR, JSMSG_UNEXPECTED_TYPE,
                                      JSDVG_SEARCH_STACK, arg, NullPtr(), "not an object", NULL);
-            return JS_FALSE;
+            return false;
         }
 
         RootedObject config(cx, &arg.toObject());
 
         RootedValue prop(cx);
 
         /* config.loc */
         RootedId locId(cx, NameToId(cx->names().loc));
         RootedValue trueVal(cx, BooleanValue(true));
         if (!baseops::GetPropertyDefault(cx, config, locId, trueVal, &prop))
-            return JS_FALSE;
+            return false;
 
         loc = ToBoolean(prop);
 
         if (loc) {
             /* config.source */
             RootedId sourceId(cx, NameToId(cx->names().source));
             RootedValue nullVal(cx, NullValue());
             if (!baseops::GetPropertyDefault(cx, config, sourceId, nullVal, &prop))
-                return JS_FALSE;
+                return false;
 
             if (!prop.isNullOrUndefined()) {
                 RootedString str(cx, ToString<CanGC>(cx, prop));
                 if (!str)
-                    return JS_FALSE;
+                    return false;
 
                 size_t length = str->length();
                 const jschar *chars = str->getChars(cx);
                 if (!chars)
-                    return JS_FALSE;
+                    return false;
 
                 TwoByteChars tbchars(chars, length);
                 filename = LossyTwoByteCharsToNewLatin1CharsZ(cx, tbchars).c_str();
                 if (!filename)
-                    return JS_FALSE;
+                    return false;
             }
 
             /* config.line */
             RootedId lineId(cx, NameToId(cx->names().line));
             RootedValue oneValue(cx, Int32Value(1));
             if (!baseops::GetPropertyDefault(cx, config, lineId, oneValue, &prop) ||
                 !ToUint32(cx, prop, &lineno)) {
-                return JS_FALSE;
+                return false;
             }
         }
 
         /* config.builder */
         RootedId builderId(cx, NameToId(cx->names().builder));
         RootedValue nullVal(cx, NullValue());
         if (!baseops::GetPropertyDefault(cx, config, builderId, nullVal, &prop))
-            return JS_FALSE;
+            return false;
 
         if (!prop.isNullOrUndefined()) {
             if (!prop.isObject()) {
                 js_ReportValueErrorFlags(cx, JSREPORT_ERROR, JSMSG_UNEXPECTED_TYPE,
                                          JSDVG_SEARCH_STACK, prop, NullPtr(), "not an object", NULL);
-                return JS_FALSE;
+                return false;
             }
             builder = &prop.toObject();
         }
     }
 
     /* Extract the builder methods first to report errors before parsing. */
     ASTSerializer serialize(cx, loc, filename, lineno);
     if (!serialize.init(builder))
-        return JS_FALSE;
+        return false;
 
     JSStableString *stable = src->ensureStable(cx);
     if (!stable)
-        return JS_FALSE;
+        return false;
 
     const StableCharPtr chars = stable->chars();
     size_t length = stable->length();
     CompileOptions options(cx);
     options.setFileAndLine(filename, lineno);
     options.setCanLazilyParse(false);
     Parser<FullParseHandler> parser(cx, &cx->tempLifoAlloc(), options, chars.get(), length,
                                     /* foldConstants = */ false, NULL, NULL);
 
     serialize.setParser(&parser);
 
     ParseNode *pn = parser.parse(NULL);
     if (!pn)
-        return JS_FALSE;
+        return false;
 
     RootedValue val(cx);
     if (!serialize.program(pn, &val)) {
         args.rval().setNull();
-        return JS_FALSE;
+        return false;
     }
 
     args.rval().set(val);
-    return JS_TRUE;
+    return true;
 }
 
 static const JSFunctionSpec static_methods[] = {
     JS_FN("parse", reflect_parse, 1, 0),
     JS_FS_END
 };
 
 JS_PUBLIC_API(JSObject *)
--- a/js/src/jsscript.cpp
+++ b/js/src/jsscript.cpp
@@ -321,17 +321,17 @@ XDRScriptConst(XDRState<mode> *xdr, Heap
         return false;
 
     switch (tag) {
       case SCRIPT_INT: {
         uint32_t i;
         if (mode == XDR_ENCODE)
             i = uint32_t(vp->toInt32());
         if (!xdr->codeUint32(&i))
-            return JS_FALSE;
+            return false;
         if (mode == XDR_DECODE)
             vp->init(Int32Value(int32_t(i)));
         break;
       }
       case SCRIPT_DOUBLE: {
         double d;
         if (mode == XDR_ENCODE)
             d = vp->toDouble();
@@ -440,17 +440,17 @@ js::XDRScript(XDRState<mode> *xdr, Handl
     if (mode == XDR_DECODE) {
         nargs = argsVars >> 16;
         nvars = argsVars & 0xFFFF;
     }
 
     if (mode == XDR_ENCODE)
         length = script->length;
     if (!xdr->codeUint32(&length))
-        return JS_FALSE;
+        return false;
 
     if (mode == XDR_ENCODE) {
         prologLength = script->mainOffset;
         JS_ASSERT(script->getVersion() != JSVERSION_UNKNOWN);
         version = (uint32_t)script->getVersion() | (script->nfixed << 16);
         lineno = script->lineno;
         nslots = (uint32_t)script->nslots;
         nslots = (uint32_t)((script->staticLevel << 16) | script->nslots);
@@ -501,42 +501,42 @@ js::XDRScript(XDRState<mode> *xdr, Handl
         if (script->isLegacyGenerator)
             scriptBits |= (1 << IsLegacyGenerator);
 
         JS_ASSERT(!script->compileAndGo);
         JS_ASSERT(!script->hasSingletons);
     }
 
     if (!xdr->codeUint32(&prologLength))
-        return JS_FALSE;
+        return false;
     if (!xdr->codeUint32(&version))
-        return JS_FALSE;
+        return false;
 
     /*
      * To fuse allocations, we need srcnote, atom, objects, regexp, and trynote
      * counts early.
      */
     if (!xdr->codeUint32(&natoms))
-        return JS_FALSE;
+        return false;
     if (!xdr->codeUint32(&nsrcnotes))
-        return JS_FALSE;
+        return false;
     if (!xdr->codeUint32(&ntrynotes))
-        return JS_FALSE;
+        return false;
     if (!xdr->codeUint32(&nobjects))
-        return JS_FALSE;
+        return false;
     if (!xdr->codeUint32(&nregexps))
-        return JS_FALSE;
+        return false;
     if (!xdr->codeUint32(&nconsts))
-        return JS_FALSE;
+        return false;
     if (!xdr->codeUint32(&nTypeSets))
-        return JS_FALSE;
+        return false;
     if (!xdr->codeUint32(&ndefaults))
-        return JS_FALSE;
+        return false;
     if (!xdr->codeUint32(&scriptBits))
-        return JS_FALSE;
+        return false;
 
     if (mode == XDR_DECODE) {
         /* Note: version is packed into the 32b space with another 16b value. */
         JSVersion version_ = JSVersion(version & JS_BITMASK(16));
         JS_ASSERT((version_ & VersionFlags::MASK) == unsigned(version_));
 
         // staticLevel is set below.
         CompileOptions options(cx);
--- a/js/src/jsstr.cpp
+++ b/js/src/jsstr.cpp
@@ -1519,29 +1519,29 @@ js_TrimString(JSContext *cx, Value *vp, 
 
     call.rval().setString(str);
     return true;
 }
 
 static bool
 str_trim(JSContext *cx, unsigned argc, Value *vp)
 {
-    return js_TrimString(cx, vp, JS_TRUE, JS_TRUE);
+    return js_TrimString(cx, vp, true, true);
 }
 
 static bool
 str_trimLeft(JSContext *cx, unsigned argc, Value *vp)
 {
-    return js_TrimString(cx, vp, JS_TRUE, JS_FALSE);
+    return js_TrimString(cx, vp, true, false);
 }
 
 static bool
 str_trimRight(JSContext *cx, unsigned argc, Value *vp)
 {
-    return js_TrimString(cx, vp, JS_FALSE, JS_TRUE);
+    return js_TrimString(cx, vp, false, true);
 }
 
 /*
  * Perl-inspired string functions.
  */
 
 namespace {
 
@@ -3543,43 +3543,43 @@ bool
 js::str_fromCharCode(JSContext *cx, unsigned argc, Value *vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
 
     JS_ASSERT(args.length() <= ARGS_LENGTH_MAX);
     if (args.length() == 1) {
         uint16_t code;
         if (!ToUint16(cx, args[0], &code))
-            return JS_FALSE;
+            return false;
         if (StaticStrings::hasUnit(code)) {
             args.rval().setString(cx->runtime()->staticStrings.getUnit(code));
-            return JS_TRUE;
+            return true;
         }
         args[0].setInt32(code);
     }
     jschar *chars = cx->pod_malloc<jschar>(args.length() + 1);
     if (!chars)
-        return JS_FALSE;
+        return false;
     for (unsigned i = 0; i < args.length(); i++) {
         uint16_t code;
         if (!ToUint16(cx, args[i], &code)) {
             js_free(chars);
-            return JS_FALSE;
+            return false;
         }
         chars[i] = (jschar)code;
     }
     chars[args.length()] = 0;
     JSString *str = js_NewString<CanGC>(cx, chars, args.length());
     if (!str) {
         js_free(chars);
-        return JS_FALSE;
+        return false;
     }
 
     args.rval().setString(str);
-    return JS_TRUE;
+    return true;
 }
 
 static const JSFunctionSpec string_static_methods[] = {
     JS_FN("fromCharCode", js::str_fromCharCode, 1, 0),
 
     // This must be at the end because of bug 853075: functions listed after
     // self-hosted methods aren't available in self-hosted code.
 #if ENABLE_INTL_API
@@ -4012,45 +4012,45 @@ js::DeflateStringToBuffer(JSContext *may
     if (srclen > dstlen) {
         for (size_t i = 0; i < dstlen; i++)
             dst[i] = (char) src[i];
         if (maybecx) {
             AutoSuppressGC suppress(maybecx);
             JS_ReportErrorNumber(maybecx, js_GetErrorMessage, NULL,
                                  JSMSG_BUFFER_TOO_SMALL);
         }
-        return JS_FALSE;
+        return false;
     }
     for (size_t i = 0; i < srclen; i++)
         dst[i] = (char) src[i];
     *dstlenp = srclen;
-    return JS_TRUE;
+    return true;
 }
 
 bool
 js::InflateStringToBuffer(JSContext *maybecx, const char *src, size_t srclen,
                           jschar *dst, size_t *dstlenp)
 {
     if (dst) {
         size_t dstlen = *dstlenp;
         if (srclen > dstlen) {
             for (size_t i = 0; i < dstlen; i++)
                 dst[i] = (unsigned char) src[i];
             if (maybecx) {
                 AutoSuppressGC suppress(maybecx);
                 JS_ReportErrorNumber(maybecx, js_GetErrorMessage, NULL,
                                      JSMSG_BUFFER_TOO_SMALL);
             }
-            return JS_FALSE;
+            return false;
         }
         for (size_t i = 0; i < srclen; i++)
             dst[i] = (unsigned char) src[i];
     }
     *dstlenp = srclen;
-    return JS_TRUE;
+    return true;
 }
 
 #define ____ false
 
 /*
  * Identifier start chars:
  * -      36:    $
  * -  65..90: A..Z
@@ -4310,31 +4310,31 @@ Decode(JSContext *cx, Handle<JSLinearStr
                 uint32_t v = JS::Utf8ToOneUcs4Char(octets, n);
                 if (v >= 0x10000) {
                     v -= 0x10000;
                     if (v > 0xFFFFF)
                         goto report_bad_uri;
                     c = (jschar)((v & 0x3FF) + 0xDC00);
                     jschar H = (jschar)((v >> 10) + 0xD800);
                     if (!sb.append(H))
-                        return JS_FALSE;
+                        return false;
                 } else {
                     c = (jschar)v;
                 }
             }
             if (c < 128 && reservedSet && reservedSet[c]) {
                 if (!sb.append(chars + start, k - start + 1))
-                    return JS_FALSE;
+                    return false;
             } else {
                 if (!sb.append(c))
-                    return JS_FALSE;
+                    return false;
             }
         } else {
             if (!sb.append(c))
-                return JS_FALSE;
+                return false;
         }
     }
 
     return TransferBufferToString(sb, rval);
 
   report_bad_uri:
     JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_URI);
     /* FALL THROUGH */
--- a/js/src/jstypes.h
+++ b/js/src/jstypes.h
@@ -179,24 +179,21 @@
 #else
 # error "Implement me"
 #endif
 
 
 /************************************************************************
 ** TYPES:       JSBool
 ** DESCRIPTION:
-**  Use JSBool for variables and parameter types. Use JS_FALSE and JS_TRUE
-**      for clarity of target type in assignments and actual arguments. Use
-**      'if (bool)', 'while (!bool)', '(bool) ? x : y' etc., to test booleans
-**      just as you would C int-valued conditions.
+**  This type is deprecated;  avoid it.  See bug 898914.
 ************************************************************************/
 typedef int JSBool;
-#define JS_TRUE (int)1
-#define JS_FALSE (int)0
+#define JS_TRUE_DEPRECATED  (int)1
+#define JS_FALSE_DEPRECATED (int)0
 
 /***********************************************************************
 ** MACROS:      JS_LIKELY
 **              JS_UNLIKELY
 ** DESCRIPTION:
 **      These macros allow you to give a hint to the compiler about branch
 **      probability so that it can better optimize.  Use them like this:
 **
--- a/js/src/jswrapper.cpp
+++ b/js/src/jswrapper.cpp
@@ -887,17 +887,17 @@ js::NukeCrossCompartmentWrappers(JSConte
             if (targetFilter.match(wrapped->compartment())) {
                 // We found a wrapper to nuke.
                 e.removeFront();
                 NukeCrossCompartmentWrapper(cx, wobj);
             }
         }
     }
 
-    return JS_TRUE;
+    return true;
 }
 
 // Given a cross-compartment wrapper |wobj|, update it to point to
 // |newTarget|. This recomputes the wrapper with JS_WrapValue, and thus can be
 // useful even if wrapper already points to newTarget.
 bool
 js::RemapWrapper(JSContext *cx, JSObject *wobjArg, JSObject *newTargetArg)
 {
--- a/js/src/perf/jsperf.cpp
+++ b/js/src/perf/jsperf.cpp
@@ -18,19 +18,19 @@ static PerfMeasurement* GetPMFromThis(JS
 // Property access
 
 #define GETTER(name)                                                    \
     static JSBool                                                       \
     pm_get_##name(JSContext* cx, JS::HandleObject obj, JS::HandleId /*unused*/, JS::MutableHandleValue vp) \
     {                                                                   \
         PerfMeasurement* p = GetPM(cx, obj, #name);                     \
         if (!p)                                                         \
-            return JS_FALSE;                                            \
+            return false;                                               \
         vp.set(JS_NumberValue(double(p->name)));                        \
-        return JS_TRUE;                                                 \
+        return true;                                                    \
     }
 
 GETTER(cpu_cycles)
 GETTER(instructions)
 GETTER(cache_references)
 GETTER(cache_misses)
 GETTER(branch_instructions)
 GETTER(branch_misses)
--- a/js/src/shell/js.cpp
+++ b/js/src/shell/js.cpp
@@ -5005,19 +5005,19 @@ static int
 ProcessArgs(JSContext *cx, JSObject *obj_, OptionParser *op)
 {
     RootedObject obj(cx, obj_);
 
     if (op->getBoolOption('c'))
         compileOnly = true;
 
     if (op->getBoolOption('w'))
-        reportWarnings = JS_TRUE;
+        reportWarnings = true;
     else if (op->getBoolOption('W'))
-        reportWarnings = JS_FALSE;
+        reportWarnings = false;
 
     if (op->getBoolOption('s'))
         JS_ToggleOptions(cx, JSOPTION_EXTRA_WARNINGS);
 
     if (op->getBoolOption('d')) {
         JS_SetRuntimeDebugMode(JS_GetRuntime(cx), true);
         JS_SetDebugMode(cx, true);
     }
--- a/js/src/vm/ArgumentsObject.cpp
+++ b/js/src/vm/ArgumentsObject.cpp
@@ -386,17 +386,17 @@ args_resolve(JSContext *cx, HandleObject
             return true;
 
         if (argsobj->callee().isMagic(JS_OVERWRITTEN_CALLEE))
             return true;
     }
 
     RootedValue undef(cx, UndefinedValue());
     if (!baseops::DefineGeneric(cx, argsobj, id, undef, ArgGetter, ArgSetter, attrs))
-        return JS_FALSE;
+        return false;
 
     objp.set(argsobj);
     return true;
 }
 
 static JSBool
 args_enumerate(JSContext *cx, HandleObject obj)
 {
--- a/js/src/vm/Interpreter.cpp
+++ b/js/src/vm/Interpreter.cpp
@@ -220,29 +220,29 @@ js::OnUnknownMethod(JSContext *cx, Handl
     return true;
 }
 
 static JSBool
 NoSuchMethod(JSContext *cx, unsigned argc, Value *vp)
 {
     InvokeArgs args(cx);
     if (!args.init(2))
-        return JS_FALSE;
+        return false;
 
     JS_ASSERT(vp[0].isObject());
     JS_ASSERT(vp[1].isObject());
     JSObject *obj = &vp[0].toObject();
     JS_ASSERT(obj->getClass() == &js_NoSuchMethodClass);
 
     args.setCallee(obj->getReservedSlot(JSSLOT_FOUND_FUNCTION));
     args.setThis(vp[1]);
     args[0].set(obj->getReservedSlot(JSSLOT_SAVED_ID));
     JSObject *argsobj = NewDenseCopiedArray(cx, argc, vp + 2);
     if (!argsobj)
-        return JS_FALSE;
+        return false;
     args[1].setObject(*argsobj);
     JSBool ok = Invoke(cx, args);
     vp[0] = args.rval();
     return ok;
 }
 
 #endif /* JS_HAS_NO_SUCH_METHOD */
 
@@ -2029,17 +2029,17 @@ END_CASE(JSOP_NE)
 
 #define STRICT_EQUALITY_OP(OP, COND)                                          \
     JS_BEGIN_MACRO                                                            \
         const Value &rref = regs.sp[-1];                                      \
         const Value &lref = regs.sp[-2];                                      \
         bool equal;                                                           \
         if (!StrictlyEqual(cx, lref, rref, &equal))                           \
             goto error;                                                       \
-        COND = equal OP JS_TRUE;                                              \
+        COND = equal OP true;                                                 \
         regs.sp--;                                                            \
     JS_END_MACRO
 
 BEGIN_CASE(JSOP_STRICTEQ)
 {
     bool cond;
     STRICT_EQUALITY_OP(==, cond);
     regs.sp[-1].setBoolean(cond);
--- a/js/xpconnect/idl/nsIXPCSecurityManager.idl
+++ b/js/xpconnect/idl/nsIXPCSecurityManager.idl
@@ -21,17 +21,17 @@ interface nsIClassInfo;
 [ptr] native JSStackFramePtr(JSStackFrame);
 
 [uuid(31431440-f1ce-11d2-985a-006008962422)]
 interface nsIXPCSecurityManager : nsISupports
 {
     /**
     * For each of these hooks returning NS_OK means 'let the action continue'.
     * Returning an error code means 'veto the action'. XPConnect will return
-    * JS_FALSE to the js engine if the action is vetoed. The implementor of this
+    * false to the js engine if the action is vetoed. The implementor of this
     * interface is responsible for setting a JS exception into the JSContext
     * if that is appropriate.
     */
 
     void CanCreateWrapper(in JSContextPtr aJSContext,
                           in nsIIDRef aIID,
                           in nsISupports aObj,
                           in nsIClassInfo aClassInfo,
--- a/js/xpconnect/src/dictionary_helper_gen.py
+++ b/js/xpconnect/src/dictionary_helper_gen.py
@@ -365,17 +365,17 @@ def write_cpp(iface, fd):
     fd.write("static nsresult\n%s_InitInternal(%s& aDict, JSContext* aCx, JS::HandleObject aObj)\n" %
              (iface.name, iface.name))
     fd.write("{\n")
     if iface.base is not None:
         fd.write("  nsresult rv = %s_InitInternal(aDict, aCx, aObj);\n" %
                  iface.base)
         fd.write("  NS_ENSURE_SUCCESS(rv, rv);\n")
 
-    fd.write("  JSBool found = JS_FALSE;\n")
+    fd.write("  JSBool found = false;\n")
     needccx = False
     for a in attributes:
         if a.realtype.nativeType('in').count("nsIVariant"):
             needccx = True
     fd.write("  JS::RootedValue v(aCx, JSVAL_VOID);\n")
     if needccx:
         fd.write("  XPCCallContext ccx(NATIVE_CALLER, aCx);\n")
         fd.write("  NS_ENSURE_STATE(ccx.IsValid());\n")
--- a/js/xpconnect/src/qsgen.py
+++ b/js/xpconnect/src/qsgen.py
@@ -381,98 +381,98 @@ def substitute(template, vals):
         return vals[match.group(1)]
     return re.sub(r'\${(\w+)}', replacement, template)
 
 # From JSData2Native.
 argumentUnboxingTemplates = {
     'octet':
         "    uint32_t ${name}_u32;\n"
         "    if (!JS_ValueToECMAUint32(cx, ${argVal}, &${name}_u32))\n"
-        "        return JS_FALSE;\n"
+        "        return false;\n"
         "    uint8_t ${name} = (uint8_t) ${name}_u32;\n",
 
     'short':
         "    int32_t ${name}_i32;\n"
         "    if (!JS_ValueToECMAInt32(cx, ${argVal}, &${name}_i32))\n"
-        "        return JS_FALSE;\n"
+        "        return false;\n"
         "    int16_t ${name} = (int16_t) ${name}_i32;\n",
 
     'unsigned short':
         "    uint32_t ${name}_u32;\n"
         "    if (!JS_ValueToECMAUint32(cx, ${argVal}, &${name}_u32))\n"
-        "        return JS_FALSE;\n"
+        "        return false;\n"
         "    uint16_t ${name} = (uint16_t) ${name}_u32;\n",
 
     'long':
         "    int32_t ${name};\n"
         "    if (!JS_ValueToECMAInt32(cx, ${argVal}, &${name}))\n"
-        "        return JS_FALSE;\n",
+        "        return false;\n",
 
     'unsigned long':
         "    uint32_t ${name};\n"
         "    if (!JS_ValueToECMAUint32(cx, ${argVal}, &${name}))\n"
-        "        return JS_FALSE;\n",
+        "        return false;\n",
 
     'long long':
         "    int64_t ${name};\n"
         "    if (!JS::ToInt64(cx, ${argVal}, &${name}))\n"
-        "        return JS_FALSE;\n",
+        "        return false;\n",
 
     'unsigned long long':
         "    uint64_t ${name};\n"
         "    if (!JS::ToUint64(cx, ${argVal}, &${name}))\n"
-        "        return JS_FALSE;\n",
+        "        return false;\n",
 
     'float':
         "    double ${name}_dbl;\n"
         "    if (!JS_ValueToNumber(cx, ${argVal}, &${name}_dbl))\n"
-        "        return JS_FALSE;\n"
+        "        return false;\n"
         "    float ${name} = (float) ${name}_dbl;\n",
 
     'double':
         "    double ${name};\n"
         "    if (!JS_ValueToNumber(cx, ${argVal}, &${name}))\n"
-        "        return JS_FALSE;\n",
+        "        return false;\n",
 
     'boolean':
         "    JSBool ${name};\n"
         "    JS_ValueToBoolean(cx, ${argVal}, &${name});\n",
 
     '[astring]':
         "    xpc_qsAString ${name}(cx, ${argVal}, ${argPtr});\n"
         "    if (!${name}.IsValid())\n"
-        "        return JS_FALSE;\n",
+        "        return false;\n",
 
     '[domstring]':
         "    xpc_qsDOMString ${name}(cx, ${argVal}, ${argPtr},\n"
         "                            xpc_qsDOMString::e${nullBehavior},\n"
         "                            xpc_qsDOMString::e${undefinedBehavior});\n"
         "    if (!${name}.IsValid())\n"
-        "        return JS_FALSE;\n",
+        "        return false;\n",
 
     'string':
         "    JSAutoByteString ${name}_bytes;\n"
         "    if (!xpc_qsJsvalToCharStr(cx, ${argVal}, &${name}_bytes))\n"
-        "        return JS_FALSE;\n"
+        "        return false;\n"
         "    char *${name} = ${name}_bytes.ptr();\n",
 
     'wstring':
         "    const PRUnichar *${name};\n"
         "    if (!xpc_qsJsvalToWcharStr(cx, ${argVal}, ${argPtr}, &${name}))\n"
-        "        return JS_FALSE;\n",
+        "        return false;\n",
 
     '[cstring]':
         "    xpc_qsACString ${name}(cx, ${argVal}, ${argPtr});\n"
         "    if (!${name}.IsValid())\n"
-        "        return JS_FALSE;\n",
+        "        return false;\n",
 
     '[utf8string]':
         "    xpc_qsAUTF8String ${name}(cx, ${argVal}, ${argPtr});\n"
         "    if (!${name}.IsValid())\n"
-        "        return JS_FALSE;\n",
+        "        return false;\n",
 
     '[jsval]':
         "    JS::RootedValue ${name}(cx, ${argVal});\n"
     }
 
 # From JSData2Native.
 #
 # Omitted optional arguments are treated as though the caller had passed JS
@@ -532,17 +532,17 @@ def writeArgumentUnboxing(f, i, name, ty
     elif isInterfaceType(type):
         if type.name == 'nsIVariant':
             # Totally custom.
             template = (
                 "    nsCOMPtr<nsIVariant> ${name}(already_AddRefed<nsIVariant>("
                 "XPCVariant::newVariant(cx, ${argVal})));\n"
                 "    if (!${name}) {\n"
                 "        xpc_qsThrowBadArg(cx, NS_ERROR_INVALID_ARG, vp, %d);\n"
-                "        return JS_FALSE;\n"
+                "        return false;\n"
                 "    }") % i
             f.write(substitute(template, params))
             return rvdeclared
         elif type.name == 'nsIAtom':
             # Should have special atomizing behavior.  Fall through.
             pass
         else:
             if not rvdeclared:
@@ -554,17 +554,17 @@ def writeArgumentUnboxing(f, i, name, ty
                     % (type.name, argVal, name, name, argPtr))
             f.write("    if (NS_FAILED(rv)) {\n")
             if isSetter:
                 assert(propIndex is not None)
                 f.write("        xpc_qsThrowBadSetterValue(cx, rv, JSVAL_TO_OBJECT(vp[1]), (uint16_t)%s);\n" %
                         propIndex)
             else:
                 f.write("        xpc_qsThrowBadArg(cx, rv, vp, %d);\n" % i)
-            f.write("        return JS_FALSE;\n"
+            f.write("        return false;\n"
                     "    }\n")
             return True
 
     warn("Unable to unbox argument of type %s (native type %s)" % (type.name, typeName))
     if i is None:
         src = 'argv[0]'
     else:
         src = 'argv[%d]' % i
@@ -612,55 +612,55 @@ def outParamForm(name, type):
             return '&' + name
     else:
         return 'getter_AddRefs(%s)' % name
 
 # From NativeData2JS.
 resultConvTemplates = {
     'void':
             "    ${jsvalRef} = JSVAL_VOID;\n"
-            "    return JS_TRUE;\n",
+            "    return true;\n",
 
     'octet':
         "    ${jsvalRef} = INT_TO_JSVAL((int32_t) result);\n"
-        "    return JS_TRUE;\n",
+        "    return true;\n",
 
     'short':
         "    ${jsvalRef} = INT_TO_JSVAL((int32_t) result);\n"
-        "    return JS_TRUE;\n",
+        "    return true;\n",
 
     'long':
         "    ${jsvalRef} = INT_TO_JSVAL(result);\n"
-        "    return JS_TRUE;\n",
+        "    return true;\n",
 
     'long long':
         "    return xpc_qsInt64ToJsval(cx, result, ${jsvalPtr});\n",
 
     'unsigned short':
         "    ${jsvalRef} = INT_TO_JSVAL((int32_t) result);\n"
-        "    return JS_TRUE;\n",
+        "    return true;\n",
 
     'unsigned long':
         "    ${jsvalRef} = UINT_TO_JSVAL(result);\n"
-        "    return JS_TRUE;\n",
+        "    return true;\n",
 
     'unsigned long long':
         "    return xpc_qsUint64ToJsval(cx, result, ${jsvalPtr});\n",
 
     'float':
         "    ${jsvalRef} = JS_NumberValue(result);\n"
-        "    return JS_TRUE;\n",
+        "    return true;\n",
 
     'double':
         "    ${jsvalRef} =  JS_NumberValue(result);\n"
-        "    return JS_TRUE;\n",
+        "    return true;\n",
 
     'boolean':
         "    ${jsvalRef} = (result ? JSVAL_TRUE : JSVAL_FALSE);\n"
-        "    return JS_TRUE;\n",
+        "    return true;\n",
 
     '[astring]':
         "    return xpc::StringToJsval(cx, result, ${jsvalPtr});\n",
 
     '[domstring]':
         "    return xpc::StringToJsval(cx, result, ${jsvalPtr});\n",
 
     '[jsval]':
@@ -669,18 +669,18 @@ resultConvTemplates = {
     }
 
 def isVariantType(t):
     return isSpecificInterfaceType(t, 'nsIVariant')
 
 def writeResultConv(f, type, jsvalPtr, jsvalRef):
     """ Emit code to convert the C++ variable `result` to a jsval.
 
-    The emitted code contains a return statement; it returns JS_TRUE on
-    success, JS_FALSE on error.
+    The emitted code contains a return statement; it returns true on
+    success, false on error.
     """
     # From NativeData2JS.
     typeName = getBuiltinOrNativeTypeName(type)
     if typeName is not None:
         template = resultConvTemplates.get(typeName)
         if template is not None:
             values = {'jsvalRef': jsvalRef,
                       'jsvalPtr': jsvalPtr}
@@ -690,21 +690,21 @@ def writeResultConv(f, type, jsvalPtr, j
     elif isInterfaceType(type):
         if isVariantType(type):
             f.write("    return xpc_qsVariantToJsval(cx, result, %s);\n"
                     % jsvalPtr)
             return
         else:
             f.write("    if (!result) {\n"
                     "      *%s = JSVAL_NULL;\n"
-                    "      return JS_TRUE;\n"
+                    "      return true;\n"
                     "    }\n"
                     "    nsWrapperCache* cache = xpc_qsGetWrapperCache(result);\n"
                     "    if (xpc_FastGetCachedWrapper(cache, obj, %s)) {\n"
-                    "      return JS_TRUE;\n"
+                    "      return true;\n"
                     "    }\n"
                     "    // After this point do not use 'result'!\n"
                     "    qsObjectHelper helper(result, cache);\n"
                     "    return xpc_qsXPCOMObjectToJsval(cx, "
                     "helper, &NS_GET_IID(%s), &interfaces[k_%s], %s);\n"
                     % (jsvalPtr, jsvalPtr, type.name, type.name, jsvalPtr))
             return
 
@@ -830,40 +830,40 @@ def writeQuickStub(f, customMethodCalls,
         setOptimizationForMSVC(f, False)
     f.write(signature % (stubName, additionalArguments))
     f.write("{\n")
     f.write("    XPC_QS_ASSERT_CONTEXT_OK(cx);\n")
 
     # Compute "this".
     f.write("    JS::RootedObject obj(cx, JS_THIS_OBJECT(cx, vp));\n"
             "    if (!obj)\n"
-            "        return JS_FALSE;\n")
+            "        return false;\n")
 
     # Get the 'self' pointer.
     if customMethodCall is None or not 'thisType' in customMethodCall:
         f.write("    %s *self;\n" % member.iface.name)
     else:
         f.write("    %s *self;\n" % customMethodCall['thisType'])
     f.write("    xpc_qsSelfRef selfref;\n")
     pthisval = '&vp[1]' # as above, ok to overwrite vp[1]
 
     if unwrapThisFailureFatal:
         unwrapFatalArg = "true"
     else:
         unwrapFatalArg = "false"
 
     f.write("    if (!xpc_qsUnwrapThis(cx, obj, &self, "
             "&selfref.ptr, %s, %s))\n" % (pthisval, unwrapFatalArg))
-    f.write("        return JS_FALSE;\n")
+    f.write("        return false;\n")
 
     if not unwrapThisFailureFatal:
         f.write("      if (!self) {\n")
         if (isGetter):
             f.write("        *vp = JSVAL_NULL;\n")
-        f.write("        return JS_TRUE;\n")
+        f.write("        return true;\n")
         f.write("    }\n");
 
     if isMethod:
         # If there are any required arguments, check argc.
         requiredArgs = len(member.params)
         while requiredArgs and member.params[requiredArgs-1].optional:
             requiredArgs -= 1
     elif isSetter:
@@ -979,17 +979,17 @@ def writeQuickStub(f, customMethodCalls,
             f.write("        return xpc_qsThrowGetterSetterFailed(cx, rv, " +
                     "JSVAL_TO_OBJECT(vp[1]), (uint16_t)%d);\n" %
                     stringtable.stringIndex(member.name))
 
     # Convert the return value.
     if isMethod or isGetter:
         writeResultConv(f, member.realtype, 'vp', '*vp')
     else:
-        f.write("    return JS_TRUE;\n")
+        f.write("    return true;\n")
 
     # Epilog.
     f.write("}\n")
     if disableOptimizationForMSVC:
         setOptimizationForMSVC(f, True)
     f.write("\n")
 
     # Now write out the call to the template function.
--- a/startupcache/test/TestStartupCache.cpp
+++ b/startupcache/test/TestStartupCache.cpp
@@ -440,17 +440,17 @@ CompareCountArrays(JSContext *cx, JSObje
 
   JS::RootedValue before_num(cx), after_num(cx);
   for (uint32_t i = 0; i < before_size; ++i) {
     if (!(JS_GetElement(cx, before, i, &before_num)
           && JS_GetElement(cx, after, i, &after_num))) {
       return NS_ERROR_UNEXPECTED;
     }
 
-    JSBool same = JS_TRUE;
+    JSBool same = true;
     if (!JS_LooselyEqual(cx, before_num, after_num, &same)) {
       return NS_ERROR_UNEXPECTED;
     } else {
       if (same) {
         continue;
       } else {
         // Some element of the histograms's count arrays differed.
         // That's a good thing!
--- a/tools/profiler/JSObjectBuilder.cpp
+++ b/tools/profiler/JSObjectBuilder.cpp
@@ -2,17 +2,17 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "jsapi.h"
 #include "nsStringGlue.h"
 #include "JSObjectBuilder.h"
 
-JSObjectBuilder::JSObjectBuilder(JSContext *aCx) : mCx(aCx), mOk(JS_TRUE)
+JSObjectBuilder::JSObjectBuilder(JSContext *aCx) : mCx(aCx), mOk(true)
 {}
 
 void
 JSObjectBuilder::DefineProperty(JSCustomObject *aObject, const char *name, JSCustomArray *aValue)
 {
   DefineProperty(aObject, name, (JSCustomObject*)aValue);
 }
 
@@ -47,33 +47,33 @@ void
 JSObjectBuilder::DefineProperty(JSCustomObject *aObject, const char *name, nsAString &value)
 {
   if (!mOk)
     return;
 
   const nsString &flat = PromiseFlatString(value);
   JSString *string = JS_NewUCStringCopyN(mCx, static_cast<const jschar*>(flat.get()), flat.Length());
   if (!string)
-    mOk = JS_FALSE;
+    mOk = false;
 
   if (!mOk)
     return;
 
   mOk = JS_DefineProperty(mCx, (JSObject*)aObject, name, STRING_TO_JSVAL(string), nullptr, nullptr, JSPROP_ENUMERATE);
 }
 
 void
 JSObjectBuilder::DefineProperty(JSCustomObject *aObject, const char *name, const char *value, size_t valueLength)
 {
   if (!mOk)
     return;
 
   JSString *string = JS_InternStringN(mCx, value, valueLength);
   if (!string) {
-    mOk = JS_FALSE;
+    mOk = false;
     return;
   }
 
   mOk = JS_DefineProperty(mCx, (JSObject*)aObject, name, STRING_TO_JSVAL(string), nullptr, nullptr, JSPROP_ENUMERATE); }
 
 void
 JSObjectBuilder::DefineProperty(JSCustomObject *aObject, const char *name, const char *value)
 {
@@ -99,17 +99,17 @@ JSObjectBuilder::ArrayPush(JSCustomArray
 void
 JSObjectBuilder::ArrayPush(JSCustomArray *aArray, const char *value)
 {
   if (!mOk)
     return;
 
   JS::RootedString string(mCx, JS_NewStringCopyN(mCx, value, strlen(value)));
   if (!string) {
-    mOk = JS_FALSE;
+    mOk = false;
     return;
   }
 
   uint32_t length;
   mOk = JS_GetArrayLength(mCx, (JSObject*)aArray, &length);
 
   if (!mOk)
     return;
@@ -133,22 +133,22 @@ JSObjectBuilder::ArrayPush(JSCustomArray
   JS::Rooted<JS::Value> objval(mCx, OBJECT_TO_JSVAL((JSObject*)aObject));
   mOk = JS_SetElement(mCx, (JSObject*)aArray, length, &objval);
 }
 
 JSCustomArray*
 JSObjectBuilder::CreateArray() {
   JSCustomArray *array = (JSCustomArray*)JS_NewArrayObject(mCx, 0, nullptr);
   if (!array)
-    mOk = JS_FALSE;
+    mOk = false;
 
   return array;
 }
 
 JSCustomObject*
 JSObjectBuilder::CreateObject() {
   JSCustomObject *obj = (JSCustomObject*)JS_NewObject(mCx, nullptr, nullptr, nullptr);
   if (!obj)
-    mOk = JS_FALSE;
+    mOk = false;
 
   return obj;
 }
 
--- a/tools/profiler/SaveProfileTask.cpp
+++ b/tools/profiler/SaveProfileTask.cpp
@@ -7,17 +7,17 @@
 #include "GeckoProfilerImpl.h"
 
 static JSBool
 WriteCallback(const jschar *buf, uint32_t len, void *data)
 {
   std::ofstream& stream = *static_cast<std::ofstream*>(data);
   nsAutoCString profile = NS_ConvertUTF16toUTF8(buf, len);
   stream << profile.Data();
-  return JS_TRUE;
+  return true;
 }
 
 nsresult
 SaveProfileTask::Run() {
   // Get file path
 #if defined(SPS_PLAT_arm_android) && !defined(MOZ_WIDGET_GONK)
   nsCString tmpPath;
   tmpPath.AppendPrintf("/sdcard/profile_%i_%i.txt", XRE_GetProcessType(), getpid());
--- a/widget/xpwidgets/GfxInfoCollector.h
+++ b/widget/xpwidgets/GfxInfoCollector.h
@@ -33,37 +33,37 @@ class MOZ_STACK_CLASS InfoObject
   void DefineProperty(const char *name, nsAString &value)
   {
     if (!mOk)
       return;
 
     const nsString &flat = PromiseFlatString(value);
     JSString *string = JS_NewUCStringCopyN(mCx, static_cast<const jschar*>(flat.get()), flat.Length());
     if (!string)
-      mOk = JS_FALSE;
+      mOk = false;
 
     if (!mOk)
       return;
 
     mOk = JS_DefineProperty(mCx, mObj, name, STRING_TO_JSVAL(string), NULL, NULL, JSPROP_ENUMERATE);
   }
 
   void DefineProperty(const char *name, const char *value)
   {
     nsAutoString string = NS_ConvertASCIItoUTF16(value);
     DefineProperty(name, string);
   }
 
   private:
   // We need to ensure that this object lives on the stack so that GC sees it properly
-  InfoObject(JSContext *aCx) : mCx(aCx), mObj(aCx), mOk(JS_TRUE)
+  InfoObject(JSContext *aCx) : mCx(aCx), mObj(aCx), mOk(true)
   {
     mObj = JS_NewObject(mCx, NULL, NULL, NULL);
     if (!mObj)
-      mOk = JS_FALSE;
+      mOk = false;
   }
   InfoObject(InfoObject&);
 
   JSContext *mCx;
   JS::Rooted<JSObject*> mObj;
   JSBool mOk;
 };