Bug 690459: Remove usage of PR_TRUE and PR_FALSE from base plugin code. r=jst
authorJosh Aas <joshmoz@gmail.com>
Fri, 30 Sep 2011 02:02:59 -0400
changeset 77887 7558f15d82410a11cb9ecf4f6bcd0764854e66ee
parent 77886 b5b082d183d0a3913b93ff3d8dd7f759c56894d4
child 77888 98bb04b061d2dfc29e848390e55d8f23486a7334
push id3
push userfelipc@gmail.com
push dateFri, 30 Sep 2011 20:09:13 +0000
reviewersjst
bugs690459
milestone10.0a1
Bug 690459: Remove usage of PR_TRUE and PR_FALSE from base plugin code. r=jst
dom/plugins/base/PluginPRLibrary.cpp
dom/plugins/base/nsJSNPRuntime.cpp
dom/plugins/base/nsNPAPIPlugin.cpp
dom/plugins/base/nsNPAPIPluginInstance.cpp
dom/plugins/base/nsNPAPIPluginStreamListener.cpp
dom/plugins/base/nsPluginDirServiceProvider.cpp
dom/plugins/base/nsPluginHost.cpp
dom/plugins/base/nsPluginHost.h
dom/plugins/base/nsPluginInstanceOwner.cpp
dom/plugins/base/nsPluginInstanceOwner.h
dom/plugins/base/nsPluginManifestLineReader.h
dom/plugins/base/nsPluginNativeWindowGtk2.cpp
dom/plugins/base/nsPluginNativeWindowOS2.cpp
dom/plugins/base/nsPluginNativeWindowWin.cpp
dom/plugins/base/nsPluginSafety.h
dom/plugins/base/nsPluginStreamListenerPeer.cpp
dom/plugins/base/nsPluginStreamListenerPeer.h
dom/plugins/base/nsPluginTags.cpp
dom/plugins/base/nsPluginsDirDarwin.cpp
dom/plugins/base/nsPluginsDirOS2.cpp
dom/plugins/base/nsPluginsDirUnix.cpp
dom/plugins/base/nsPluginsDirWin.cpp
--- a/dom/plugins/base/PluginPRLibrary.cpp
+++ b/dom/plugins/base/PluginPRLibrary.cpp
@@ -292,17 +292,17 @@ PluginPRLibrary::GetImage(NPP instance, 
 }
 
 #if defined(XP_MACOSX)
 nsresult
 PluginPRLibrary::IsRemoteDrawingCoreAnimation(NPP instance, bool *aDrawing)
 {
   nsNPAPIPluginInstance* inst = (nsNPAPIPluginInstance*)instance->ndata;
   NS_ENSURE_TRUE(inst, NS_ERROR_NULL_POINTER);
-  *aDrawing = PR_FALSE; 
+  *aDrawing = false; 
   return NS_OK;
 }
 #endif
 
 nsresult
 PluginPRLibrary::GetImageSize(NPP instance, nsIntSize* aSize)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
--- a/dom/plugins/base/nsJSNPRuntime.cpp
+++ b/dom/plugins/base/nsJSNPRuntime.cpp
@@ -321,17 +321,17 @@ struct AutoCXPusher
 
     if (!currentCx) {
       // No JS is running, tell the context we're done executing
       // script.
 
       nsIScriptContext *scx = GetScriptContextFromJSContext(cx);
 
       if (scx) {
-        scx->ScriptEvaluated(PR_TRUE);
+        scx->ScriptEvaluated(true);
       }
     }
 
     OnWrapperDestroyed();
   }
 };
 
 namespace mozilla {
@@ -619,34 +619,34 @@ GetProperty(JSContext *cx, JSObject *obj
 // static
 bool
 nsJSObjWrapper::NP_HasMethod(NPObject *npobj, NPIdentifier id)
 {
   NPP npp = NPPStack::Peek();
   JSContext *cx = GetJSContext(npp);
 
   if (!cx) {
-    return PR_FALSE;
+    return false;
   }
 
   if (!npobj) {
     ThrowJSException(cx,
                      "Null npobj in nsJSObjWrapper::NP_HasMethod!");
 
-    return PR_FALSE;
+    return false;
   }
 
   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
 
   AutoCXPusher pusher(cx);
   JSAutoRequest ar(cx);
   JSAutoEnterCompartment ac;
 
   if (!ac.enter(cx, npjsobj->mJSObj))
-    return PR_FALSE;
+    return false;
 
   AutoJSExceptionReporter reporter(cx);
 
   jsval v;
   JSBool ok = GetProperty(cx, npjsobj->mJSObj, id, &v);
 
   return ok && !JSVAL_IS_PRIMITIVE(v) &&
     ::JS_ObjectIsFunction(cx, JSVAL_TO_OBJECT(v));
@@ -655,60 +655,60 @@ nsJSObjWrapper::NP_HasMethod(NPObject *n
 static bool
 doInvoke(NPObject *npobj, NPIdentifier method, const NPVariant *args,
          uint32_t argCount, bool ctorCall, NPVariant *result)
 {
   NPP npp = NPPStack::Peek();
   JSContext *cx = GetJSContext(npp);
 
   if (!cx) {
-    return PR_FALSE;
+    return false;
   }
 
   if (!npobj || !result) {
     ThrowJSException(cx, "Null npobj, or result in doInvoke!");
 
-    return PR_FALSE;
+    return false;
   }
 
   // Initialize *result
   VOID_TO_NPVARIANT(*result);
 
   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
   jsval fv;
 
   AutoCXPusher pusher(cx);
   JSAutoRequest ar(cx);
   JSAutoEnterCompartment ac;
 
   if (!ac.enter(cx, npjsobj->mJSObj))
-    return PR_FALSE;
+    return false;
 
   AutoJSExceptionReporter reporter(cx);
 
   if (method != NPIdentifier_VOID) {
     if (!GetProperty(cx, npjsobj->mJSObj, method, &fv) ||
         ::JS_TypeOfValue(cx, fv) != JSTYPE_FUNCTION) {
-      return PR_FALSE;
+      return false;
     }
   } else {
     fv = OBJECT_TO_JSVAL(npjsobj->mJSObj);
   }
 
   jsval jsargs_buf[8];
   jsval *jsargs = jsargs_buf;
 
   if (argCount > (sizeof(jsargs_buf) / sizeof(jsval))) {
     // Our stack buffer isn't large enough to hold all arguments,
     // malloc a buffer.
     jsargs = (jsval *)PR_Malloc(argCount * sizeof(jsval));
     if (!jsargs) {
       ::JS_ReportOutOfMemory(cx);
 
-      return PR_FALSE;
+      return false;
     }
   }
 
   jsval v;
   JSBool ok;
 
   {
     js::AutoArrayRooter tvr(cx, 0, jsargs);
@@ -748,129 +748,129 @@ doInvoke(NPObject *npobj, NPIdentifier m
 
 // static
 bool
 nsJSObjWrapper::NP_Invoke(NPObject *npobj, NPIdentifier method,
                           const NPVariant *args, uint32_t argCount,
                           NPVariant *result)
 {
   if (method == NPIdentifier_VOID) {
-    return PR_FALSE;
+    return false;
   }
 
-  return doInvoke(npobj, method, args, argCount, PR_FALSE, result);
+  return doInvoke(npobj, method, args, argCount, false, result);
 }
 
 // static
 bool
 nsJSObjWrapper::NP_InvokeDefault(NPObject *npobj, const NPVariant *args,
                                  uint32_t argCount, NPVariant *result)
 {
-  return doInvoke(npobj, NPIdentifier_VOID, args, argCount, PR_FALSE,
+  return doInvoke(npobj, NPIdentifier_VOID, args, argCount, false,
                   result);
 }
 
 // static
 bool
 nsJSObjWrapper::NP_HasProperty(NPObject *npobj, NPIdentifier id)
 {
   NPP npp = NPPStack::Peek();
   JSContext *cx = GetJSContext(npp);
 
   if (!cx) {
-    return PR_FALSE;
+    return false;
   }
 
   if (!npobj) {
     ThrowJSException(cx,
                      "Null npobj in nsJSObjWrapper::NP_HasProperty!");
 
-    return PR_FALSE;
+    return false;
   }
 
   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
   JSBool found, ok = JS_FALSE;
 
   AutoCXPusher pusher(cx);
   JSAutoRequest ar(cx);
   AutoJSExceptionReporter reporter(cx);
   JSAutoEnterCompartment ac;
 
   if (!ac.enter(cx, npjsobj->mJSObj))
-    return PR_FALSE;
+    return false;
 
   NS_ASSERTION(NPIdentifierIsInt(id) || NPIdentifierIsString(id),
                "id must be either string or int!\n");
   ok = ::JS_HasPropertyById(cx, npjsobj->mJSObj, NPIdentifierToJSId(id), &found);
   return ok && found;
 }
 
 // static
 bool
 nsJSObjWrapper::NP_GetProperty(NPObject *npobj, NPIdentifier id,
                                NPVariant *result)
 {
   NPP npp = NPPStack::Peek();
   JSContext *cx = GetJSContext(npp);
 
   if (!cx) {
-    return PR_FALSE;
+    return false;
   }
 
   if (!npobj) {
     ThrowJSException(cx,
                      "Null npobj in nsJSObjWrapper::NP_GetProperty!");
 
-    return PR_FALSE;
+    return false;
   }
 
   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
 
   AutoCXPusher pusher(cx);
   JSAutoRequest ar(cx);
   AutoJSExceptionReporter reporter(cx);
   JSAutoEnterCompartment ac;
 
   if (!ac.enter(cx, npjsobj->mJSObj))
-    return PR_FALSE;
+    return false;
 
   jsval v;
   return (GetProperty(cx, npjsobj->mJSObj, id, &v) &&
           JSValToNPVariant(npp, cx, v, result));
 }
 
 // static
 bool
 nsJSObjWrapper::NP_SetProperty(NPObject *npobj, NPIdentifier id,
                                const NPVariant *value)
 {
   NPP npp = NPPStack::Peek();
   JSContext *cx = GetJSContext(npp);
 
   if (!cx) {
-    return PR_FALSE;
+    return false;
   }
 
   if (!npobj) {
     ThrowJSException(cx,
                      "Null npobj in nsJSObjWrapper::NP_SetProperty!");
 
-    return PR_FALSE;
+    return false;
   }
 
   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
   JSBool ok = JS_FALSE;
 
   AutoCXPusher pusher(cx);
   JSAutoRequest ar(cx);
   AutoJSExceptionReporter reporter(cx);
   JSAutoEnterCompartment ac;
 
   if (!ac.enter(cx, npjsobj->mJSObj))
-    return PR_FALSE;
+    return false;
 
   jsval v = NPVariantToJSVal(npp, cx, value);
   js::AutoValueRooter tvr(cx, v);
 
   NS_ASSERTION(NPIdentifierIsInt(id) || NPIdentifierIsString(id),
                "id must be either string or int!\n");
   ok = ::JS_SetPropertyById(cx, npjsobj->mJSObj, NPIdentifierToJSId(id), &v);
 
@@ -882,37 +882,37 @@ nsJSObjWrapper::NP_SetProperty(NPObject 
 // static
 bool
 nsJSObjWrapper::NP_RemoveProperty(NPObject *npobj, NPIdentifier id)
 {
   NPP npp = NPPStack::Peek();
   JSContext *cx = GetJSContext(npp);
 
   if (!cx) {
-    return PR_FALSE;
+    return false;
   }
 
   if (!npobj) {
     ThrowJSException(cx,
                      "Null npobj in nsJSObjWrapper::NP_RemoveProperty!");
 
-    return PR_FALSE;
+    return false;
   }
 
   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
   JSBool ok = JS_FALSE;
 
   AutoCXPusher pusher(cx);
   JSAutoRequest ar(cx);
   AutoJSExceptionReporter reporter(cx);
   jsval deleted = JSVAL_FALSE;
   JSAutoEnterCompartment ac;
 
   if (!ac.enter(cx, npjsobj->mJSObj))
-    return PR_FALSE;
+    return false;
 
   NS_ASSERTION(NPIdentifierIsInt(id) || NPIdentifierIsString(id),
                "id must be either string or int!\n");
   ok = ::JS_DeletePropertyById2(cx, npjsobj->mJSObj, NPIdentifierToJSId(id), &deleted);
   if (ok && deleted == JSVAL_TRUE) {
     // FIXME: See bug 425823, we shouldn't need to do this, and once
     // that bug is fixed we can remove this code.
 
@@ -939,89 +939,89 @@ nsJSObjWrapper::NP_Enumerate(NPObject *n
 {
   NPP npp = NPPStack::Peek();
   JSContext *cx = GetJSContext(npp);
 
   *idarray = 0;
   *count = 0;
 
   if (!cx) {
-    return PR_FALSE;
+    return false;
   }
 
   if (!npobj) {
     ThrowJSException(cx,
                      "Null npobj in nsJSObjWrapper::NP_Enumerate!");
 
-    return PR_FALSE;
+    return false;
   }
 
   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
 
   AutoCXPusher pusher(cx);
   JSAutoRequest ar(cx);
   AutoJSExceptionReporter reporter(cx);
   JSAutoEnterCompartment ac;
 
   if (!ac.enter(cx, npjsobj->mJSObj))
-    return PR_FALSE;
+    return false;
 
   JSIdArray *ida = ::JS_Enumerate(cx, npjsobj->mJSObj);
   if (!ida) {
-    return PR_FALSE;
+    return false;
   }
 
   *count = ida->length;
   *idarray = (NPIdentifier *)PR_Malloc(*count * sizeof(NPIdentifier));
   if (!*idarray) {
     ThrowJSException(cx, "Memory allocation failed for NPIdentifier!");
 
     ::JS_DestroyIdArray(cx, ida);
 
-    return PR_FALSE;
+    return false;
   }
 
   for (PRUint32 i = 0; i < *count; i++) {
     jsval v;
     if (!::JS_IdToValue(cx, ida->vector[i], &v)) {
       ::JS_DestroyIdArray(cx, ida);
       PR_Free(*idarray);
-      return PR_FALSE;
+      return false;
     }
 
     NPIdentifier id;
     if (JSVAL_IS_STRING(v)) {
       JSString *str = JS_InternJSString(cx, JSVAL_TO_STRING(v));
       if (!str) {
           ::JS_DestroyIdArray(cx, ida);
           PR_Free(*idarray);
 
-          return PR_FALSE;
+          return false;
       }
       id = StringToNPIdentifier(cx, str);
     } else {
       NS_ASSERTION(JSVAL_IS_INT(v),
                    "The element in ida must be either string or int!\n");
       id = IntToNPIdentifier(JSVAL_TO_INT(v));
     }
 
     (*idarray)[i] = id;
   }
 
   ::JS_DestroyIdArray(cx, ida);
 
-  return PR_TRUE;
+  return true;
 }
 
 //static
 bool
 nsJSObjWrapper::NP_Construct(NPObject *npobj, const NPVariant *args,
                              uint32_t argCount, NPVariant *result)
 {
-  return doInvoke(npobj, NPIdentifier_VOID, args, argCount, PR_TRUE, result);
+  return doInvoke(npobj, NPIdentifier_VOID, args, argCount, true, result);
 }
 
 
 class JSObjWrapperHashEntry : public PLDHashEntryHdr
 {
 public:
   nsJSObjWrapper *mJSObjWrapper;
 };
@@ -1535,17 +1535,17 @@ CallNPMethodInternal(JSContext *cx, JSOb
 
 static JSBool
 CallNPMethod(JSContext *cx, uintN argc, jsval *vp)
 {
   JSObject *obj = JS_THIS_OBJECT(cx, vp);
   if (!obj)
       return JS_FALSE;
 
-  return CallNPMethodInternal(cx, obj, argc, JS_ARGV(cx, vp), vp, PR_FALSE);
+  return CallNPMethodInternal(cx, obj, argc, JS_ARGV(cx, vp), vp, false);
 }
 
 struct NPObjectEnumerateState {
   PRUint32     index;
   PRUint32     length;
   NPIdentifier *value;
 };
 
@@ -1709,24 +1709,24 @@ NPObjWrapper_Finalize(JSContext *cx, JSO
     sDelayedReleases = new nsTArray<NPObject*>;
   sDelayedReleases->AppendElement(npobj);
 }
 
 static JSBool
 NPObjWrapper_Call(JSContext *cx, uintN argc, jsval *vp)
 {
   return CallNPMethodInternal(cx, JSVAL_TO_OBJECT(JS_CALLEE(cx, vp)), argc,
-                              JS_ARGV(cx, vp), vp, PR_FALSE);
+                              JS_ARGV(cx, vp), vp, false);
 }
 
 static JSBool
 NPObjWrapper_Construct(JSContext *cx, uintN argc, jsval *vp)
 {
   return CallNPMethodInternal(cx, JSVAL_TO_OBJECT(JS_CALLEE(cx, vp)), argc,
-                              JS_ARGV(cx, vp), vp, PR_TRUE);
+                              JS_ARGV(cx, vp), vp, true);
 }
 
 class NPObjWrapperHashEntry : public PLDHashEntryHdr
 {
 public:
   NPObject *mNPObj; // Must be the first member for the PLDHash stubs to work
   JSObject *mJSObj;
   NPP mNpp;
--- a/dom/plugins/base/nsNPAPIPlugin.cpp
+++ b/dom/plugins/base/nsNPAPIPlugin.cpp
@@ -234,17 +234,17 @@ static void CheckClassInitialized()
   static bool initialized = false;
 
   if (initialized)
     return;
 
   if (!sPluginThreadAsyncCallLock)
     sPluginThreadAsyncCallLock = new Mutex("nsNPAPIPlugin.sPluginThreadAsyncCallLock");
 
-  initialized = PR_TRUE;
+  initialized = true;
 
   NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,("NPN callbacks initialized\n"));
 }
 
 NS_IMPL_ISUPPORTS0(nsNPAPIPlugin)
 
 nsNPAPIPlugin::nsNPAPIPlugin()
 {
@@ -285,98 +285,98 @@ static PRInt32 OSXVersion()
 }
 
 // Detects machines with Intel GMA9xx GPUs.
 // kCGLRendererIDMatchingMask and kCGLRendererIntel900ID are only defined in the 10.6 SDK.
 #define CGLRendererIDMatchingMask 0x00FE7F00
 #define CGLRendererIntel900ID 0x00024000
 static bool GMA9XXGraphics()
 {
-  bool hasIntelGMA9XX = PR_FALSE;
+  bool hasIntelGMA9XX = false;
   CGLRendererInfoObj renderer = 0;
   GLint rendererCount = 0;
   if (::CGLQueryRendererInfo(0xffffffff, &renderer, &rendererCount) == kCGLNoError) {
     for (GLint c = 0; c < rendererCount; c++) {
       GLint rendProp = 0;
       if (::CGLDescribeRenderer(renderer, c, kCGLRPRendererID, &rendProp) == kCGLNoError) {
         if ((rendProp & CGLRendererIDMatchingMask) == CGLRendererIntel900ID) {
-          hasIntelGMA9XX = PR_TRUE;
+          hasIntelGMA9XX = true;
           break;
         }
       }
     }
     ::CGLDestroyRendererInfo(renderer);
   }
   return hasIntelGMA9XX;
 }
 #endif
 
 bool
 nsNPAPIPlugin::RunPluginOOP(const nsPluginTag *aPluginTag)
 {
   if (PR_GetEnv("MOZ_DISABLE_OOP_PLUGINS")) {
-    return PR_FALSE;
+    return false;
   }
 
   if (!aPluginTag) {
-    return PR_FALSE;
+    return false;
   }
 
 #if defined(XP_MACOSX) && defined(__i386__)
   // Only allow on Mac OS X 10.6 or higher.
   if (OSXVersion() < 0x00001060) {
-    return PR_FALSE;
+    return false;
   }
   // Blacklist Flash 10.0 or lower since it may try to negotiate Carbon/Quickdraw
   // which are not supported out of process. Also blacklist Flash 10.1 if this
   // machine has an Intel GMA9XX GPU because Flash will negotiate Quickdraw graphics.
   // Never blacklist Flash >= 10.2.
   if (aPluginTag->mFileName.EqualsIgnoreCase("flash player.plugin")) {
     // If the first '.' is before position 2 or the version 
     // starts with 10.0 then we are dealing with Flash 10 or less.
     if (aPluginTag->mVersion.FindChar('.') < 2) {
-      return PR_FALSE;
+      return false;
     }
     if (aPluginTag->mVersion.Length() >= 4) {
       nsCString versionPrefix;
       aPluginTag->mVersion.Left(versionPrefix, 4);
       if (versionPrefix.EqualsASCII("10.0")) {
-        return PR_FALSE;
+        return false;
       }
       if (versionPrefix.EqualsASCII("10.1") && GMA9XXGraphics()) {
-        return PR_FALSE;
+        return false;
       }
     }
   }
 #endif
 
 #ifdef XP_WIN
   OSVERSIONINFO osVerInfo = {0};
   osVerInfo.dwOSVersionInfoSize = sizeof(osVerInfo);
   GetVersionEx(&osVerInfo);
   // Always disabled on 2K or less. (bug 536303)
   if (osVerInfo.dwMajorVersion < 5 ||
       (osVerInfo.dwMajorVersion == 5 && osVerInfo.dwMinorVersion == 0))
-    return PR_FALSE;
+    return false;
 #endif
 
   nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
   if (!prefs) {
-    return PR_FALSE;
+    return false;
   }
 
   // Get per-library whitelist/blacklist pref string
   // "dom.ipc.plugins.enabled.filename.dll" and fall back to the default value
   // of "dom.ipc.plugins.enabled"
   // The "filename.dll" part can contain shell wildcard pattern
 
   nsCAutoString prefFile(aPluginTag->mFullPath.get());
   PRInt32 slashPos = prefFile.RFindCharInSet("/\\");
   if (kNotFound == slashPos)
-    return PR_FALSE;
+    return false;
   prefFile.Cut(0, slashPos + 1);
   ToLowerCase(prefFile);
 
 #ifdef XP_MACOSX
 #if defined(__i386__)
   nsCAutoString prefGroupKey("dom.ipc.plugins.enabled.i386.");
 #elif defined(__x86_64__)
   nsCAutoString prefGroupKey("dom.ipc.plugins.enabled.x86_64.");
@@ -388,17 +388,17 @@ nsNPAPIPlugin::RunPluginOOP(const nsPlug
 #endif
 
   // Java plugins include a number of different file names,
   // so use the mime type (mIsJavaPlugin) and a special pref.
   bool javaIsEnabled;
   if (aPluginTag->mIsJavaPlugin &&
       NS_SUCCEEDED(prefs->GetBoolPref("dom.ipc.plugins.java.enabled", &javaIsEnabled)) &&
       !javaIsEnabled) {
-    return PR_FALSE;
+    return false;
   }
 
   PRUint32 prefCount;
   char** prefNames;
   nsresult rv = prefs->GetChildList(prefGroupKey.get(),
                                     &prefCount, &prefNames);
 
   bool oopPluginsEnabled = false;
@@ -420,25 +420,25 @@ nsNPAPIPlugin::RunPluginOOP(const nsPlug
         match = (strcmp(prefFile.get(), maskStart) == 0);
       }
       else {
         match = (NS_WildCardMatch(prefFile.get(), maskStart, 0) == MATCH);
       }
 
       if (match && NS_SUCCEEDED(prefs->GetBoolPref(prefNames[currentPref],
                                                    &oopPluginsEnabled))) {
-        prefSet = PR_TRUE;
+        prefSet = true;
         break;
       }
     }
     NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, prefNames);
   }
 
   if (!prefSet) {
-    oopPluginsEnabled = PR_FALSE;
+    oopPluginsEnabled = false;
 #ifdef XP_MACOSX
 #if defined(__i386__)
     prefs->GetBoolPref("dom.ipc.plugins.enabled.i386", &oopPluginsEnabled);
 #elif defined(__x86_64__)
     prefs->GetBoolPref("dom.ipc.plugins.enabled.x86_64", &oopPluginsEnabled);
 #elif defined(__ppc__)
     prefs->GetBoolPref("dom.ipc.plugins.enabled.ppc", &oopPluginsEnabled);
 #endif
@@ -576,17 +576,17 @@ nsNPAPIPlugin::Shutdown()
 
 // Create a new NPP GET or POST (given in the type argument) url
 // stream that may have a notify callback
 NPError
 MakeNewNPAPIStreamInternal(NPP npp, const char *relativeURL, const char *target,
                           eNPPStreamTypeInternal type,
                           bool bDoNotify = false,
                           void *notifyData = nsnull, uint32_t len = 0,
-                          const char *buf = nsnull, NPBool file = PR_FALSE)
+                          const char *buf = nsnull, NPBool file = false)
 {
   if (!npp)
     return NPERR_INVALID_INSTANCE_ERROR;
 
   PluginDestructionGuard guard(npp);
 
   nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *) npp->ndata;
   if (!inst || !inst->IsRunning())
@@ -603,17 +603,17 @@ MakeNewNPAPIStreamInternal(NPP npp, cons
   // the listener's destructor will do the notification while we are about to
   // return a failure code.
   // Call SetCallNotify(true) below after we are sure we cannot return a failure 
   // code.
   if (!target) {
     inst->NewStreamListener(relativeURL, notifyData,
                             getter_AddRefs(listener));
     if (listener) {
-      static_cast<nsNPAPIPluginStreamListener*>(listener.get())->SetCallNotify(PR_FALSE);
+      static_cast<nsNPAPIPluginStreamListener*>(listener.get())->SetCallNotify(false);
     }
   }
 
   switch (type) {
   case eNPPStreamTypeInternal_Get:
     {
       if (NS_FAILED(pluginHost->GetURL(inst, relativeURL, target, listener,
                                        NULL, NULL, false)))
@@ -995,17 +995,17 @@ NPError NP_CALLBACK
 
   NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
     ("NPN_GetURLNotify: npp=%p, target=%s, notify=%p, url=%s\n", (void*)npp,
      target, notifyData, relativeURL));
 
   PluginDestructionGuard guard(npp);
 
   return MakeNewNPAPIStreamInternal(npp, relativeURL, target,
-                                    eNPPStreamTypeInternal_Get, PR_TRUE,
+                                    eNPPStreamTypeInternal_Get, true,
                                     notifyData);
 }
 
 NPError NP_CALLBACK
 _posturlnotify(NPP npp, const char *relativeURL, const char *target,
                uint32_t len, const char *buf, NPBool file, void *notifyData)
 {
   if (!NS_IsMainThread()) {
@@ -1019,17 +1019,17 @@ NPError NP_CALLBACK
                  ("NPN_PostURLNotify: npp=%p, target=%s, len=%d, file=%d, "
                   "notify=%p, url=%s, buf=%s\n",
                   (void*)npp, target, len, file, notifyData, relativeURL,
                   buf));
 
   PluginDestructionGuard guard(npp);
 
   return MakeNewNPAPIStreamInternal(npp, relativeURL, target,
-                                    eNPPStreamTypeInternal_Post, PR_TRUE,
+                                    eNPPStreamTypeInternal_Post, true,
                                     notifyData, len, buf, file);
 }
 
 NPError NP_CALLBACK
 _posturl(NPP npp, const char *relativeURL, const char *target,
          uint32_t len, const char *buf, NPBool file)
 {
   if (!NS_IsMainThread()) {
@@ -1039,17 +1039,17 @@ NPError NP_CALLBACK
   NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
                  ("NPN_PostURL: npp=%p, target=%s, file=%d, len=%d, url=%s, "
                   "buf=%s\n",
                   (void*)npp, target, file, len, relativeURL, buf));
 
   PluginDestructionGuard guard(npp);
 
   return MakeNewNPAPIStreamInternal(npp, relativeURL, target,
-                                    eNPPStreamTypeInternal_Post, PR_FALSE, nsnull,
+                                    eNPPStreamTypeInternal_Post, false, nsnull,
                                     len, buf, file);
 }
 
 NPError NP_CALLBACK
 _newstream(NPP npp, NPMIMEType type, const char* target, NPStream* *result)
 {
   if (!NS_IsMainThread()) {
     NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_newstream called from the wrong thread\n"));
@@ -1203,17 +1203,17 @@ void NP_CALLBACK
 uint32_t NP_CALLBACK
 _memflush(uint32_t size)
 {
   if (!NS_IsMainThread()) {
     NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_memflush called from the wrong thread\n"));
   }
   NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY, ("NPN_MemFlush: size=%d\n", size));
 
-  nsMemory::HeapMinimize(PR_TRUE);
+  nsMemory::HeapMinimize(true);
   return 0;
 }
 
 void NP_CALLBACK
 _reloadplugins(NPBool reloadPages)
 {
   if (!NS_IsMainThread()) {
     NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_reloadplugins called from the wrong thread\n"));
@@ -1756,17 +1756,17 @@ bool NP_CALLBACK
     return true;
 
   NPString urlnp = NPVARIANT_TO_STRING(*result);
   nsXPIDLCString url;
   url.Assign(urlnp.UTF8Characters, urlnp.UTF8Length);
 
   bool javaCompatible = false;
   if (NS_FAILED(NS_CheckIsJavaCompatibleURLString(url, &javaCompatible)))
-    javaCompatible = PR_FALSE;
+    javaCompatible = false;
   if (javaCompatible)
     return true;
 
   // If Java won't be able to interpret the original value of document.URL or
   // document.documentURI, or is likely to mishandle it, pass back something
   // that Java will understand but won't be able to use to access the network,
   // and for which same-origin checks will always fail.
 
@@ -2020,22 +2020,22 @@ NPError NP_CALLBACK
   switch(variable) {
 #if defined(XP_UNIX) && !defined(XP_MACOSX)
   case NPNVxDisplay : {
 #if defined(MOZ_X11)
     if (npp) {
       nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *) npp->ndata;
       bool windowless = false;
       inst->IsWindowless(&windowless);
-      NPBool needXEmbed = PR_FALSE;
+      NPBool needXEmbed = false;
       if (!windowless) {
         res = inst->GetValueFromPlugin(NPPVpluginNeedsXEmbed, &needXEmbed);
         // If the call returned an error code make sure we still use our default value.
         if (NS_FAILED(res)) {
-          needXEmbed = PR_FALSE;
+          needXEmbed = false;
         }
       }
       if (windowless || needXEmbed) {
         (*(Display **)result) = mozilla::DefaultXDisplay();
         return NPERR_NO_ERROR;
       }
     }
 #ifdef MOZ_WIDGET_GTK2
@@ -2074,29 +2074,29 @@ NPError NP_CALLBACK
     if (NS_SUCCEEDED(owner->GetNetscapeWindow(result))) {
       return NPERR_NO_ERROR;
     }
     return NPERR_GENERIC_ERROR;
   }
 #endif
 
   case NPNVjavascriptEnabledBool: {
-    *(NPBool*)result = PR_FALSE;
+    *(NPBool*)result = false;
     nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
     if (prefs) {
       bool js = false;;
       res = prefs->GetBoolPref("javascript.enabled", &js);
       if (NS_SUCCEEDED(res))
         *(NPBool*)result = js;
     }
     return NPERR_NO_ERROR;
   }
 
   case NPNVasdEnabledBool:
-    *(NPBool*)result = PR_FALSE;
+    *(NPBool*)result = false;
     return NPERR_NO_ERROR;
 
   case NPNVisOfflineBool: {
     bool offline = false;
     nsCOMPtr<nsIIOService> ioservice =
       do_GetService(NS_IOSERVICE_CONTRACTID, &res);
     if (NS_SUCCEEDED(res))
       res = ioservice->GetOffline(&offline);
@@ -2119,24 +2119,24 @@ NPError NP_CALLBACK
     if (*(NPNToolkitType*)result)
         return NPERR_NO_ERROR;
 
     return NPERR_GENERIC_ERROR;
   }
 
   case NPNVSupportsXEmbedBool: {
 #ifdef MOZ_WIDGET_GTK2
-    *(NPBool*)result = PR_TRUE;
+    *(NPBool*)result = true;
 #elif defined(MOZ_WIDGET_QT)
     // Desktop Flash fail to initialize if browser does not support NPNVSupportsXEmbedBool
     // even when wmode!=windowed, lets return fake support
     fprintf(stderr, "Fake support for XEmbed plugins in Qt port\n");
-    *(NPBool*)result = PR_TRUE;
+    *(NPBool*)result = true;
 #else
-    *(NPBool*)result = PR_FALSE;
+    *(NPBool*)result = false;
 #endif
     return NPERR_NO_ERROR;
   }
 
   case NPNVWindowNPObject: {
     *(NPObject **)result = _getwindowobject(npp);
 
     return *(NPObject **)result ? NPERR_NO_ERROR : NPERR_GENERIC_ERROR;
@@ -2146,19 +2146,19 @@ NPError NP_CALLBACK
     *(NPObject **)result = _getpluginelement(npp);
 
     return *(NPObject **)result ? NPERR_NO_ERROR : NPERR_GENERIC_ERROR;
   }
 
   case NPNVSupportsWindowless: {
 #if defined(XP_WIN) || defined(XP_MACOSX) || \
     (defined(MOZ_X11) && (defined(MOZ_WIDGET_GTK2) || defined(MOZ_WIDGET_QT)))
-    *(NPBool*)result = PR_TRUE;
+    *(NPBool*)result = true;
 #else
-    *(NPBool*)result = PR_FALSE;
+    *(NPBool*)result = false;
 #endif
     return NPERR_NO_ERROR;
   }
 
   case NPNVprivateModeBool: {
     nsCOMPtr<nsIPrivateBrowsingService> pbs = do_GetService(NS_PRIVATE_BROWSING_SERVICE_CONTRACTID);
     if (pbs) {
       bool enabled;
@@ -2222,50 +2222,50 @@ NPError NP_CALLBACK
     }
     else {
       return NPERR_GENERIC_ERROR;
     }
   }
 
 #ifndef NP_NO_QUICKDRAW
   case NPNVsupportsQuickDrawBool: {
-    *(NPBool*)result = PR_TRUE;
+    *(NPBool*)result = true;
     
     return NPERR_NO_ERROR;
   }
 #endif
 
   case NPNVsupportsCoreGraphicsBool: {
-    *(NPBool*)result = PR_TRUE;
+    *(NPBool*)result = true;
     
     return NPERR_NO_ERROR;
   }
 
    case NPNVsupportsCoreAnimationBool: {
-     *(NPBool*)result = PR_TRUE;
+     *(NPBool*)result = true;
 
      return NPERR_NO_ERROR;
    }
 
    case NPNVsupportsInvalidatingCoreAnimationBool: {
-     *(NPBool*)result = PR_TRUE;
+     *(NPBool*)result = true;
 
      return NPERR_NO_ERROR;
    }
 
 
 #ifndef NP_NO_CARBON
   case NPNVsupportsCarbonBool: {
-    *(NPBool*)result = PR_TRUE;
+    *(NPBool*)result = true;
 
     return NPERR_NO_ERROR;
   }
 #endif
   case NPNVsupportsCocoaBool: {
-    *(NPBool*)result = PR_TRUE;
+    *(NPBool*)result = true;
 
     return NPERR_NO_ERROR;
   }
 
   case NPNVsupportsUpdatedCocoaTextInputBool: {
     *(NPBool*)result = true;
     return NPERR_NO_ERROR;
   }
@@ -2825,17 +2825,17 @@ NPError NP_CALLBACK
   return inst->PopUpContextMenu(menu);
 }
 
 NPBool NP_CALLBACK
 _convertpoint(NPP instance, double sourceX, double sourceY, NPCoordinateSpace sourceSpace, double *destX, double *destY, NPCoordinateSpace destSpace)
 {
   nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
   if (!inst)
-    return PR_FALSE;
+    return false;
 
   return inst->ConvertPoint(sourceX, sourceY, sourceSpace, destX, destY, destSpace);
 }
 
 void NP_CALLBACK
 _urlredirectresponse(NPP instance, void* notifyData, NPBool allow)
 {
   nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
--- a/dom/plugins/base/nsNPAPIPluginInstance.cpp
+++ b/dom/plugins/base/nsNPAPIPluginInstance.cpp
@@ -87,29 +87,29 @@ nsNPAPIPluginInstance::nsNPAPIPluginInst
     mDrawingModel(NPDrawingModelQuickDraw),
 #endif
 #endif
 #ifdef ANDROID
     mSurface(nsnull),
     mDrawingModel(0),
 #endif
     mRunning(NOT_STARTED),
-    mWindowless(PR_FALSE),
-    mWindowlessLocal(PR_FALSE),
-    mTransparent(PR_FALSE),
-    mUsesDOMForCursor(PR_FALSE),
-    mInPluginInitCall(PR_FALSE),
+    mWindowless(false),
+    mWindowlessLocal(false),
+    mTransparent(false),
+    mUsesDOMForCursor(false),
+    mInPluginInitCall(false),
     mPlugin(plugin),
     mMIMEType(nsnull),
     mOwner(nsnull),
     mCurrentPluginEvent(nsnull),
 #if defined(MOZ_X11) || defined(XP_WIN) || defined(XP_MACOSX)
-    mUsePluginLayersPref(PR_TRUE)
+    mUsePluginLayersPref(true)
 #else
-    mUsePluginLayersPref(PR_FALSE)
+    mUsePluginLayersPref(false)
 #endif
 {
   NS_ASSERTION(mPlugin != NULL, "Plugin is required when creating an instance.");
 
   // Initialize the NPP structure.
 
   mNPP.pdata = NULL;
   mNPP.ndata = this;
@@ -399,17 +399,17 @@ nsNPAPIPluginInstance::InitializePlugin(
           }
           break;
         }
       }
     }
   }
 
   bool oldVal = mInPluginInitCall;
-  mInPluginInitCall = PR_TRUE;
+  mInPluginInitCall = true;
 
   // Need this on the stack before calling NPP_New otherwise some callbacks that
   // the plugin may make could fail (NPN_HasProperty, for example).
   NPPAutoPusher autopush(&mNPP);
 
   if (!mPlugin)
     return NS_ERROR_FAILURE;
 
@@ -462,17 +462,17 @@ nsresult nsNPAPIPluginInstance::SetWindo
     PluginDestructionGuard guard(this);
 
     // XXX Turns out that NPPluginWindow and NPWindow are structurally
     // identical (on purpose!), so there's no need to make a copy.
 
     PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("nsNPAPIPluginInstance::SetWindow (about to call it) this=%p\n",this));
 
     bool oldVal = mInPluginInitCall;
-    mInPluginInitCall = PR_TRUE;
+    mInPluginInitCall = true;
 
     NPPAutoPusher nppPusher(&mNPP);
 
     NPError error;
     NS_TRY_SAFE_CALL_RETURN(error, (*pluginFunctions->setwindow)(&mNPP, (NPWindow*)window), this);
 
     mInPluginInitCall = oldVal;
 
@@ -661,17 +661,17 @@ NPError nsNPAPIPluginInstance::SetWindow
     // bug 558434 - Prior to 3.6.4, we assumed windowless was transparent.
     // Silverlight apparently relied on this quirk, so we default to
     // transparent unless they specify otherwise after setting the windowless
     // property. (Last tested version: sl 4.0).
     // Changes to this code should be matched with changes in
     // PluginInstanceChild::InitQuirksMode.
     NS_NAMED_LITERAL_CSTRING(silverlight, "application/x-silverlight");
     if (!PL_strncasecmp(mMIMEType, silverlight.get(), silverlight.Length())) {
-      mTransparent = PR_TRUE;
+      mTransparent = true;
     }
   }
 
   return NPERR_NO_ERROR;
 }
 
 NPError nsNPAPIPluginInstance::SetWindowlessLocal(bool aWindowlessLocal)
 {
@@ -721,35 +721,35 @@ void nsNPAPIPluginInstance::SetEventMode
 void nsNPAPIPluginInstance::SetDrawingModel(PRUint32 aModel)
 {
   mDrawingModel = aModel;
 }
 
 class SurfaceGetter : public nsRunnable {
 public:
   SurfaceGetter(NPPluginFuncs* aPluginFunctions, NPP_t aNPP) : 
-    mHaveSurface(PR_FALSE), mPluginFunctions(aPluginFunctions), mNPP(aNPP) {
+    mHaveSurface(false), mPluginFunctions(aPluginFunctions), mNPP(aNPP) {
     mLock = new Mutex("SurfaceGetter::Lock");
     mCondVar = new CondVar(*mLock, "SurfaceGetter::CondVar");
     
   }
   ~SurfaceGetter() {
     delete mLock;
     delete mCondVar;
   }
   nsresult Run() {
     MutexAutoLock lock(*mLock);
     (*mPluginFunctions->getvalue)(&mNPP, kJavaSurface_ANPGetValue, &mSurface);
-    mHaveSurface = PR_TRUE;
+    mHaveSurface = true;
     mCondVar->Notify();
     return NS_OK;
   }
   void* GetSurface() {
     MutexAutoLock lock(*mLock);
-    mHaveSurface = PR_FALSE;
+    mHaveSurface = false;
     AndroidBridge::Bridge()->PostToJavaThread(this);
     while (!mHaveSurface)
       mCondVar->Wait();
     return mSurface;
   }
 private:
   NPP_t mNPP;
   void* mSurface;
@@ -873,17 +873,17 @@ nsNPAPIPluginInstance::DefineJavaPropert
   return NS_OK;
 }
 
 nsresult
 nsNPAPIPluginInstance::IsWindowless(bool* isWindowless)
 {
 #ifdef ANDROID
   // On android, pre-honeycomb, all plugins are treated as windowless.
-  *isWindowless = PR_TRUE;
+  *isWindowless = true;
 #else
   *isWindowless = mWindowless;
 #endif
   return NS_OK;
 }
 
 class NS_STACK_CLASS AutoPluginLibraryCall
 {
@@ -1052,17 +1052,17 @@ nsresult
 nsNPAPIPluginInstance::PushPopupsEnabledState(bool aEnabled)
 {
   nsCOMPtr<nsPIDOMWindow> window = GetDOMWindow();
   if (!window)
     return NS_ERROR_FAILURE;
 
   PopupControlState oldState =
     window->PushPopupControlState(aEnabled ? openAllowed : openAbused,
-                                  PR_TRUE);
+                                  true);
 
   if (!mPopupStates.AppendElement(oldState)) {
     // Appending to our state stack failed, pop what we just pushed.
     window->PopPopupControlState(oldState);
     return NS_ERROR_FAILURE;
   }
 
   return NS_OK;
@@ -1167,19 +1167,19 @@ static void
 PluginTimerCallback(nsITimer *aTimer, void *aClosure)
 {
   nsNPAPITimer* t = (nsNPAPITimer*)aClosure;
   NPP npp = t->npp;
   uint32_t id = t->id;
 
   // Some plugins (Flash on Android) calls unscheduletimer
   // from this callback.
-  t->inCallback = PR_TRUE;
+  t->inCallback = true;
   (*(t->callback))(npp, id);
-  t->inCallback = PR_FALSE;
+  t->inCallback = false;
 
   // Make sure we still have an instance and the timer is still alive
   // after the callback.
   nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance*)npp->ndata;
   if (!inst || !inst->TimerWithID(id, NULL))
     return;
 
   // use UnscheduleTimer to clean up if this is a one-shot timer
@@ -1203,17 +1203,17 @@ nsNPAPIPluginInstance::TimerWithID(uint3
   return nsnull;
 }
 
 uint32_t
 nsNPAPIPluginInstance::ScheduleTimer(uint32_t interval, NPBool repeat, void (*timerFunc)(NPP npp, uint32_t timerID))
 {
   nsNPAPITimer *newTimer = new nsNPAPITimer();
 
-  newTimer->inCallback = PR_FALSE;
+  newTimer->inCallback = false;
   newTimer->npp = &mNPP;
 
   // generate ID that is unique to this instance
   uint32_t uniqueID = mTimers.Length();
   while ((uniqueID == 0) || TimerWithID(uniqueID, NULL))
     uniqueID++;
   newTimer->id = uniqueID;
 
@@ -1275,17 +1275,17 @@ nsNPAPIPluginInstance::PopUpContextMenu(
 
 NPBool
 nsNPAPIPluginInstance::ConvertPoint(double sourceX, double sourceY, NPCoordinateSpace sourceSpace,
                                     double *destX, double *destY, NPCoordinateSpace destSpace)
 {
   if (mOwner)
     return mOwner->ConvertPoint(sourceX, sourceY, sourceSpace, destX, destY, destSpace);
 
-  return PR_FALSE;
+  return false;
 }
 
 nsresult
 nsNPAPIPluginInstance::GetDOMElement(nsIDOMElement* *result)
 {
   if (!mOwner) {
     *result = nsnull;
     return NS_ERROR_FAILURE;
@@ -1447,17 +1447,17 @@ public:
   NS_IMETHOD Run();
 };
 
 NS_IMETHODIMP
 CarbonEventModelFailureEvent::Run()
 {
   nsString type = NS_LITERAL_STRING("npapi-carbon-event-model-failure");
   nsContentUtils::DispatchTrustedEvent(mContent->GetDocument(), mContent,
-                                       type, PR_TRUE, PR_TRUE);
+                                       type, true, true);
   return NS_OK;
 }
 
 void
 nsNPAPIPluginInstance::CarbonNPAPIFailure()
 {
   nsCOMPtr<nsIDOMElement> element;
   GetDOMElement(getter_AddRefs(element));
--- a/dom/plugins/base/nsNPAPIPluginStreamListener.cpp
+++ b/dom/plugins/base/nsNPAPIPluginStreamListener.cpp
@@ -122,17 +122,17 @@ nsPluginStreamToFile::WriteSegments(nsRe
 {
   NS_NOTREACHED("WriteSegments");
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsPluginStreamToFile::IsNonBlocking(bool *aNonBlocking)
 {
-  *aNonBlocking = PR_FALSE;
+  *aNonBlocking = false;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsPluginStreamToFile::Close(void)
 {
   mOutputStream->Close();
   mOwner->GetURL(mFileURL.get(), mTarget, nsnull, nsnull, 0);
@@ -149,24 +149,24 @@ nsNPAPIPluginStreamListener::nsNPAPIPlug
                                                          const char* aURL)
 : mStreamBuffer(nsnull),
 mNotifyURL(aURL ? PL_strdup(aURL) : nsnull),
 mInst(inst),
 mStreamListenerPeer(nsnull),
 mStreamBufferSize(0),
 mStreamBufferByteCount(0),
 mStreamType(NP_NORMAL),
-mStreamStarted(PR_FALSE),
-mStreamCleanedUp(PR_FALSE),
-mCallNotify(notifyData ? PR_TRUE : PR_FALSE),
-mIsSuspended(PR_FALSE),
+mStreamStarted(false),
+mStreamCleanedUp(false),
+mCallNotify(notifyData ? true : false),
+mIsSuspended(false),
 mIsPluginInitJSStream(mInst->mInPluginInitCall &&
                       aURL && strncmp(aURL, "javascript:",
                                       sizeof("javascript:") - 1) == 0),
-mRedirectDenied(PR_FALSE),
+mRedirectDenied(false),
 mResponseHeaderBuf(nsnull)
 {
   memset(&mNPStream, 0, sizeof(mNPStream));
   mNPStream.notifyData = notifyData;
 }
 
 nsNPAPIPluginStreamListener::~nsNPAPIPluginStreamListener()
 {
@@ -196,17 +196,17 @@ nsNPAPIPluginStreamListener::~nsNPAPIPlu
 nsresult
 nsNPAPIPluginStreamListener::CleanUpStream(NPReason reason)
 {
   nsresult rv = NS_ERROR_FAILURE;
   
   if (mStreamCleanedUp)
     return NS_OK;
   
-  mStreamCleanedUp = PR_TRUE;
+  mStreamCleanedUp = true;
   
   StopDataPump();
 
   // Release any outstanding redirect callback.
   if (mHTTPRedirectCallback) {
     mHTTPRedirectCallback->OnRedirectVerifyCallback(NS_ERROR_FAILURE);
     mHTTPRedirectCallback = nsnull;
   }
@@ -241,33 +241,33 @@ nsNPAPIPluginStreamListener::CleanUpStre
     NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
                    ("NPP DestroyStream called: this=%p, npp=%p, reason=%d, return=%d, url=%s\n",
                     this, npp, reason, error, mNPStream.url));
     
     if (error == NPERR_NO_ERROR)
       rv = NS_OK;
   }
   
-  mStreamStarted = PR_FALSE;
+  mStreamStarted = false;
   
   // fire notification back to plugin, just like before
   CallURLNotify(reason);
   
   return rv;
 }
 
 void
 nsNPAPIPluginStreamListener::CallURLNotify(NPReason reason)
 {
   if (!mCallNotify || !mInst || !mInst->CanFireNotifications())
     return;
   
   PluginDestructionGuard guard(mInst);
   
-  mCallNotify = PR_FALSE; // only do this ONCE and prevent recursion
+  mCallNotify = false; // only do this ONCE and prevent recursion
 
   nsNPAPIPlugin* plugin = mInst->GetPlugin();
   if (!plugin || !plugin->GetLibrary())
     return;
 
   NPPluginFuncs* pluginFunctions = plugin->PluginFuncs();
 
   if (pluginFunctions->urlnotify) {
@@ -352,17 +352,17 @@ nsNPAPIPluginStreamListener::OnStartBind
       // calls NPN_DestroyStream the stream will be destroyed before the plugin
       // instance is destroyed.
       NS_ADDREF_THIS();
       break;
     default:
       return NS_ERROR_FAILURE;
   }
   
-  mStreamStarted = PR_TRUE;
+  mStreamStarted = true;
   return NS_OK;
 }
 
 void
 nsNPAPIPluginStreamListener::SuspendRequest()
 {
   NS_ASSERTION(!mIsSuspended,
                "Suspending a request that's already suspended!");
@@ -373,30 +373,30 @@ nsNPAPIPluginStreamListener::SuspendRequ
   if (!pluginInfoNPAPI) {
     return;
   }
   
   nsresult rv = StartDataPump();
   if (NS_FAILED(rv))
     return;
   
-  mIsSuspended = PR_TRUE;
+  mIsSuspended = true;
   
   pluginInfoNPAPI->SuspendRequests();
 }
 
 void
 nsNPAPIPluginStreamListener::ResumeRequest()
 {
   nsCOMPtr<nsINPAPIPluginStreamInfo> pluginInfoNPAPI =
   do_QueryInterface(mStreamInfo);
   
   pluginInfoNPAPI->ResumeRequests();
   
-  mIsSuspended = PR_FALSE;
+  mIsSuspended = false;
 }
 
 nsresult
 nsNPAPIPluginStreamListener::StartDataPump()
 {
   nsresult rv;
   mDataPumpTimer = do_CreateInstance("@mozilla.org/timer;1", &rv);
   NS_ENSURE_SUCCESS(rv, rv);
@@ -417,26 +417,26 @@ nsNPAPIPluginStreamListener::StopDataPum
 }
 
 // Return true if a javascript: load that was started while the plugin
 // was being initialized is still in progress.
 bool
 nsNPAPIPluginStreamListener::PluginInitJSLoadInProgress()
 {
   if (!mInst)
-    return PR_FALSE;
+    return false;
 
   nsTArray<nsNPAPIPluginStreamListener*> *streamListeners = mInst->StreamListeners();
   for (unsigned int i = 0; i < streamListeners->Length(); i++) {
     if (streamListeners->ElementAt(i)->mIsPluginInitJSStream) {
-      return PR_TRUE;
+      return true;
     }
   }
   
-  return PR_FALSE;
+  return false;
 }
 
 // This method is called when there's more data available off the
 // network, but it's also called from our data pump when we're feeding
 // the plugin data that we already got off the network, but the plugin
 // was unable to consume it at the point it arrived. In the case when
 // the plugin pump calls this method, the input argument will be null,
 // and the length will be the number of bytes available in our
@@ -885,12 +885,12 @@ nsNPAPIPluginStreamListener::HandleRedir
   return true;
 }
 
 void
 nsNPAPIPluginStreamListener::URLRedirectResponse(NPBool allow)
 {
   if (mHTTPRedirectCallback) {
     mHTTPRedirectCallback->OnRedirectVerifyCallback(allow ? NS_OK : NS_ERROR_FAILURE);
-    mRedirectDenied = allow ? PR_FALSE : PR_TRUE;
+    mRedirectDenied = allow ? false : true;
     mHTTPRedirectCallback = nsnull;
   }
 }
--- a/dom/plugins/base/nsPluginDirServiceProvider.cpp
+++ b/dom/plugins/base/nsPluginDirServiceProvider.cpp
@@ -224,17 +224,17 @@ nsPluginDirServiceProvider::GetFile(cons
                                     nsIFile **_retval)
 {
   nsCOMPtr<nsILocalFile>  localFile;
   nsresult rv = NS_ERROR_FAILURE;
 
   NS_ENSURE_ARG(charProp);
 
   *_retval = nsnull;
-  *persistant = PR_FALSE;
+  *persistant = false;
 
   nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
   if (!prefs)
     return NS_ERROR_FAILURE;
 
   nsCOMPtr<nsIWindowsRegKey> regKey =
     do_CreateInstance("@mozilla.org/windows-registry-key;1");
   NS_ENSURE_TRUE(regKey, NS_ERROR_FAILURE);
@@ -305,17 +305,17 @@ nsPluginDirServiceProvider::GetFile(cons
     if (newestPath.IsEmpty()) {
       return NS_ERROR_FAILURE;
     }
 
     // We require the newer NPAPI Java plugin.
     newestPath += NS_LITERAL_STRING("\\bin\\new_plugin");
 
     rv = NS_NewLocalFile(newestPath,
-                         PR_TRUE, getter_AddRefs(localFile));
+                         true, getter_AddRefs(localFile));
 
     if (NS_SUCCEEDED(rv)) {
       nsCOMPtr<nsIWindowsRegKey> newKey =
         do_CreateInstance("@mozilla.org/windows-registry-key;1");
       NS_ENSURE_TRUE(newKey, NS_ERROR_FAILURE);
 
       rv = newKey->Create(nsIWindowsRegKey::ROOT_KEY_LOCAL_MACHINE,
                           NS_LITERAL_STRING("Software\\mozilla.org\\Mozilla"),
@@ -361,17 +361,17 @@ nsPluginDirServiceProvider::GetFile(cons
     rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_LOCAL_MACHINE,
                       NS_LITERAL_STRING("software\\Apple Computer, Inc.\\QuickTime"),
                       nsIWindowsRegKey::ACCESS_READ);
     if (NS_SUCCEEDED(rv)) {
       nsAutoString path;
       rv = regKey->ReadStringValue(NS_LITERAL_STRING("InstallDir"), path);
       if (NS_SUCCEEDED(rv)) {
         path += NS_LITERAL_STRING("\\Plugins");
-        rv = NS_NewLocalFile(path, PR_TRUE,
+        rv = NS_NewLocalFile(path, true,
                              getter_AddRefs(localFile));
       }
     }
   } else if (nsCRT::strcmp(charProp, NS_WIN_WMP_SCAN_KEY) == 0) {
     nsXPIDLCString strVer;
     if (NS_FAILED(prefs->GetCharPref(charProp, getter_Copies(strVer))))
       return NS_ERROR_FAILURE;
     verBlock minVer;
@@ -399,17 +399,17 @@ nsPluginDirServiceProvider::GetFile(cons
     rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_LOCAL_MACHINE,
                       NS_LITERAL_STRING("software\\Microsoft\\MediaPlayer"),
                       nsIWindowsRegKey::ACCESS_READ);
     if (NS_SUCCEEDED(rv)) {
       nsAutoString path;
       rv = regKey->ReadStringValue(NS_LITERAL_STRING("Installation Directory"),
                                    path);
       if (NS_SUCCEEDED(rv)) {
-        rv = NS_NewLocalFile(path, PR_TRUE,
+        rv = NS_NewLocalFile(path, true,
                              getter_AddRefs(localFile));
       }
     }
   } else if (nsCRT::strcmp(charProp, NS_WIN_ACROBAT_SCAN_KEY) == 0) {
     nsXPIDLCString strVer;
     if (NS_FAILED(prefs->GetCharPref(charProp, getter_Copies(strVer)))) {
       return NS_ERROR_FAILURE;
     }
@@ -464,17 +464,17 @@ nsPluginDirServiceProvider::GetFile(cons
             }
           }
         }
       }
     }
 
     if (!newestPath.IsEmpty()) {
       newestPath += NS_LITERAL_STRING("\\browser");
-      rv = NS_NewLocalFile(newestPath, PR_TRUE,
+      rv = NS_NewLocalFile(newestPath, true,
                            getter_AddRefs(localFile));
     }
   }
 
   if (localFile && NS_SUCCEEDED(rv))
     return CallQueryInterface(localFile, _retval);
 
   return rv;
@@ -516,17 +516,17 @@ nsPluginDirServiceProvider::GetPLIDDirec
       nsCOMPtr<nsIWindowsRegKey> childKey;
       rv = regKey->OpenChild(childName, nsIWindowsRegKey::ACCESS_QUERY_VALUE,
                              getter_AddRefs(childKey));
       if (NS_SUCCEEDED(rv) && childKey) {
         nsAutoString path;
         rv = childKey->ReadStringValue(NS_LITERAL_STRING("Path"), path);
         if (NS_SUCCEEDED(rv)) {
           nsCOMPtr<nsILocalFile> localFile;
-          if (NS_SUCCEEDED(NS_NewLocalFile(path, PR_TRUE,
+          if (NS_SUCCEEDED(NS_NewLocalFile(path, true,
                                            getter_AddRefs(localFile))) &&
               localFile) {
             // Some vendors use a path directly to the DLL so chop off
             // the filename
             bool isDir = false;
             if (NS_SUCCEEDED(localFile->IsDirectory(&isDir)) && !isDir) {
               nsCOMPtr<nsIFile> temp;
               localFile->GetParent(getter_AddRefs(temp));
--- a/dom/plugins/base/nsPluginHost.cpp
+++ b/dom/plugins/base/nsPluginHost.cpp
@@ -266,20 +266,20 @@ bool ReadSectionHeader(nsPluginManifestL
 
       char* values[1];
       if (1 != reader.ParseLine(values, 1))
         break;
       // ignore the leading '['
       if (PL_strcmp(values[0]+1, token)) {
         break; // it's wrong token
       }
-      return PR_TRUE;
+      return true;
     }
   } while (reader.NextLine());
-  return PR_FALSE;
+  return false;
 }
 
 // Little helper struct to asynchronously reframe any presentations (embedded)
 // or reload any documents (full-page), that contained plugins
 // which were shutdown as a result of a plugins.refresh(1)
 class nsPluginDocReframeEvent: public nsRunnable {
 public:
   nsPluginDocReframeEvent(nsISupportsArray* aDocs) { mDocs = aDocs; }
@@ -332,17 +332,17 @@ static bool UnloadPluginsASAP()
   if (NS_SUCCEEDED(rv)) {
     bool unloadPluginsASAP = false;
     rv = pref->GetBoolPref("plugins.unloadASAP", &unloadPluginsASAP);
     if (NS_SUCCEEDED(rv)) {
       return unloadPluginsASAP;
     }
   }
 
-  return PR_FALSE;
+  return false;
 }
 
 // helper struct for asynchronous handling of plugin unloading
 class nsPluginUnloadEvent : public nsRunnable {
 public:
   nsPluginUnloadEvent(PRLibrary* aLibrary)
     : mLibrary(aLibrary)
   {}
@@ -372,17 +372,17 @@ nsresult nsPluginHost::PostPluginUnloadE
 
   // failure case
   NS_TRY_SAFE_CALL_VOID(PR_UnloadLibrary(aLibrary), nsnull);
 
   return NS_ERROR_FAILURE;
 }
 
 nsPluginHost::nsPluginHost()
-  // No need to initialize members to nsnull, PR_FALSE etc because this class
+  // No need to initialize members to nsnull, false etc because this class
   // has a zeroing operator new.
 {
   // check to see if pref is set at startup to let plugins take over in
   // full page mode for certain image mime types that we handle internally
   mPrefService = do_GetService(NS_PREFSERVICE_CONTRACTID);
   if (mPrefService) {
     bool tmp;
     nsresult rv = mPrefService->GetBoolPref("plugin.override_internal_types",
@@ -395,18 +395,18 @@ nsPluginHost::nsPluginHost()
     if (NS_SUCCEEDED(rv)) {
       mPluginsDisabled = tmp;
     }
   }
 
   nsCOMPtr<nsIObserverService> obsService =
     mozilla::services::GetObserverService();
   if (obsService) {
-    obsService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, PR_FALSE);
-    obsService->AddObserver(this, NS_PRIVATE_BROWSING_SWITCH_TOPIC, PR_FALSE);
+    obsService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
+    obsService->AddObserver(this, NS_PRIVATE_BROWSING_SWITCH_TOPIC, false);
   }
 
 #ifdef PLUGIN_LOGGING
   nsPluginLogging::gNPNLog = PR_NewLogModule(NPN_LOG_NAME);
   nsPluginLogging::gNPPLog = PR_NewLogModule(NPP_LOG_NAME);
   nsPluginLogging::gPluginLog = PR_NewLogModule(PLUGIN_LOG_NAME);
 
   PR_LOG(nsPluginLogging::gNPNLog, PLUGIN_LOG_ALWAYS,("NPN Logging Active!\n"));
@@ -449,29 +449,29 @@ nsPluginHost::GetInst()
 
   NS_ADDREF(sInst);
   return sInst;
 }
 
 bool nsPluginHost::IsRunningPlugin(nsPluginTag * plugin)
 {
   if (!plugin || !plugin->mEntryPoint) {
-    return PR_FALSE;
+    return false;
   }
 
   for (PRUint32 i = 0; i < mInstances.Length(); i++) {
     nsNPAPIPluginInstance *instance = mInstances[i].get();
     if (instance &&
         instance->GetPlugin() == plugin->mEntryPoint &&
         instance->IsRunning()) {
-      return PR_TRUE;
+      return true;
     }
   }
 
-  return PR_FALSE;
+  return false;
 }
 
 nsresult nsPluginHost::ReloadPlugins(bool reloadPages)
 {
   PLUGIN_LOG(PLUGIN_LOG_NORMAL,
   ("nsPluginHost::ReloadPlugins Begin reloadPages=%d, active_instance_count=%d\n",
   reloadPages, mInstances.Length()));
 
@@ -483,20 +483,20 @@ nsresult nsPluginHost::ReloadPlugins(boo
     return LoadPlugins();
 
   // we are re-scanning plugins. New plugins may have been added, also some
   // plugins may have been removed, so we should probably shut everything down
   // but don't touch running (active and not stopped) plugins
 
   // check if plugins changed, no need to do anything else
   // if no changes to plugins have been made
-  // PR_FALSE instructs not to touch the plugin list, just to
+  // false instructs not to touch the plugin list, just to
   // look for possible changes
   bool pluginschanged = true;
-  FindPlugins(PR_FALSE, &pluginschanged);
+  FindPlugins(false, &pluginschanged);
 
   // if no changed detected, return an appropriate error code
   if (!pluginschanged)
     return NS_ERROR_PLUGINS_PLUGINSNOTCHANGED;
 
   nsCOMPtr<nsISupportsArray> instsToReload;
   if (reloadPages) {
     NS_NewISupportsArray(getter_AddRefs(instsToReload));
@@ -529,17 +529,17 @@ nsresult nsPluginHost::ReloadPlugins(boo
       continue;
     }
 
     prev = p;
     p = next;
   }
 
   // set flags
-  mPluginsLoaded = PR_FALSE;
+  mPluginsLoaded = false;
 
   // load them again
   rv = LoadPlugins();
 
   // If we have shut down any plugin instances, we've now got to restart them.
   // Post an event to do the rest as we are going to be destroying the frame tree and we also want
   // any posted unload events to finish
   PRUint32 c;
@@ -835,17 +835,17 @@ nsresult nsPluginHost::FindProxyForURL(c
   } else if (type.EqualsLiteral("socks")) {
     // XXX - this is socks5, but there is no API for us to tell the
     // plugin that fact. SOCKS for now, in case the proxy server
     // speaks SOCKS4 as well. See bug 78176
     // For a long time this was returning an http proxy type, so
     // very little is probably broken by this
     *result = PR_smprintf("SOCKS %s:%d", host.get(), port);
   } else {
-    NS_ASSERTION(PR_FALSE, "Unknown proxy type!");
+    NS_ASSERTION(false, "Unknown proxy type!");
     *result = PL_strdup("DIRECT");
   }
 
   if (nsnull == *result)
     res = NS_ERROR_OUT_OF_MEMORY;
 
   return res;
 }
@@ -857,34 +857,34 @@ nsresult nsPluginHost::Init()
 
 nsresult nsPluginHost::Destroy()
 {
   PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("nsPluginHost::Destroy Called\n"));
 
   if (mIsDestroyed)
     return NS_OK;
 
-  mIsDestroyed = PR_TRUE;
+  mIsDestroyed = true;
 
   // we should call nsIPluginInstance::Stop and nsIPluginInstance::SetWindow
   // for those plugins who want it
   DestroyRunningInstances(nsnull, nsnull);
 
   nsPluginTag *pluginTag;
   for (pluginTag = mPlugins; pluginTag; pluginTag = pluginTag->mNext) {
     pluginTag->TryUnloadPlugin();
   }
 
   NS_ITERATIVE_UNREF_LIST(nsRefPtr<nsPluginTag>, mPlugins, mNext);
   NS_ITERATIVE_UNREF_LIST(nsRefPtr<nsPluginTag>, mCachedPlugins, mNext);
   NS_ITERATIVE_UNREF_LIST(nsRefPtr<nsInvalidPluginTag>, mInvalidPlugins, mNext);
 
   // Lets remove any of the temporary files that we created.
   if (sPluginTempDir) {
-    sPluginTempDir->Remove(PR_TRUE);
+    sPluginTempDir->Remove(true);
     NS_RELEASE(sPluginTempDir);
   }
 
 #ifdef XP_WIN
   if (mPrivateDirServiceProvider) {
     nsCOMPtr<nsIDirectoryService> dirService =
       do_GetService(kDirectoryServiceContractID);
     if (dirService)
@@ -898,17 +898,17 @@ nsresult nsPluginHost::Destroy()
   return NS_OK;
 }
 
 void nsPluginHost::OnPluginInstanceDestroyed(nsPluginTag* aPluginTag)
 {
   bool hasInstance = false;
   for (PRUint32 i = 0; i < mInstances.Length(); i++) {
     if (TagForPlugin(mInstances[i]->GetPlugin()) == aPluginTag) {
-      hasInstance = PR_TRUE;
+      hasInstance = true;
       break;
     }
   }
 
   if (!hasInstance && UnloadPluginsASAP()) {
     aPluginTag->TryUnloadPlugin();
   }
 }
@@ -1028,17 +1028,17 @@ nsPluginHost::InstantiateEmbeddedPlugin(
                                 nsDependentCString(aMimeType ? aMimeType : ""),
                                 nsnull, //extra
                                 &shouldLoad);
     if (NS_FAILED(rv) || NS_CP_REJECTED(shouldLoad))
       return NS_ERROR_CONTENT_BLOCKED_SHOW_ALT;
   }
 
   bool isJava = false;
-  nsPluginTag* pluginTag = FindPluginForType(aMimeType, PR_TRUE);
+  nsPluginTag* pluginTag = FindPluginForType(aMimeType, true);
   if (pluginTag) {
     isJava = pluginTag->mIsJavaPlugin;
   }
 
   // Determine if the scheme of this URL is one we can handle internally because we should
   // only open the initial stream if it's one that we can handle internally. Otherwise
   // |NS_OpenURI| in |InstantiateEmbeddedPlugin| may open up a OS protocal registered helper app
   // Also set bCanHandleInternally to true if aAllowOpeningStreams is
@@ -1046,17 +1046,17 @@ nsPluginHost::InstantiateEmbeddedPlugin(
   bool bCanHandleInternally = false;
   nsCAutoString scheme;
   if (aURL && NS_SUCCEEDED(aURL->GetScheme(scheme))) {
       nsCAutoString contractID(NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX);
       contractID += scheme;
       ToLowerCase(contractID);
       nsCOMPtr<nsIProtocolHandler> handler = do_GetService(contractID.get());
       if (handler)
-        bCanHandleInternally = PR_TRUE;
+        bCanHandleInternally = true;
   }
 
   // if we don't have a MIME type at this point, we still have one more chance by
   // opening the stream and seeing if the server hands one back
   if (!aMimeType)
     return bCanHandleInternally ? NewEmbeddedPluginStream(aURL, aOwner, nsnull) : NS_ERROR_FAILURE;
 
   rv = SetUpPluginInstance(aMimeType, aURL, aOwner);
@@ -1198,17 +1198,17 @@ nsresult nsPluginHost::SetUpPluginInstan
     nsCOMPtr<nsIDocument> currentdocument = do_QueryReferent(mCurrentDocument);
     if (document == currentdocument)
       return rv;
 
     mCurrentDocument = do_GetWeakReference(document);
 
     // ReloadPlugins will do the job smartly: nothing will be done
     // if no changes detected, in such a case just return
-    if (NS_ERROR_PLUGINS_PLUGINSNOTCHANGED == ReloadPlugins(PR_FALSE))
+    if (NS_ERROR_PLUGINS_PLUGINSNOTCHANGED == ReloadPlugins(false))
       return rv;
 
     // other failure return codes may be not fatal, so we can still try
     aOwner->SetInstance(nsnull); // avoid assert about setting it twice
     rv = TrySetUpPluginInstance(aMimeType, aURL, aOwner);
   }
 
   return rv;
@@ -1231,17 +1231,17 @@ nsPluginHost::TrySetUpPluginInstance(con
 #endif
 
   nsresult rv = NS_ERROR_FAILURE;
   
   const char* mimetype = nsnull;
 
   // if don't have a mimetype or no plugin can handle this mimetype
   // check by file extension
-  nsPluginTag* pluginTag = FindPluginForType(aMimeType, PR_TRUE);
+  nsPluginTag* pluginTag = FindPluginForType(aMimeType, true);
   if (!pluginTag) {
     nsCOMPtr<nsIURL> url = do_QueryInterface(aURL);
     if (!url) return NS_ERROR_FAILURE;
 
     nsCAutoString fileExtension;
     url->GetFileExtension(fileExtension);
 
     // if we don't have an extension or no plugin for this extension,
@@ -1324,23 +1324,23 @@ nsPluginHost::TrySetUpPluginInstance(con
 #endif
 
   return rv;
 }
 
 nsresult
 nsPluginHost::IsPluginEnabledForType(const char* aMimeType)
 {
-  nsPluginTag *plugin = FindPluginForType(aMimeType, PR_TRUE);
+  nsPluginTag *plugin = FindPluginForType(aMimeType, true);
   if (plugin)
     return NS_OK;
 
-  // Pass PR_FALSE as the second arg so we can return NS_ERROR_PLUGIN_DISABLED
+  // Pass false as the second arg so we can return NS_ERROR_PLUGIN_DISABLED
   // for disabled plug-ins.
-  plugin = FindPluginForType(aMimeType, PR_FALSE);
+  plugin = FindPluginForType(aMimeType, false);
   if (!plugin)
     return NS_ERROR_FAILURE;
 
   if (!plugin->IsEnabled()) {
     if (plugin->HasFlag(NS_PLUGIN_FLAG_BLOCKLISTED))
       return NS_ERROR_PLUGIN_BLOCKLISTED;
     else
       return NS_ERROR_PLUGIN_DISABLED;
@@ -1667,17 +1667,17 @@ nsresult nsPluginHost::GetPlugin(const c
   *aPlugin = NULL;
 
   if (!aMimeType)
     return NS_ERROR_ILLEGAL_VALUE;
 
   // If plugins haven't been scanned yet, do so now
   LoadPlugins();
 
-  nsPluginTag* pluginTag = FindPluginForType(aMimeType, PR_TRUE);
+  nsPluginTag* pluginTag = FindPluginForType(aMimeType, true);
   if (pluginTag) {
     rv = NS_OK;
     PLUGIN_LOG(PLUGIN_LOG_BASIC,
     ("nsPluginHost::GetPlugin Begin mime=%s, plugin=%s\n",
     aMimeType, pluginTag->mFileName.get()));
 
 #ifdef NS_DEBUG
     if (aMimeType && !pluginTag->mFileName.IsEmpty())
@@ -1916,20 +1916,20 @@ bool nsPluginHost::IsJavaMIMEType(const 
 
 // Check whether or not a tag is a live, valid tag, and that it's loaded.
 bool
 nsPluginHost::IsLiveTag(nsIPluginTag* aPluginTag)
 {
   nsPluginTag* tag;
   for (tag = mPlugins; tag; tag = tag->mNext) {
     if (tag == aPluginTag) {
-      return PR_TRUE;
+      return true;
     }
   }
-  return PR_FALSE;
+  return false;
 }
 
 nsPluginTag * nsPluginHost::HaveSamePlugin(nsPluginTag * aPluginTag)
 {
   for (nsPluginTag* tag = mPlugins; tag; tag = tag->mNext) {
     if (tag->Equals(aPluginTag))
       return tag;
   }
@@ -1941,38 +1941,38 @@ bool nsPluginHost::IsDuplicatePlugin(nsP
   nsPluginTag * tag = HaveSamePlugin(aPluginTag);
   if (tag) {
     // if we got the same plugin, check the full path to see if this is a dup;
 
     // mFileName contains full path on Windows and Unix and leaf name on Mac
     // if those are not equal, we have the same plugin with  different path,
     // i.e. duplicate, return true
     if (!tag->mFileName.Equals(aPluginTag->mFileName))
-      return PR_TRUE;
+      return true;
 
     // if they are equal, compare mFullPath fields just in case
     // mFileName contained leaf name only, and if not equal, return true
     if (!tag->mFullPath.Equals(aPluginTag->mFullPath))
-      return PR_TRUE;
+      return true;
   }
 
   // we do not have it at all, return false
-  return PR_FALSE;
+  return false;
 }
 
 typedef NS_NPAPIPLUGIN_CALLBACK(char *, NP_GETMIMEDESCRIPTION)(void);
 
 nsresult nsPluginHost::ScanPluginsDirectory(nsIFile *pluginsDir,
                                             bool aCreatePluginList,
                                             bool *aPluginsChanged)
 {
   NS_ENSURE_ARG_POINTER(aPluginsChanged);
   nsresult rv;
 
-  *aPluginsChanged = PR_FALSE;
+  *aPluginsChanged = false;
 
 #ifdef PLUGIN_LOGGING
   nsCAutoString dirPath;
   pluginsDir->GetNativePath(dirPath);
   PLUGIN_LOG(PLUGIN_LOG_BASIC,
   ("nsPluginHost::ScanPluginsDirectory dir=%s\n", dirPath.get()));
 #endif
 
@@ -2019,41 +2019,41 @@ nsresult nsPluginHost::ScanPluginsDirect
     NS_ConvertUTF16toUTF8 filePath(utf16FilePath);
     nsRefPtr<nsPluginTag> pluginTag;
     RemoveCachedPluginsInfo(filePath.get(),
                             getter_AddRefs(pluginTag));
 
     bool enabled = true;
     bool seenBefore = false;
     if (pluginTag) {
-      seenBefore = PR_TRUE;
+      seenBefore = true;
       // If plugin changed, delete cachedPluginTag and don't use cache
       if (LL_NE(fileModTime, pluginTag->mLastModifiedTime)) {
         // Plugins has changed. Don't use cached plugin info.
         enabled = (pluginTag->Flags() & NS_PLUGIN_FLAG_ENABLED) != 0;
         pluginTag = nsnull;
 
         // plugin file changed, flag this fact
-        *aPluginsChanged = PR_TRUE;
+        *aPluginsChanged = true;
       }
       else {
         // if it is unwanted plugin we are checking for, get it back to the cache info list
         // if this is a duplicate plugin, too place it back in the cache info list marking unwantedness
         if (IsDuplicatePlugin(pluginTag)) {
           if (!pluginTag->HasFlag(NS_PLUGIN_FLAG_UNWANTED)) {
             // Plugin switched from wanted to unwanted
-            *aPluginsChanged = PR_TRUE;
+            *aPluginsChanged = true;
           }
           pluginTag->Mark(NS_PLUGIN_FLAG_UNWANTED);
           pluginTag->mNext = mCachedPlugins;
           mCachedPlugins = pluginTag;
         } else if (pluginTag->HasFlag(NS_PLUGIN_FLAG_UNWANTED)) {
           pluginTag->UnMark(NS_PLUGIN_FLAG_UNWANTED);
           // Plugin switched from unwanted to wanted
-          *aPluginsChanged = PR_TRUE;
+          *aPluginsChanged = true;
         }
       }
 
       // If we're not creating a list and we already know something changed then
       // we're done.
       if (!aCreatePluginList) {
         if (*aPluginsChanged) {
           return NS_OK;
@@ -2099,17 +2099,17 @@ nsresult nsPluginHost::ScanPluginsDirect
         }
         invalidTag->mNext = mInvalidPlugins;
         if (mInvalidPlugins) {
           mInvalidPlugins->mPrev = invalidTag;
         }
         mInvalidPlugins = invalidTag;
         
         // Mark aPluginsChanged so pluginreg is rewritten
-        *aPluginsChanged = PR_TRUE;
+        *aPluginsChanged = true;
         continue;
       }
 
       pluginTag = new nsPluginTag(&info);
       pluginFile.FreePluginInfo(info);
       if (!pluginTag)
         return NS_ERROR_OUT_OF_MEMORY;
 
@@ -2123,19 +2123,19 @@ nsresult nsPluginHost::ScanPluginsDirect
                                                 EmptyString(), &state);
 
         if (NS_SUCCEEDED(rv)) {
           // If the blocklist says so then block the plugin. If the blocklist says
           // it is risky and we have never seen this plugin before then disable it
           if (state == nsIBlocklistService::STATE_BLOCKED)
             pluginTag->Mark(NS_PLUGIN_FLAG_BLOCKLISTED);
           else if (state == nsIBlocklistService::STATE_SOFTBLOCKED && !seenBefore)
-            enabled = PR_FALSE;
+            enabled = false;
           else if (state == nsIBlocklistService::STATE_OUTDATED && !seenBefore)
-            warnOutdated = PR_TRUE;
+            warnOutdated = true;
         }
       }
 
       if (!enabled)
         pluginTag->UnMark(NS_PLUGIN_FLAG_ENABLED);
 
       // if this is unwanted plugin we are checkin for, or this is a duplicate plugin,
       // add it to our cache info list so we can cache the unwantedness of this plugin
@@ -2159,24 +2159,24 @@ nsresult nsPluginHost::ScanPluginsDirect
     // set the flag that we want to add this plugin to the list for now
     // and see if it remains after we check several reasons not to do so
     bool bAddIt = true;
     
     if (HaveSamePlugin(pluginTag)) {
       // we cannot get here if the plugin has just been added
       // and thus |pluginTag| is not from cache, because otherwise
       // it would not be present in the list;
-      bAddIt = PR_FALSE;
+      bAddIt = false;
     }
 
     // do it if we still want it
     if (bAddIt) {
       if (!seenBefore) {
         // We have a valid new plugin so report that plugins have changed.
-        *aPluginsChanged = PR_TRUE;
+        *aPluginsChanged = true;
       }
 
       // If we're not creating a plugin list, simply looking for changes,
       // then we're done.
       if (!aCreatePluginList) {
         return NS_OK;
       }
 
@@ -2210,17 +2210,17 @@ nsresult nsPluginHost::ScanPluginsDirect
 
       if (pluginTag->IsEnabled()) {
         pluginTag->RegisterWithCategoryManager(mOverrideInternalTypes);
       }
     }
   }
 
   if (warnOutdated) {
-    mPrefService->SetBoolPref("plugins.update.notifyUser", PR_TRUE);
+    mPrefService->SetBoolPref("plugins.update.notifyUser", true);
   }
 
   return NS_OK;
 }
 
 nsresult nsPluginHost::ScanPluginsDirectoryList(nsISimpleEnumerator *dirEnum,
                                                 bool aCreatePluginList,
                                                 bool *aPluginsChanged)
@@ -2235,17 +2235,17 @@ nsresult nsPluginHost::ScanPluginsDirect
       if (NS_FAILED(rv))
         continue;
       
       // don't pass aPluginsChanged directly to prevent it from been reset
       bool pluginschanged = false;
       ScanPluginsDirectory(nextDir, aCreatePluginList, &pluginschanged);
 
       if (pluginschanged)
-        *aPluginsChanged = PR_TRUE;
+        *aPluginsChanged = true;
 
       // if changes are detected and we are not creating the list, do not proceed
       if (!aCreatePluginList && *aPluginsChanged)
         break;
     }
     return NS_OK;
 }
 
@@ -2255,17 +2255,17 @@ nsresult nsPluginHost::LoadPlugins()
   // use ReloadPlugins() to enforce loading
   if (mPluginsLoaded)
     return NS_OK;
 
   if (mPluginsDisabled)
     return NS_OK;
 
   bool pluginschanged;
-  nsresult rv = FindPlugins(PR_TRUE, &pluginschanged);
+  nsresult rv = FindPlugins(true, &pluginschanged);
   if (NS_FAILED(rv))
     return rv;
 
   // only if plugins have changed will we notify plugin-change observers
   if (pluginschanged) {
     nsCOMPtr<nsIObserverService> obsService =
       mozilla::services::GetObserverService();
     if (obsService)
@@ -2284,17 +2284,17 @@ nsresult nsPluginHost::FindPlugins(bool 
 
 #ifdef CALL_SAFETY_ON
   // check preferences on whether or not we want to try safe calls to plugins
   NS_INIT_PLUGIN_SAFE_CALLS;
 #endif
 
   NS_ENSURE_ARG_POINTER(aPluginsChanged);
 
-  *aPluginsChanged = PR_FALSE;
+  *aPluginsChanged = false;
   nsresult rv;
 
   // Read cached plugins info. If the profile isn't yet available then don't
   // scan for plugins
   if (ReadPluginInfo() == NS_ERROR_NOT_AVAILABLE)
     return NS_OK;
 
 #ifdef XP_WIN
@@ -2315,48 +2315,48 @@ nsresult nsPluginHost::FindPlugins(bool 
   bool pluginschanged = false;
 
   // Scan the app-defined list of plugin dirs.
   rv = dirService->Get(NS_APP_PLUGINS_DIR_LIST, NS_GET_IID(nsISimpleEnumerator), getter_AddRefs(dirList));
   if (NS_SUCCEEDED(rv)) {
     ScanPluginsDirectoryList(dirList, aCreatePluginList, &pluginschanged);
 
     if (pluginschanged)
-      *aPluginsChanged = PR_TRUE;
+      *aPluginsChanged = true;
 
     // if we are just looking for possible changes,
     // no need to proceed if changes are detected
     if (!aCreatePluginList && *aPluginsChanged) {
       NS_ITERATIVE_UNREF_LIST(nsRefPtr<nsPluginTag>, mCachedPlugins, mNext);
       NS_ITERATIVE_UNREF_LIST(nsRefPtr<nsInvalidPluginTag>, mInvalidPlugins, mNext);
       return NS_OK;
     }
   } else {
 #ifdef ANDROID
     LOG("getting plugins dir failed");
 #endif
   }
 
-  mPluginsLoaded = PR_TRUE; // at this point 'some' plugins have been loaded,
+  mPluginsLoaded = true; // at this point 'some' plugins have been loaded,
                             // the rest is optional
 
 #ifdef XP_WIN
   bool bScanPLIDs = false;
 
   if (mPrefService)
     mPrefService->GetBoolPref("plugin.scan.plid.all", &bScanPLIDs);
 
     // Now lets scan any PLID directories
   if (bScanPLIDs && mPrivateDirServiceProvider) {
     rv = mPrivateDirServiceProvider->GetPLIDDirectories(getter_AddRefs(dirList));
     if (NS_SUCCEEDED(rv)) {
       ScanPluginsDirectoryList(dirList, aCreatePluginList, &pluginschanged);
 
       if (pluginschanged)
-        *aPluginsChanged = PR_TRUE;
+        *aPluginsChanged = true;
 
       // if we are just looking for possible changes,
       // no need to proceed if changes are detected
       if (!aCreatePluginList && *aPluginsChanged) {
         NS_ITERATIVE_UNREF_LIST(nsRefPtr<nsPluginTag>, mCachedPlugins, mNext);
         NS_ITERATIVE_UNREF_LIST(nsRefPtr<nsInvalidPluginTag>, mInvalidPlugins, mNext);
         return NS_OK;
       }
@@ -2380,17 +2380,17 @@ nsresult nsPluginHost::FindPlugins(bool 
     if (NS_SUCCEEDED(dirService->Get(prefs[i], NS_GET_IID(nsIFile), getter_AddRefs(dirToScan))) &&
         dirToScan &&
         NS_SUCCEEDED(dirToScan->Exists(&bExists)) &&
         bExists) {
       
       ScanPluginsDirectory(dirToScan, aCreatePluginList, &pluginschanged);
 
       if (pluginschanged)
-        *aPluginsChanged = PR_TRUE;
+        *aPluginsChanged = true;
 
       // if we are just looking for possible changes,
       // no need to proceed if changes are detected
       if (!aCreatePluginList && *aPluginsChanged) {
         NS_ITERATIVE_UNREF_LIST(nsRefPtr<nsPluginTag>, mCachedPlugins, mNext);
         NS_ITERATIVE_UNREF_LIST(nsRefPtr<nsInvalidPluginTag>, mInvalidPlugins, mNext);
         return NS_OK;
       }
@@ -2408,17 +2408,17 @@ nsresult nsPluginHost::FindPlugins(bool 
     for (nsPluginTag * cachetag = mCachedPlugins; cachetag; cachetag = cachetag->mNext) {
       if (!cachetag->HasFlag(NS_PLUGIN_FLAG_UNWANTED))
         cachecount++;
     }
     // if there is something left in cache, some plugins got removed from the directory
     // and therefor their info did not get removed from the cache info list during directory scan;
     // flag this fact
     if (cachecount > 0)
-      *aPluginsChanged = PR_TRUE;
+      *aPluginsChanged = true;
   }
   
   // Remove unseen invalid plugins
   nsRefPtr<nsInvalidPluginTag> invalidPlugins = mInvalidPlugins;
   while (invalidPlugins) {
     if (!invalidPlugins->mSeen) {
       nsRefPtr<nsInvalidPluginTag> invalidPlugin = invalidPlugins;
       
@@ -2893,17 +2893,17 @@ nsPluginHost::ReadPluginInfo()
     nsRefPtr<nsPluginTag> tag = new nsPluginTag(name,
       description,
       filename,
       fullpath,
       version,
       (const char* const*)mimetypes,
       (const char* const*)mimedescriptions,
       (const char* const*)extensions,
-      mimetypecount, lastmod, canunload, PR_TRUE);
+      mimetypecount, lastmod, canunload, true);
     if (heapalloced)
       delete [] heapalloced;
 
     if (!tag)
       continue;
 
     // Mark plugin as loaded from cache
     tag->Mark(tagflag | NS_PLUGIN_FLAG_FROMCACHE);
@@ -3058,17 +3058,17 @@ nsresult nsPluginHost::NewPluginURLStrea
     channel->SetOwner(doc->NodePrincipal());
 
     // And if it's a script allow it to execute against the
     // document's script context.
     nsCOMPtr<nsIScriptChannel> scriptChannel(do_QueryInterface(channel));
     if (scriptChannel) {
       scriptChannel->SetExecutionPolicy(nsIScriptChannel::EXECUTE_NORMAL);
       // Plug-ins seem to depend on javascript: URIs running synchronously
-      scriptChannel->SetExecuteAsync(PR_FALSE);
+      scriptChannel->SetExecuteAsync(false);
     }
   }
 
   // deal with headers and post data
   nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
   if (httpChannel) {
     if (aPostStream) {
       // XXX it's a bit of a hack to rewind the postdata stream
@@ -3150,18 +3150,18 @@ nsPluginHost::AddHeadersToChannel(const 
   PRInt32 crlf = 0;
   PRInt32 colon = 0;
 
   // Turn the char * buffer into an nsString.
   headersString = aHeadersData;
 
   // Iterate over the nsString: for each "\r\n" delimited chunk,
   // add the value as a header to the nsIHTTPChannel
-  while (PR_TRUE) {
-    crlf = headersString.Find("\r\n", PR_TRUE);
+  while (true) {
+    crlf = headersString.Find("\r\n", true);
     if (-1 == crlf) {
       rv = NS_OK;
       return rv;
     }
     headersString.Mid(oneHeader, 0, crlf);
     headersString.Cut(0, crlf + 2);
     oneHeader.StripWhitespace();
     colon = oneHeader.Find(":");
@@ -3170,17 +3170,17 @@ nsPluginHost::AddHeadersToChannel(const 
       return rv;
     }
     oneHeader.Left(headerName, colon);
     colon++;
     oneHeader.Mid(headerValue, colon, oneHeader.Length() - colon);
 
     // FINALLY: we can set the header!
 
-    rv = aChannel->SetRequestHeader(headerName, headerValue, PR_TRUE);
+    rv = aChannel->SetRequestHeader(headerName, headerValue, true);
     if (NS_FAILED(rv)) {
       rv = NS_ERROR_NULL_POINTER;
       return rv;
     }
   }
   return rv;
 }
 
@@ -3396,17 +3396,17 @@ nsPluginHost::HandleBadPlugin(PRLibrary*
   bool checkboxState = false;
   rv = prompt->ConfirmEx(title, msg.get(),
                        nsIPrompt::BUTTON_TITLE_OK * nsIPrompt::BUTTON_POS_0,
                        nsnull, nsnull, nsnull,
                        checkboxMessage, &checkboxState, &buttonPressed);
 
 
   if (NS_SUCCEEDED(rv) && checkboxState)
-    mDontShowBadPluginMessage = PR_TRUE;
+    mDontShowBadPluginMessage = true;
 
   return rv;
 }
 
 nsresult
 nsPluginHost::ParsePostBufferToFixHeaders(const char *inPostData, PRUint32 inPostDataLen,
                                           char **outPostData, PRUint32 *outPostDataLen)
 {
@@ -3566,17 +3566,17 @@ nsPluginHost::CreateTempFileToPost(const
   nsCAutoString filename;
 
   // stat file == get size & convert file:///c:/ to c: if needed
   nsCOMPtr<nsIFile> inFile;
   rv = NS_GetFileFromURLSpec(nsDependentCString(aPostDataURL),
                              getter_AddRefs(inFile));
   if (NS_FAILED(rv)) {
     nsCOMPtr<nsILocalFile> localFile;
-    rv = NS_NewNativeLocalFile(nsDependentCString(aPostDataURL), PR_FALSE,
+    rv = NS_NewNativeLocalFile(nsDependentCString(aPostDataURL), false,
                                getter_AddRefs(localFile));
     if (NS_FAILED(rv)) return rv;
     inFile = localFile;
   }
   rv = inFile->GetFileSize(&fileSize);
   if (NS_FAILED(rv)) return rv;
   rv = inFile->GetNativePath(filename);
   if (NS_FAILED(rv)) return rv;
@@ -3637,17 +3637,17 @@ nsPluginHost::CreateTempFileToPost(const
         // assuming first 1K (or what we got) has all headers in,
         // lets parse it through nsPluginHost::ParsePostBufferToFixHeaders()
         ParsePostBufferToFixHeaders((const char *)buf, br, &parsedBuf, &bw);
         rv = outStream->Write(parsedBuf, bw, &br);
         nsMemory::Free(parsedBuf);
         if (NS_FAILED(rv) || (bw != br))
           break;
 
-        firstRead = PR_FALSE;
+        firstRead = false;
         continue;
       }
       bw = br;
       rv = outStream->Write(buf, bw, &br);
       if (NS_FAILED(rv) || (bw != br))
         break;
     }
 
@@ -3669,19 +3669,19 @@ nsresult
 nsPluginHost::DeletePluginNativeWindow(nsPluginNativeWindow * aPluginNativeWindow)
 {
   return PLUG_DeletePluginNativeWindow(aPluginNativeWindow);
 }
 
 nsresult
 nsPluginHost::InstantiateDummyJavaPlugin(nsIPluginInstanceOwner *aOwner)
 {
-  // Pass PR_FALSE as the second arg, we want the answer to be the
+  // Pass false as the second arg, we want the answer to be the
   // same here whether the Java plugin is enabled or not.
-  nsPluginTag *plugin = FindPluginForType("application/x-java-vm", PR_FALSE);
+  nsPluginTag *plugin = FindPluginForType("application/x-java-vm", false);
 
   if (!plugin || !plugin->mIsNPRuntimeEnabledJavaPlugin) {
     // No NPRuntime enabled Java plugin found, no point in
     // instantiating a dummy plugin then.
 
     return NS_OK;
   }
 
@@ -3826,31 +3826,31 @@ CheckForDisabledWindows()
     nsCOMPtr<nsISupports> supportsWindow;
     windowList->GetNext(getter_AddRefs(supportsWindow));
     nsCOMPtr<nsIBaseWindow> baseWin(do_QueryInterface(supportsWindow));
     if (baseWin) {
       bool aFlag;
       nsCOMPtr<nsIWidget> widget;
       baseWin->GetMainWidget(getter_AddRefs(widget));
       if (widget && !widget->GetParent() &&
-          NS_SUCCEEDED(widget->IsVisible(aFlag)) && aFlag == PR_TRUE &&
-          NS_SUCCEEDED(widget->IsEnabled(&aFlag)) && aFlag == PR_FALSE) {
+          NS_SUCCEEDED(widget->IsVisible(aFlag)) && aFlag == true &&
+          NS_SUCCEEDED(widget->IsEnabled(&aFlag)) && aFlag == false) {
         nsIWidget * child = widget->GetFirstChild();
         bool enable = true;
         while (child)  {
           nsWindowType aType;
           if (NS_SUCCEEDED(child->GetWindowType(aType)) &&
               aType == eWindowType_dialog) {
-            enable = PR_FALSE;
+            enable = false;
             break;
           }
           child = child->GetNextSibling();
         }
         if (enable) {
-          widget->Enable(PR_TRUE);
+          widget->Enable(true);
         }
       }
     }
   } while (haveWindows);
 }
 #endif
 
 void
@@ -4066,17 +4066,17 @@ PluginDestructionGuard::DelayDestroy(nsN
   // Find the first guard on the stack and make it do a delayed
   // destroy upon destruction.
 
   PluginDestructionGuard *g =
     static_cast<PluginDestructionGuard*>(PR_LIST_HEAD(&sListHead));
 
   while (g != &sListHead) {
     if (g->mInstance == aInstance) {
-      g->mDelayedDestroy = PR_TRUE;
-
-      return PR_TRUE;
+      g->mDelayedDestroy = true;
+
+      return true;
     }
     g = static_cast<PluginDestructionGuard*>(PR_NEXT_LINK(g));    
   }
 
-  return PR_FALSE;
+  return false;
 }
--- a/dom/plugins/base/nsPluginHost.h
+++ b/dom/plugins/base/nsPluginHost.h
@@ -363,17 +363,17 @@ public:
 
   static bool DelayDestroy(nsNPAPIPluginInstance *aInstance);
 
 protected:
   void Init()
   {
     NS_ASSERTION(NS_IsMainThread(), "Should be on the main thread");
 
-    mDelayedDestroy = PR_FALSE;
+    mDelayedDestroy = false;
 
     PR_INIT_CLIST(this);
     PR_INSERT_BEFORE(this, &sListHead);
   }
 
   nsRefPtr<nsNPAPIPluginInstance> mInstance;
   bool mDelayedDestroy;
 
--- a/dom/plugins/base/nsPluginInstanceOwner.cpp
+++ b/dom/plugins/base/nsPluginInstanceOwner.cpp
@@ -158,31 +158,31 @@ public:
     mContent(aContent), mFinished(aFinished)
   {
   }
 
   NS_IMETHOD Run()
   {
     nsContentUtils::DispatchTrustedEvent(mContent->GetOwnerDoc(), mContent,
         mFinished ? NS_LITERAL_STRING("MozPaintWaitFinished") : NS_LITERAL_STRING("MozPaintWait"),
-        PR_TRUE, PR_TRUE);
+        true, true);
     return NS_OK;
   }
 
 private:
   nsCOMPtr<nsIContent> mContent;
   bool                 mFinished;
 };
 
 void
 nsPluginInstanceOwner::NotifyPaintWaiter(nsDisplayListBuilder* aBuilder)
 {
   // This is notification for reftests about async plugin paint start
   if (!mWaitingForPaint && !IsUpToDate() && aBuilder->ShouldSyncDecodeImages()) {
-    nsCOMPtr<nsIRunnable> event = new AsyncPaintWaitEvent(mContent, PR_FALSE);
+    nsCOMPtr<nsIRunnable> event = new AsyncPaintWaitEvent(mContent, false);
     // Run this event as soon as it's safe to do so, since listeners need to
     // receive it immediately
     mWaitingForPaint = nsContentUtils::AddScriptRunner(event);
   }
 }
 
 #ifdef XP_MACOSX
 static void DrawPlugin(ImageContainer* aContainer, void* aPluginInstanceOwner)
@@ -213,21 +213,21 @@ nsPluginInstanceOwner::SetCurrentImage(I
       if (image->GetFormat() == Image::MAC_IO_SURFACE && mObjectFrame) {
         MacIOSurfaceImage *oglImage = static_cast<MacIOSurfaceImage*>(image.get());
         NS_ADDREF_THIS();
         oglImage->SetUpdateCallback(&DrawPlugin, this);
         oglImage->SetDestroyCallback(&OnDestroyImage);
       }
 #endif
       aContainer->SetCurrentImage(image);
-      return PR_TRUE;
+      return true;
     }
   }
   aContainer->SetCurrentImage(nsnull);
-  return PR_FALSE;
+  return false;
 }
 
 void
 nsPluginInstanceOwner::SetBackgroundUnknown()
 {
   if (mInstance) {
     mInstance->SetBackgroundUnknown();
   }
@@ -303,49 +303,49 @@ nsPluginInstanceOwner::nsPluginInstanceO
   mObjectFrame = nsnull;
   mTagText = nsnull;
 #ifdef XP_MACOSX
   memset(&mCGPluginPortCopy, 0, sizeof(NP_CGContext));
 #ifndef NP_NO_QUICKDRAW
   memset(&mQDPluginPortCopy, 0, sizeof(NP_Port));
 #endif
   mInCGPaintLevel = 0;
-  mSentInitialTopLevelWindowEvent = PR_FALSE;
+  mSentInitialTopLevelWindowEvent = false;
   mColorProfile = nsnull;
-  mPluginPortChanged = PR_FALSE;
+  mPluginPortChanged = false;
 #endif
-  mContentFocused = PR_FALSE;
-  mWidgetVisible = PR_TRUE;
-  mPluginWindowVisible = PR_FALSE;
-  mPluginDocumentActiveState = PR_TRUE;
+  mContentFocused = false;
+  mWidgetVisible = true;
+  mPluginWindowVisible = false;
+  mPluginDocumentActiveState = true;
   mNumCachedAttrs = 0;
   mNumCachedParams = 0;
   mCachedAttrParamNames = nsnull;
   mCachedAttrParamValues = nsnull;
-  mDestroyWidget = PR_FALSE;
+  mDestroyWidget = false;
 
 #ifdef XP_MACOSX
 #ifndef NP_NO_QUICKDRAW
   mEventModel = NPEventModelCarbon;
 #else
   mEventModel = NPEventModelCocoa;
 #endif
 #endif
 
-  mWaitingForPaint = PR_FALSE;
+  mWaitingForPaint = false;
 }
 
 nsPluginInstanceOwner::~nsPluginInstanceOwner()
 {
   PRInt32 cnt;
 
   if (mWaitingForPaint) {
     // We don't care when the event is dispatched as long as it's "soon",
     // since whoever needs it will be waiting for it.
-    nsCOMPtr<nsIRunnable> event = new AsyncPaintWaitEvent(mContent, PR_TRUE);
+    nsCOMPtr<nsIRunnable> event = new AsyncPaintWaitEvent(mContent, true);
     NS_DispatchToMainThread(event);
   }
 
 #ifdef MAC_CARBON_PLUGINS
   CancelTimer();
 #endif
 
   mObjectFrame = nsnull;
@@ -524,17 +524,17 @@ NS_IMETHODIMP nsPluginInstanceOwner::Get
     headersDataStream = do_QueryInterface(sis);
   }
 
   PRInt32 blockPopups =
     Preferences::GetInt("privacy.popups.disable_from_plugins");
   nsAutoPopupStatePusher popupStatePusher((PopupControlState)blockPopups);
 
   rv = lh->OnLinkClick(mContent, uri, unitarget.get(), 
-                       aPostStream, headersDataStream, PR_TRUE);
+                       aPostStream, headersDataStream, true);
 
   return rv;
 }
 
 NS_IMETHODIMP nsPluginInstanceOwner::ShowStatus(const char *aStatusMsg)
 {
   nsresult  rv = NS_ERROR_FAILURE;
   
@@ -589,17 +589,17 @@ NS_IMETHODIMP nsPluginInstanceOwner::Get
 
 NS_IMETHODIMP nsPluginInstanceOwner::InvalidateRect(NPRect *invalidRect)
 {
   // If our object frame has gone away, we won't be able to determine
   // up-to-date-ness, so just fire off the event.
   if (mWaitingForPaint && (!mObjectFrame || IsUpToDate())) {
     // We don't care when the event is dispatched as long as it's "soon",
     // since whoever needs it will be waiting for it.
-    nsCOMPtr<nsIRunnable> event = new AsyncPaintWaitEvent(mContent, PR_TRUE);
+    nsCOMPtr<nsIRunnable> event = new AsyncPaintWaitEvent(mContent, true);
     NS_DispatchToMainThread(event);
     mWaitingForPaint = false;
   }
 
   if (!mObjectFrame || !invalidRect || !mWidgetVisible)
     return NS_ERROR_FAILURE;
 
   // Each time an asynchronously-drawing plugin sends a new surface to display,
@@ -614,17 +614,17 @@ NS_IMETHODIMP nsPluginInstanceOwner::Inv
 
 #ifndef XP_MACOSX
   // Windowed plugins should not be calling NPN_InvalidateRect, but
   // Silverlight does and expects it to "work"
   if (mWidget) {
     mWidget->Invalidate(nsIntRect(invalidRect->left, invalidRect->top,
                                   invalidRect->right - invalidRect->left,
                                   invalidRect->bottom - invalidRect->top),
-                        PR_FALSE);
+                        false);
     return NS_OK;
   }
 #endif
 
   nsPresContext* presContext = mObjectFrame->PresContext();
   nsRect rect(presContext->DevPixelsToAppUnits(invalidRect->left),
               presContext->DevPixelsToAppUnits(invalidRect->top),
               presContext->DevPixelsToAppUnits(invalidRect->right - invalidRect->left),
@@ -747,17 +747,17 @@ NS_IMETHODIMP nsPluginInstanceOwner::Set
 #else
   return NS_ERROR_NOT_IMPLEMENTED;
 #endif
 }
 
 NS_IMETHODIMP nsPluginInstanceOwner::SetWindow()
 {
   NS_ENSURE_TRUE(mObjectFrame, NS_ERROR_NULL_POINTER);
-  return mObjectFrame->CallSetWindow(PR_FALSE);
+  return mObjectFrame->CallSetWindow(false);
 }
 
 NPError nsPluginInstanceOwner::ShowNativeContextMenu(NPMenu* menu, void* event)
 {
   if (!menu || !event)
     return NPERR_GENERIC_ERROR;
 
 #ifdef XP_MACOSX
@@ -771,23 +771,23 @@ NPError nsPluginInstanceOwner::ShowNativ
 #endif
 }
 
 NPBool nsPluginInstanceOwner::ConvertPoint(double sourceX, double sourceY, NPCoordinateSpace sourceSpace,
                                            double *destX, double *destY, NPCoordinateSpace destSpace)
 {
 #ifdef XP_MACOSX
   if (!mWidget)
-    return PR_FALSE;
+    return false;
 
   return NS_NPAPI_ConvertPointCocoa(mWidget->GetNativeData(NS_NATIVE_WIDGET),
                                     sourceX, sourceY, sourceSpace, destX, destY, destSpace);
 #else
   // we should implement this for all platforms
-  return PR_FALSE;
+  return false;
 #endif
 }
 
 NS_IMETHODIMP nsPluginInstanceOwner::GetTagType(nsPluginTagType *result)
 {
   NS_ENSURE_ARG_POINTER(result);
 
   *result = nsPluginTagType_Unknown;
@@ -1292,18 +1292,18 @@ nsresult nsPluginInstanceOwner::EnsureCa
      * http://www.w3.org/TR/html4/types.html#type-cdata
      * ''User agents may ignore leading and trailing
      * white space in CDATA attribute values (e.g., "
      * myval " may be interpreted as "myval"). Authors
      * should not declare attribute values with
      * leading or trailing white space.''
      * However, do not trim consecutive spaces as in bug 122119
      */
-    name.Trim(" \n\r\t\b", PR_TRUE, PR_TRUE, PR_FALSE);
-    value.Trim(" \n\r\t\b", PR_TRUE, PR_TRUE, PR_FALSE);
+    name.Trim(" \n\r\t\b", true, true, false);
+    value.Trim(" \n\r\t\b", true, true, false);
     mCachedAttrParamNames [nextAttrParamIndex] = ToNewUTF8String(name);
     mCachedAttrParamValues[nextAttrParamIndex] = ToNewUTF8String(value);
     nextAttrParamIndex++;
   }
 
   return NS_OK;
 }
 
@@ -1341,21 +1341,21 @@ NPDrawingModel nsPluginInstanceOwner::Ge
 
   mInstance->GetDrawingModel((PRInt32*)&drawingModel);
   return drawingModel;
 }
 
 bool nsPluginInstanceOwner::IsRemoteDrawingCoreAnimation()
 {
   if (!mInstance)
-    return PR_FALSE;
+    return false;
 
   bool coreAnimation;
   if (!NS_SUCCEEDED(mInstance->IsRemoteDrawingCoreAnimation(&coreAnimation)))
-    return PR_FALSE;
+    return false;
 
   return coreAnimation;
 }
 
 NPEventModel nsPluginInstanceOwner::GetEventModel()
 {
   return mEventModel;
 }
@@ -1540,31 +1540,31 @@ void* nsPluginInstanceOwner::SetPluginPo
   mPluginWindow->window = pluginPort;
 
 #ifndef NP_NO_QUICKDRAW
   NPDrawingModel drawingModel = GetDrawingModel();
   if (drawingModel == NPDrawingModelQuickDraw) {
     NP_Port* windowQDPort = static_cast<NP_Port*>(mPluginWindow->window);
     if (windowQDPort->port != mQDPluginPortCopy.port) {
       mQDPluginPortCopy.port = windowQDPort->port;
-      mPluginPortChanged = PR_TRUE;
+      mPluginPortChanged = true;
     }
   } else if (drawingModel == NPDrawingModelCoreGraphics || 
              drawingModel == NPDrawingModelCoreAnimation ||
              drawingModel == NPDrawingModelInvalidatingCoreAnimation)
 #endif
   {
 #ifndef NP_NO_CARBON
     if (GetEventModel() == NPEventModelCarbon) {
       NP_CGContext* windowCGPort = static_cast<NP_CGContext*>(mPluginWindow->window);
       if ((windowCGPort->context != mCGPluginPortCopy.context) ||
           (windowCGPort->window != mCGPluginPortCopy.window)) {
         mCGPluginPortCopy.context = windowCGPort->context;
         mCGPluginPortCopy.window = windowCGPort->window;
-        mPluginPortChanged = PR_TRUE;
+        mPluginPortChanged = true;
       }
     }
 #endif
   }
 
   return mPluginWindow->window;
 }
 
@@ -1686,17 +1686,17 @@ nsresult nsPluginInstanceOwner::Dispatch
     aFocusEvent->GetType(eventType);
     if (eventType.EqualsLiteral("focus")) {
       event.data.lifecycle.action = kGainFocus_ANPLifecycleAction;
     }
     else if (eventType.EqualsLiteral("blur")) {
       event.data.lifecycle.action = kLoseFocus_ANPLifecycleAction;
     }
     else {
-      NS_ASSERTION(PR_FALSE, "nsPluginInstanceOwner::DispatchFocusToPlugin, wierd eventType");   
+      NS_ASSERTION(false, "nsPluginInstanceOwner::DispatchFocusToPlugin, wierd eventType");   
     }
     mInstance->HandleEvent(&event, nsnull);
   }
 #endif
 
 #ifndef XP_MACOSX
   if (!mPluginWindow || (mPluginWindow->type == NPWindowTypeWindow)) {
     // continue only for cases without child window
@@ -1712,19 +1712,19 @@ nsresult nsPluginInstanceOwner::Dispatch
       nsGUIEvent focusEvent(NS_IS_TRUSTED_EVENT(theEvent), theEvent->message,
                             nsnull);
       nsEventStatus rv = ProcessEvent(focusEvent);
       if (nsEventStatus_eConsumeNoDefault == rv) {
         aFocusEvent->PreventDefault();
         aFocusEvent->StopPropagation();
       }
     }
-    else NS_ASSERTION(PR_FALSE, "nsPluginInstanceOwner::DispatchFocusToPlugin failed, focusEvent null");   
+    else NS_ASSERTION(false, "nsPluginInstanceOwner::DispatchFocusToPlugin failed, focusEvent null");   
   }
-  else NS_ASSERTION(PR_FALSE, "nsPluginInstanceOwner::DispatchFocusToPlugin failed, privateEvent null");   
+  else NS_ASSERTION(false, "nsPluginInstanceOwner::DispatchFocusToPlugin failed, privateEvent null");   
   
   return NS_OK;
 }    
 
 #if defined(MOZ_WIDGET_QT) && (MOZ_PLATFORM_MAEMO == 6)
 nsresult nsPluginInstanceOwner::Text(nsIDOMEvent* aTextEvent)
 {
   if (mInstance) {
@@ -1733,19 +1733,19 @@ nsresult nsPluginInstanceOwner::Text(nsI
       nsEvent *event = privateEvent->GetInternalNSEvent();
       if (event && event->eventStructType == NS_TEXT_EVENT) {
         nsEventStatus rv = ProcessEvent(*static_cast<nsGUIEvent*>(event));
         if (nsEventStatus_eConsumeNoDefault == rv) {
           aTextEvent->PreventDefault();
           aTextEvent->StopPropagation();
         }
       }
-      else NS_ASSERTION(PR_FALSE, "nsPluginInstanceOwner::DispatchTextToPlugin failed, textEvent null");
+      else NS_ASSERTION(false, "nsPluginInstanceOwner::DispatchTextToPlugin failed, textEvent null");
     }
-    else NS_ASSERTION(PR_FALSE, "nsPluginInstanceOwner::DispatchTextToPlugin failed, privateEvent null");
+    else NS_ASSERTION(false, "nsPluginInstanceOwner::DispatchTextToPlugin failed, privateEvent null");
   }
 
   return NS_OK;
 }
 #endif
 
 nsresult nsPluginInstanceOwner::KeyPress(nsIDOMEvent* aKeyEvent)
 {
@@ -1770,19 +1770,19 @@ nsresult nsPluginInstanceOwner::KeyPress
     // dispatch key events to a TSM handler, which comes back and calls 
     // [ChildView insertText:] on the cocoa widget, which sends a key
     // event back down.
     static bool sInKeyDispatch = false;
 
     if (sInKeyDispatch)
       return aKeyEvent->PreventDefault(); // consume event
 
-    sInKeyDispatch = PR_TRUE;
+    sInKeyDispatch = true;
     nsresult rv =  DispatchKeyToPlugin(aKeyEvent);
-    sInKeyDispatch = PR_FALSE;
+    sInKeyDispatch = false;
     return rv;
   }
 #endif
 
   return DispatchKeyToPlugin(aKeyEvent);
 #else
   if (SendNativeEvents())
     DispatchKeyToPlugin(aKeyEvent);
@@ -1811,19 +1811,19 @@ nsresult nsPluginInstanceOwner::Dispatch
       nsEvent *event = privateEvent->GetInternalNSEvent();
       if (event && event->eventStructType == NS_KEY_EVENT) {
         nsEventStatus rv = ProcessEvent(*static_cast<nsGUIEvent*>(event));
         if (nsEventStatus_eConsumeNoDefault == rv) {
           aKeyEvent->PreventDefault();
           aKeyEvent->StopPropagation();
         }
       }
-      else NS_ASSERTION(PR_FALSE, "nsPluginInstanceOwner::DispatchKeyToPlugin failed, keyEvent null");   
+      else NS_ASSERTION(false, "nsPluginInstanceOwner::DispatchKeyToPlugin failed, keyEvent null");   
     }
-    else NS_ASSERTION(PR_FALSE, "nsPluginInstanceOwner::DispatchKeyToPlugin failed, privateEvent null");   
+    else NS_ASSERTION(false, "nsPluginInstanceOwner::DispatchKeyToPlugin failed, privateEvent null");   
   }
 
   return NS_OK;
 }    
 
 nsresult
 nsPluginInstanceOwner::MouseDown(nsIDOMEvent* aMouseEvent)
 {
@@ -1849,19 +1849,19 @@ nsPluginInstanceOwner::MouseDown(nsIDOME
   if (privateEvent) {
     nsEvent* event = privateEvent->GetInternalNSEvent();
       if (event && event->eventStructType == NS_MOUSE_EVENT) {
         nsEventStatus rv = ProcessEvent(*static_cast<nsGUIEvent*>(event));
       if (nsEventStatus_eConsumeNoDefault == rv) {
         return aMouseEvent->PreventDefault(); // consume event
       }
     }
-    else NS_ASSERTION(PR_FALSE, "nsPluginInstanceOwner::MouseDown failed, mouseEvent null");   
+    else NS_ASSERTION(false, "nsPluginInstanceOwner::MouseDown failed, mouseEvent null");   
   }
-  else NS_ASSERTION(PR_FALSE, "nsPluginInstanceOwner::MouseDown failed, privateEvent null");   
+  else NS_ASSERTION(false, "nsPluginInstanceOwner::MouseDown failed, privateEvent null");   
   
   return NS_OK;
 }
 
 nsresult nsPluginInstanceOwner::DispatchMouseToPlugin(nsIDOMEvent* aMouseEvent)
 {
 #if !defined(XP_MACOSX)
   if (!mPluginWindow || (mPluginWindow->type == NPWindowTypeWindow))
@@ -1877,34 +1877,34 @@ nsresult nsPluginInstanceOwner::Dispatch
     nsEvent* event = privateEvent->GetInternalNSEvent();
     if (event && event->eventStructType == NS_MOUSE_EVENT) {
       nsEventStatus rv = ProcessEvent(*static_cast<nsGUIEvent*>(event));
       if (nsEventStatus_eConsumeNoDefault == rv) {
         aMouseEvent->PreventDefault();
         aMouseEvent->StopPropagation();
       }
     }
-    else NS_ASSERTION(PR_FALSE, "nsPluginInstanceOwner::DispatchMouseToPlugin failed, mouseEvent null");   
+    else NS_ASSERTION(false, "nsPluginInstanceOwner::DispatchMouseToPlugin failed, mouseEvent null");   
   }
-  else NS_ASSERTION(PR_FALSE, "nsPluginInstanceOwner::DispatchMouseToPlugin failed, privateEvent null");   
+  else NS_ASSERTION(false, "nsPluginInstanceOwner::DispatchMouseToPlugin failed, privateEvent null");   
   
   return NS_OK;
 }
 
 nsresult
 nsPluginInstanceOwner::HandleEvent(nsIDOMEvent* aEvent)
 {
   nsAutoString eventType;
   aEvent->GetType(eventType);
   if (eventType.EqualsLiteral("focus")) {
-    mContentFocused = PR_TRUE;
+    mContentFocused = true;
     return DispatchFocusToPlugin(aEvent);
   }
   if (eventType.EqualsLiteral("blur")) {
-    mContentFocused = PR_FALSE;
+    mContentFocused = false;
     return DispatchFocusToPlugin(aEvent);
   }
   if (eventType.EqualsLiteral("mousedown")) {
     return MouseDown(aEvent);
   }
   if (eventType.EqualsLiteral("mouseup")) {
     // Don't send a mouse-up event to the plugin if it isn't focused.  This can
     // happen if the previous mouse-down was sent to a DOM element above the
@@ -2197,17 +2197,17 @@ nsEventStatus nsPluginInstanceOwner::Pro
                    anEvent.message == NS_MOUSE_MOVE,
                    "Incorrect event type for coordinate translation");
       nsPoint pt =
         nsLayoutUtils::GetEventCoordinatesRelativeTo(&anEvent, mObjectFrame) -
         mObjectFrame->GetContentRectRelativeToSelf().TopLeft();
       nsPresContext* presContext = mObjectFrame->PresContext();
       nsIntPoint ptPx(presContext->AppUnitsToDevPixels(pt.x),
                       presContext->AppUnitsToDevPixels(pt.y));
-      nsIntPoint widgetPtPx = ptPx + mObjectFrame->GetWindowOriginInPixels(PR_TRUE);
+      nsIntPoint widgetPtPx = ptPx + mObjectFrame->GetWindowOriginInPixels(true);
       pPluginEvent->lParam = MAKELPARAM(widgetPtPx.x, widgetPtPx.y);
     }
   }
   else if (!pPluginEvent) {
     switch (anEvent.message) {
       case NS_FOCUS_CONTENT:
         pluginEvent.event = WM_SETFOCUS;
         pluginEvent.wParam = 0;
@@ -2607,40 +2607,40 @@ nsPluginInstanceOwner::Destroy()
 #endif
 
   // unregister context menu listener
   if (mCXMenuListener) {
     mCXMenuListener->Destroy(mContent);
     mCXMenuListener = nsnull;
   }
 
-  mContent->RemoveEventListener(NS_LITERAL_STRING("focus"), this, PR_FALSE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("blur"), this, PR_FALSE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("mouseup"), this, PR_FALSE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("mousedown"), this, PR_FALSE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("mousemove"), this, PR_FALSE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("click"), this, PR_FALSE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("dblclick"), this, PR_FALSE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("mouseover"), this, PR_FALSE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("mouseout"), this, PR_FALSE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("keypress"), this, PR_TRUE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("keydown"), this, PR_TRUE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("keyup"), this, PR_TRUE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("drop"), this, PR_TRUE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("dragdrop"), this, PR_TRUE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("drag"), this, PR_TRUE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("dragenter"), this, PR_TRUE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("dragover"), this, PR_TRUE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("dragleave"), this, PR_TRUE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("dragexit"), this, PR_TRUE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("dragstart"), this, PR_TRUE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("draggesture"), this, PR_TRUE);
-  mContent->RemoveEventListener(NS_LITERAL_STRING("dragend"), this, PR_TRUE);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("focus"), this, false);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("blur"), this, false);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("mouseup"), this, false);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("mousedown"), this, false);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("mousemove"), this, false);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("click"), this, false);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("dblclick"), this, false);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("mouseover"), this, false);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("mouseout"), this, false);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("keypress"), this, true);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("keydown"), this, true);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("keyup"), this, true);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("drop"), this, true);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("dragdrop"), this, true);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("drag"), this, true);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("dragenter"), this, true);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("dragover"), this, true);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("dragleave"), this, true);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("dragexit"), this, true);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("dragstart"), this, true);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("draggesture"), this, true);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("dragend"), this, true);
 #if defined(MOZ_WIDGET_QT) && (MOZ_PLATFORM_MAEMO == 6)
-  mContent->RemoveEventListener(NS_LITERAL_STRING("text"), this, PR_TRUE);
+  mContent->RemoveEventListener(NS_LITERAL_STRING("text"), this, true);
 #endif
 
   if (mWidget) {
     nsCOMPtr<nsIPluginWidget> pluginWidget = do_QueryInterface(mWidget);
     if (pluginWidget)
       pluginWidget->SetPluginInstanceOwner(nsnull);
 
     if (mDestroyWidget)
@@ -2678,25 +2678,25 @@ nsPluginInstanceOwner::PrepareToStop(boo
 #if defined(XP_WIN) || defined(MOZ_X11)
   if (aDelayedStop && mWidget) {
     // To delay stopping a plugin we need to reparent the plugin
     // so that we can safely tear down the
     // plugin after its frame (and view) is gone.
 
     // Also hide and disable the widget to avoid it from appearing in
     // odd places after reparenting it, but before it gets destroyed.
-    mWidget->Show(PR_FALSE);
-    mWidget->Enable(PR_FALSE);
+    mWidget->Show(false);
+    mWidget->Enable(false);
 
     // Reparent the plugins native window. This relies on the widget
     // and plugin et al not holding any other references to its
     // parent.
     mWidget->SetParent(nsnull);
 
-    mDestroyWidget = PR_TRUE;
+    mDestroyWidget = true;
   }
 #endif
 
 #ifdef ANDROID
   RemovePluginView();
 #endif
 
   // Unregister scroll position listeners
@@ -2853,17 +2853,17 @@ void nsPluginInstanceOwner::Paint(gfxCon
       event.inSize = sizeof(ANPEvent);
       event.eventType = kLifecycle_ANPEventType;
       event.data.lifecycle.action = kOnScreen_ANPLifecycleAction;
       mInstance->HandleEvent(&event, nsnull);
     }
 
     /*
     gfxMatrix currentMatrix = aContext->CurrentMatrix();
-    gfxSize scale = currentMatrix.ScaleFactors(PR_TRUE);
+    gfxSize scale = currentMatrix.ScaleFactors(true);
     printf_stderr("!!!!!!!! scale!!:  %f x %f\n", scale.width, scale.height);
     */
 
     JNIEnv* env = GetJNIForThread();
     jclass cls = env->FindClass("org/mozilla/gecko/GeckoAppShell");
     jmethodID method = env->GetStaticMethodID(cls,
                                               "addPluginView",
                                               "(Landroid/view/View;DDDD)V");
@@ -3023,23 +3023,23 @@ nsPluginInstanceOwner::Renderer::DrawWit
     return NS_ERROR_FAILURE;
 
   // See if the plugin must be notified of new window parameters.
   bool doupdatewindow = false;
 
   if (mWindow->x != offset.x || mWindow->y != offset.y) {
     mWindow->x = offset.x;
     mWindow->y = offset.y;
-    doupdatewindow = PR_TRUE;
+    doupdatewindow = true;
   }
 
   if (nsIntSize(mWindow->width, mWindow->height) != mPluginSize) {
     mWindow->width = mPluginSize.width;
     mWindow->height = mPluginSize.height;
-    doupdatewindow = PR_TRUE;
+    doupdatewindow = true;
   }
 
   // The clip rect is relative to drawable top-left.
   NS_ASSERTION(numClipRects <= 1, "We don't support multiple clip rectangles!");
   nsIntRect clipRect;
   if (numClipRects) {
     clipRect.x = clipRects[0].x;
     clipRect.y = clipRects[0].y;
@@ -3068,27 +3068,27 @@ nsPluginInstanceOwner::Renderer::DrawWit
   newClipRect.top = clipRect.y;
   newClipRect.right = clipRect.XMost();
   newClipRect.bottom = clipRect.YMost();
   if (mWindow->clipRect.left    != newClipRect.left   ||
       mWindow->clipRect.top     != newClipRect.top    ||
       mWindow->clipRect.right   != newClipRect.right  ||
       mWindow->clipRect.bottom  != newClipRect.bottom) {
     mWindow->clipRect = newClipRect;
-    doupdatewindow = PR_TRUE;
+    doupdatewindow = true;
   }
 
   NPSetWindowCallbackStruct* ws_info = 
     static_cast<NPSetWindowCallbackStruct*>(mWindow->ws_info);
 #ifdef MOZ_X11
   if (ws_info->visual != visual || ws_info->colormap != colormap) {
     ws_info->visual = visual;
     ws_info->colormap = colormap;
     ws_info->depth = gfxXlibSurface::DepthOfVisual(screen, visual);
-    doupdatewindow = PR_TRUE;
+    doupdatewindow = true;
   }
 #endif
 
   {
     if (doupdatewindow)
       instance->SetWindow(mWindow);
   }
 
@@ -3197,49 +3197,49 @@ nsresult nsPluginInstanceOwner::Init(nsP
   }
 
   // register context menu listener
   mCXMenuListener = new nsPluginDOMContextMenuListener();
   if (mCXMenuListener) {    
     mCXMenuListener->Init(aContent);
   }
 
-  mContent->AddEventListener(NS_LITERAL_STRING("focus"), this, PR_FALSE,
-                             PR_FALSE);
-  mContent->AddEventListener(NS_LITERAL_STRING("blur"), this, PR_FALSE,
-                             PR_FALSE);
-  mContent->AddEventListener(NS_LITERAL_STRING("mouseup"), this, PR_FALSE,
-                             PR_FALSE);
-  mContent->AddEventListener(NS_LITERAL_STRING("mousedown"), this, PR_FALSE,
-                             PR_FALSE);
-  mContent->AddEventListener(NS_LITERAL_STRING("mousemove"), this, PR_FALSE,
-                             PR_FALSE);
-  mContent->AddEventListener(NS_LITERAL_STRING("click"), this, PR_FALSE,
-                             PR_FALSE);
-  mContent->AddEventListener(NS_LITERAL_STRING("dblclick"), this, PR_FALSE,
-                             PR_FALSE);
-  mContent->AddEventListener(NS_LITERAL_STRING("mouseover"), this, PR_FALSE,
-                             PR_FALSE);
-  mContent->AddEventListener(NS_LITERAL_STRING("mouseout"), this, PR_FALSE,
-                             PR_FALSE);
-  mContent->AddEventListener(NS_LITERAL_STRING("keypress"), this, PR_TRUE);
-  mContent->AddEventListener(NS_LITERAL_STRING("keydown"), this, PR_TRUE);
-  mContent->AddEventListener(NS_LITERAL_STRING("keyup"), this, PR_TRUE);
-  mContent->AddEventListener(NS_LITERAL_STRING("drop"), this, PR_TRUE);
-  mContent->AddEventListener(NS_LITERAL_STRING("dragdrop"), this, PR_TRUE);
-  mContent->AddEventListener(NS_LITERAL_STRING("drag"), this, PR_TRUE);
-  mContent->AddEventListener(NS_LITERAL_STRING("dragenter"), this, PR_TRUE);
-  mContent->AddEventListener(NS_LITERAL_STRING("dragover"), this, PR_TRUE);
-  mContent->AddEventListener(NS_LITERAL_STRING("dragleave"), this, PR_TRUE);
-  mContent->AddEventListener(NS_LITERAL_STRING("dragexit"), this, PR_TRUE);
-  mContent->AddEventListener(NS_LITERAL_STRING("dragstart"), this, PR_TRUE);
-  mContent->AddEventListener(NS_LITERAL_STRING("draggesture"), this, PR_TRUE);
-  mContent->AddEventListener(NS_LITERAL_STRING("dragend"), this, PR_TRUE);
+  mContent->AddEventListener(NS_LITERAL_STRING("focus"), this, false,
+                             false);
+  mContent->AddEventListener(NS_LITERAL_STRING("blur"), this, false,
+                             false);
+  mContent->AddEventListener(NS_LITERAL_STRING("mouseup"), this, false,
+                             false);
+  mContent->AddEventListener(NS_LITERAL_STRING("mousedown"), this, false,
+                             false);
+  mContent->AddEventListener(NS_LITERAL_STRING("mousemove"), this, false,
+                             false);
+  mContent->AddEventListener(NS_LITERAL_STRING("click"), this, false,
+                             false);
+  mContent->AddEventListener(NS_LITERAL_STRING("dblclick"), this, false,
+                             false);
+  mContent->AddEventListener(NS_LITERAL_STRING("mouseover"), this, false,
+                             false);
+  mContent->AddEventListener(NS_LITERAL_STRING("mouseout"), this, false,
+                             false);
+  mContent->AddEventListener(NS_LITERAL_STRING("keypress"), this, true);
+  mContent->AddEventListener(NS_LITERAL_STRING("keydown"), this, true);
+  mContent->AddEventListener(NS_LITERAL_STRING("keyup"), this, true);
+  mContent->AddEventListener(NS_LITERAL_STRING("drop"), this, true);
+  mContent->AddEventListener(NS_LITERAL_STRING("dragdrop"), this, true);
+  mContent->AddEventListener(NS_LITERAL_STRING("drag"), this, true);
+  mContent->AddEventListener(NS_LITERAL_STRING("dragenter"), this, true);
+  mContent->AddEventListener(NS_LITERAL_STRING("dragover"), this, true);
+  mContent->AddEventListener(NS_LITERAL_STRING("dragleave"), this, true);
+  mContent->AddEventListener(NS_LITERAL_STRING("dragexit"), this, true);
+  mContent->AddEventListener(NS_LITERAL_STRING("dragstart"), this, true);
+  mContent->AddEventListener(NS_LITERAL_STRING("draggesture"), this, true);
+  mContent->AddEventListener(NS_LITERAL_STRING("dragend"), this, true);
 #if defined(MOZ_WIDGET_QT) && (MOZ_PLATFORM_MAEMO == 6)
-  mContent->AddEventListener(NS_LITERAL_STRING("text"), this, PR_TRUE);
+  mContent->AddEventListener(NS_LITERAL_STRING("text"), this, true);
 #endif
   
   // Register scroll position listeners
   // We need to register a scroll position listener on every scrollable
   // frame up to the top
   for (nsIFrame* f = mObjectFrame; f; f = nsLayoutUtils::GetCrossDocParentFrame(f)) {
     nsIScrollableFrame* sf = do_QueryFrame(f);
     if (sf) {
@@ -3297,17 +3297,17 @@ NS_IMETHODIMP nsPluginInstanceOwner::Cre
       // always create widgets in Twips, not pixels
       nsPresContext* context = mObjectFrame->PresContext();
       rv = mObjectFrame->CreateWidget(context->DevPixelsToAppUnits(mPluginWindow->width),
                                       context->DevPixelsToAppUnits(mPluginWindow->height),
                                       windowless);
       if (NS_OK == rv) {
         mWidget = mObjectFrame->GetWidget();
 
-        if (PR_TRUE == windowless) {
+        if (true == windowless) {
           mPluginWindow->type = NPWindowTypeDrawable;
 
           // this needs to be a HDC according to the spec, but I do
           // not see the right way to release it so let's postpone
           // passing HDC till paint event when it is really
           // needed. Change spec?
           mPluginWindow->window = nsnull;
 #ifdef MOZ_X11
@@ -3343,17 +3343,17 @@ NS_IMETHODIMP nsPluginInstanceOwner::Cre
 
           // mPluginWindow->type is used in |GetPluginPort| so it must
           // be initialized first
           mPluginWindow->type = NPWindowTypeWindow;
           mPluginWindow->window = GetPluginPortFromWidget();
 
 #ifdef MAC_CARBON_PLUGINS
           // start the idle timer.
-          StartTimer(PR_TRUE);
+          StartTimer(true);
 #endif
 
           // tell the plugin window about the widget
           mPluginWindow->SetPluginWidget(mWidget);
 
           // tell the widget about the current plugin instance owner.
           nsCOMPtr<nsIPluginWidget> pluginWidget = do_QueryInterface(mWidget);
           if (pluginWidget)
@@ -3470,40 +3470,40 @@ void* nsPluginInstanceOwner::FixUpPlugin
   // if the clip rect changed, call SetWindow()
   // (RealPlayer needs this to draw correctly)
   if (mPluginWindow->clipRect.left    != oldClipRect.left   ||
       mPluginWindow->clipRect.top     != oldClipRect.top    ||
       mPluginWindow->clipRect.right   != oldClipRect.right  ||
       mPluginWindow->clipRect.bottom  != oldClipRect.bottom)
   {
     CallSetWindow();
-    mPluginPortChanged = PR_FALSE;
+    mPluginPortChanged = false;
 #ifdef MAC_CARBON_PLUGINS
     // if the clipRect is of size 0, make the null timer fire less often
     CancelTimer();
     if (mPluginWindow->clipRect.left == mPluginWindow->clipRect.right ||
         mPluginWindow->clipRect.top == mPluginWindow->clipRect.bottom) {
-      StartTimer(PR_FALSE);
+      StartTimer(false);
     }
     else {
-      StartTimer(PR_TRUE);
+      StartTimer(true);
     }
 #endif
   } else if (mPluginPortChanged) {
     CallSetWindow();
-    mPluginPortChanged = PR_FALSE;
+    mPluginPortChanged = false;
   }
 
   // After the first NPP_SetWindow call we need to send an initial
   // top-level window focus event.
   if (eventModel == NPEventModelCocoa && !mSentInitialTopLevelWindowEvent) {
     // Set this before calling ProcessEvent to avoid endless recursion.
-    mSentInitialTopLevelWindowEvent = PR_TRUE;
-
-    nsPluginEvent pluginEvent(PR_TRUE, NS_PLUGIN_FOCUS_EVENT, nsnull);
+    mSentInitialTopLevelWindowEvent = true;
+
+    nsPluginEvent pluginEvent(true, NS_PLUGIN_FOCUS_EVENT, nsnull);
     NPCocoaEvent cocoaEvent;
     InitializeNPCocoaEvent(&cocoaEvent);
     cocoaEvent.type = NPCocoaEventWindowFocusChanged;
     cocoaEvent.data.focus.hasFocus = NS_NPAPI_CocoaWindowIsMain(cocoaTopLevelWindow);
     pluginEvent.pluginEvent = &cocoaEvent;
     ProcessEvent(pluginEvent);
   }
 
@@ -3524,17 +3524,17 @@ void
 nsPluginInstanceOwner::HidePluginWindow()
 {
   if (!mPluginWindow || !mInstance) {
     return;
   }
 
   mPluginWindow->clipRect.bottom = mPluginWindow->clipRect.top;
   mPluginWindow->clipRect.right  = mPluginWindow->clipRect.left;
-  mWidgetVisible = PR_FALSE;
+  mWidgetVisible = false;
   if (mAsyncHidePluginWindow) {
     mInstance->AsyncSetWindow(mPluginWindow);
   } else {
     mInstance->SetWindow(mPluginWindow);
   }
 }
 
 #else // XP_MACOSX
@@ -3600,24 +3600,24 @@ void nsPluginInstanceOwner::UpdateWindow
     CallSetWindow();
   }
 }
 
 void
 nsPluginInstanceOwner::UpdateWindowVisibility(bool aVisible)
 {
   mPluginWindowVisible = aVisible;
-  UpdateWindowPositionAndClipRect(PR_TRUE);
+  UpdateWindowPositionAndClipRect(true);
 }
 
 void
 nsPluginInstanceOwner::UpdateDocumentActiveState(bool aIsActive)
 {
   mPluginDocumentActiveState = aIsActive;
-  UpdateWindowPositionAndClipRect(PR_TRUE);
+  UpdateWindowPositionAndClipRect(true);
 }
 #endif // XP_MACOSX
 
 void
 nsPluginInstanceOwner::CallSetWindow()
 {
   if (!mInstance)
     return;
@@ -3665,25 +3665,25 @@ nsPluginDOMContextMenuListener::HandleEv
   
   return NS_OK;
 }
 
 nsresult nsPluginDOMContextMenuListener::Init(nsIContent* aContent)
 {
   nsCOMPtr<nsIDOMEventTarget> receiver(do_QueryInterface(aContent));
   if (receiver) {
-    receiver->AddEventListener(NS_LITERAL_STRING("contextmenu"), this, PR_TRUE);
+    receiver->AddEventListener(NS_LITERAL_STRING("contextmenu"), this, true);
     return NS_OK;
   }
   
   return NS_ERROR_NO_INTERFACE;
 }
 
 nsresult nsPluginDOMContextMenuListener::Destroy(nsIContent* aContent)
 {
   // Unregister context menu listener
   nsCOMPtr<nsIDOMEventTarget> receiver(do_QueryInterface(aContent));
   if (receiver) {
-    receiver->RemoveEventListener(NS_LITERAL_STRING("contextmenu"), this, PR_TRUE);
+    receiver->RemoveEventListener(NS_LITERAL_STRING("contextmenu"), this, true);
   }
   
   return NS_OK;
 }
--- a/dom/plugins/base/nsPluginInstanceOwner.h
+++ b/dom/plugins/base/nsPluginInstanceOwner.h
@@ -262,19 +262,19 @@ public:
   bool SendNativeEvents()
   {
 #ifdef XP_WIN
     // XXX we should remove the plugin name check
     return mPluginWindow->type == NPWindowTypeDrawable &&
     (MatchPluginName("Shockwave Flash") ||
      MatchPluginName("Test Plug-in"));
 #elif defined(MOZ_X11) || defined(XP_MACOSX)
-    return PR_TRUE;
+    return true;
 #else
-    return PR_FALSE;
+    return false;
 #endif
   }
   
   bool MatchPluginName(const char *aPluginName)
   {
     return strncmp(GetPluginName(), aPluginName, strlen(aPluginName)) == 0;
   }
   
--- a/dom/plugins/base/nsPluginManifestLineReader.h
+++ b/dom/plugins/base/nsPluginManifestLineReader.h
@@ -64,44 +64,44 @@ class nsPluginManifestLineReader
       }
       mLength = 0;
       return mBase;
     }
     
     bool NextLine()
     {
       if (mNext >= mLimit)
-        return PR_FALSE;
+        return false;
       
       mCur = mNext;
       mLength = 0;
       
       char *lastDelimiter = 0;
       while(mNext < mLimit) {
         if (IsEOL(*mNext)) {
           if (lastDelimiter) {
             if (lastDelimiter && *(mNext - 1) != PLUGIN_REGISTRY_END_OF_LINE_MARKER)
-              return PR_FALSE;
+              return false;
             *lastDelimiter = '\0';
           } else {
             *mNext = '\0';
           }
 
           for (++mNext; mNext < mLimit; ++mNext) {
             if (!IsEOL(*mNext))
               break;
           }
-          return PR_TRUE;
+          return true;
         }
         if (*mNext == PLUGIN_REGISTRY_FIELD_DELIMITER)
           lastDelimiter = mNext;
         ++mNext;
         ++mLength;
       }
-      return PR_FALSE;        
+      return false;        
     }
 
     int ParseLine(char** chunks, int maxChunks)
     {
       NS_ASSERTION(mCur && maxChunks && chunks, "bad call to ParseLine");
       int found = 0;
       chunks[found++] = mCur;
       
--- a/dom/plugins/base/nsPluginNativeWindowGtk2.cpp
+++ b/dom/plugins/base/nsPluginNativeWindowGtk2.cpp
@@ -119,17 +119,17 @@ nsresult nsPluginNativeWindowGtk2::CallS
     if (type == NPWindowTypeWindow) {
       if (!mSocketWidget) {
         nsresult rv;
 
         bool needXEmbed = false;
         rv = aPluginInstance->GetValueFromPlugin(NPPVpluginNeedsXEmbed, &needXEmbed);
         // If the call returned an error code make sure we still use our default value.
         if (NS_FAILED(rv)) {
-          needXEmbed = PR_FALSE;
+          needXEmbed = false;
         }
 #ifdef DEBUG
         printf("nsPluginNativeWindowGtk2: NPPVpluginNeedsXEmbed=%d\n", needXEmbed);
 #endif
 
         if (needXEmbed) {
           rv = CreateXEmbedWindow();
         }
--- a/dom/plugins/base/nsPluginNativeWindowOS2.cpp
+++ b/dom/plugins/base/nsPluginNativeWindowOS2.cpp
@@ -146,17 +146,17 @@ public:
   NS_DECL_NSIRUNNABLE
 
 private:
   nsRefPtr<nsNPAPIPluginInstance> mInst;
 };
 
 NS_IMETHODIMP nsDelayedPopupsEnabledEvent::Run()
 {
-  mInst->PushPopupsEnabledState(PR_FALSE);
+  mInst->PushPopupsEnabledState(false);
   return NS_OK;	
 }
 
 /*****************************************************************************/
 /**
  *  nsPluginNativeWindow OS/2-specific class declaration
  */
 
@@ -209,25 +209,25 @@ static bool ProcessFlashMessageDelayed(n
   if (msg == sWM_FLASHBOUNCEMSG) {
     // See PluginWindowEvent::Run() below.
     NS_TRY_SAFE_CALL_VOID((aWin->GetWindowProc())(hWnd, WM_USER_FLASH, mp1, mp2),
                            inst);
     return TRUE;
   }
 
   if (msg != WM_USER_FLASH)
-    return PR_FALSE; // no need to delay
+    return false; // no need to delay
 
   // do stuff
   nsCOMPtr<nsIRunnable> pwe = aWin->GetPluginWindowEvent(hWnd, msg, mp1, mp2);
   if (pwe) {
     NS_DispatchToCurrentThread(pwe);
-    return PR_TRUE;  
+    return true;  
   }
-  return PR_FALSE;
+  return false;
 }
 
 /*****************************************************************************/
 /**
  *   New plugin window procedure
  */
 
 static MRESULT EXPENTRY PluginWndProc(HWND hWnd, ULONG msg, MPARAM mp1, MPARAM mp2)
@@ -269,38 +269,38 @@ static MRESULT EXPENTRY PluginWndProc(HW
   // is also done in ChildWindow::DispatchMouseEvent.
   switch (msg) {
     case WM_BUTTON1DOWN:
     case WM_BUTTON2DOWN:
     case WM_BUTTON3DOWN: {
       nsCOMPtr<nsIWidget> widget;
       win->GetPluginWidget(getter_AddRefs(widget));
       if (widget)
-        widget->CaptureMouse(PR_TRUE);
+        widget->CaptureMouse(true);
       break;
     }
 
     case WM_BUTTON1UP:
     case WM_BUTTON2UP:
     case WM_BUTTON3UP: {
       if (msg == WM_BUTTON1UP)
-        enablePopups = PR_TRUE;
+        enablePopups = true;
 
       nsCOMPtr<nsIWidget> widget;
       win->GetPluginWidget(getter_AddRefs(widget));
       if (widget)
-        widget->CaptureMouse(PR_FALSE);
+        widget->CaptureMouse(false);
       break;
     }
 
     case WM_CHAR:
       // Ignore repeating keydown messages...
       if (SHORT1FROMMP(mp1) & KC_PREVDOWN)
         break;
-      enablePopups = PR_TRUE;
+      enablePopups = true;
       break;
 
     // When the child of a plugin gets the focus, nsWindow doesn't get
     // a WM_FOCUSCHANGED msg, so plugin and window activation events
     // don't happen.  This fixes the problem by synthesizing a msg
     // that makes it look like the plugin widget just got the focus.
     case WM_FOCUSCHANGE: {
 
@@ -335,17 +335,17 @@ static MRESULT EXPENTRY PluginWndProc(HW
     if (ProcessFlashMessageDelayed(win, inst, hWnd, msg, mp1, mp2))
       return (MRESULT)TRUE;
   }
 
   if (enablePopups && inst) {
     PRUint16 apiVersion;
     if (NS_SUCCEEDED(inst->GetPluginAPIVersion(&apiVersion)) &&
         !versionOK(apiVersion, NP_POPUP_API_VERSION))
-      inst->PushPopupsEnabledState(PR_TRUE);
+      inst->PushPopupsEnabledState(true);
   }
 
   MRESULT res = (MRESULT)TRUE;
   if (win->mPluginType == nsPluginType_Java_vm)
     NS_TRY_SAFE_CALL_RETURN(res, ::WinDefWindowProc(hWnd, msg, mp1, mp2), inst);
   else
     NS_TRY_SAFE_CALL_RETURN(res, (win->GetWindowProc())(hWnd, msg, mp1, mp2), inst);
 
--- a/dom/plugins/base/nsPluginNativeWindowWin.cpp
+++ b/dom/plugins/base/nsPluginNativeWindowWin.cpp
@@ -184,25 +184,25 @@ static bool ProcessFlashMessageDelayed(n
   if (msg == sWM_FLASHBOUNCEMSG) {
     // See PluginWindowEvent::Run() below.
     NS_ASSERTION((sWM_FLASHBOUNCEMSG != 0), "RegisterWindowMessage failed in flash plugin WM_USER message handling!");
     ::CallWindowProc((WNDPROC)aWin->GetWindowProc(), hWnd, WM_USER_FLASH, wParam, lParam);
     return TRUE;
   }
 
   if (msg != WM_USER_FLASH)
-    return PR_FALSE; // no need to delay
+    return false; // no need to delay
 
   // do stuff
   nsCOMPtr<nsIRunnable> pwe = aWin->GetPluginWindowEvent(hWnd, msg, wParam, lParam);
   if (pwe) {
     NS_DispatchToCurrentThread(pwe);
-    return PR_TRUE;  
+    return true;  
   }
-  return PR_FALSE;
+  return false;
 }
 
 class nsDelayedPopupsEnabledEvent : public nsRunnable
 {
 public:
   nsDelayedPopupsEnabledEvent(nsNPAPIPluginInstance *inst)
     : mInst(inst)
   {}
@@ -210,17 +210,17 @@ public:
   NS_DECL_NSIRUNNABLE
 
 private:
   nsRefPtr<nsNPAPIPluginInstance> mInst;
 };
 
 NS_IMETHODIMP nsDelayedPopupsEnabledEvent::Run()
 {
-  mInst->PushPopupsEnabledState(PR_FALSE);
+  mInst->PushPopupsEnabledState(false);
   return NS_OK;	
 }
 
 /**
  *   New plugin window procedure
  */
 static LRESULT CALLBACK PluginWndProcInternal(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
@@ -234,17 +234,17 @@ static LRESULT CALLBACK PluginWndProcInt
   nsRefPtr<nsNPAPIPluginInstance> inst;
   win->GetPluginInstance(inst);
 
   // Real may go into a state where it recursivly dispatches the same event
   // when subclassed. If this is Real, lets examine the event and drop it
   // on the floor if we get into this recursive situation. See bug 192914.
   if (win->mPluginType == nsPluginType_Real) {
     if (sInMessageDispatch && msg == sLastMsg)
-      return PR_TRUE;
+      return true;
     // Cache the last message sent
     sLastMsg = msg;
   }
 
   bool enablePopups = false;
 
   // Activate/deactivate mouse capture on the plugin widget
   // here, before we pass the Windows event to the plugin
@@ -253,40 +253,40 @@ static LRESULT CALLBACK PluginWndProcInt
   // is also done in ChildWindow::DispatchMouseEvent.
   switch (msg) {
     case WM_LBUTTONDOWN:
     case WM_MBUTTONDOWN:
     case WM_RBUTTONDOWN: {
       nsCOMPtr<nsIWidget> widget;
       win->GetPluginWidget(getter_AddRefs(widget));
       if (widget)
-        widget->CaptureMouse(PR_TRUE);
+        widget->CaptureMouse(true);
       break;
     }
     case WM_LBUTTONUP:
-      enablePopups = PR_TRUE;
+      enablePopups = true;
 
       // fall through
     case WM_MBUTTONUP:
     case WM_RBUTTONUP: {
       nsCOMPtr<nsIWidget> widget;
       win->GetPluginWidget(getter_AddRefs(widget));
       if (widget)
-        widget->CaptureMouse(PR_FALSE);
+        widget->CaptureMouse(false);
       break;
     }
     case WM_KEYDOWN:
       // Ignore repeating keydown messages...
       if ((lParam & 0x40000000) != 0) {
         break;
       }
 
       // fall through
     case WM_KEYUP:
-      enablePopups = PR_TRUE;
+      enablePopups = true;
 
       break;
 
     case WM_MOUSEACTIVATE: {
       // If a child window of this plug-in is already focused,
       // don't focus the parent to avoid focus dance. We'll 
       // receive a follow up WM_SETFOCUS which will notify
       // the appropriate window anyway.
@@ -298,17 +298,17 @@ static LRESULT CALLBACK PluginWndProcInt
         // window in the child process receives focus via a mouse click.
         // WM_MOUSEACTIVATE is sent by nsWindow via a custom window event
         // sent from PluginInstanceParent in response to focus events sent
         // from the child. (bug 540052) Note, this gui event could also be
         // sent directly from widget.
         nsCOMPtr<nsIWidget> widget;
         win->GetPluginWidget(getter_AddRefs(widget));
         if (widget) {
-          nsGUIEvent event(PR_TRUE, NS_PLUGIN_ACTIVATE, widget);
+          nsGUIEvent event(true, NS_PLUGIN_ACTIVATE, widget);
           nsEventStatus status;
           widget->DispatchEvent(&event, status);
         }
       }
     }
     break;
 
     case WM_SETFOCUS:
@@ -317,19 +317,19 @@ static LRESULT CALLBACK PluginWndProcInt
       // see bug 328675.
       if (win->mPluginType == nsPluginType_Real && msg == sLastMsg)
         return TRUE;
       // Make sure setfocus and killfocus get through to the widget procedure
       // even if they are eaten by the plugin. Also make sure we aren't calling
       // recursively.
       WNDPROC prevWndProc = win->GetPrevWindowProc();
       if (prevWndProc && !sInPreviousMessageDispatch) {
-        sInPreviousMessageDispatch = PR_TRUE;
+        sInPreviousMessageDispatch = true;
         ::CallWindowProc(prevWndProc, hWnd, msg, wParam, lParam);
-        sInPreviousMessageDispatch = PR_FALSE;
+        sInPreviousMessageDispatch = false;
       }
       break;
     }
   }
 
   // Macromedia Flash plugin may flood the message queue with some special messages
   // (WM_USER+1) causing 100% CPU consumption and GUI freeze, see mozilla bug 132759;
   // we can prevent this from happening by delaying the processing such messages;
@@ -337,28 +337,28 @@ static LRESULT CALLBACK PluginWndProcInt
     if (ProcessFlashMessageDelayed(win, inst, hWnd, msg, wParam, lParam))
       return TRUE;
   }
 
   if (enablePopups && inst) {
     PRUint16 apiVersion;
     if (NS_SUCCEEDED(inst->GetPluginAPIVersion(&apiVersion)) &&
         !versionOK(apiVersion, NP_POPUP_API_VERSION)) {
-      inst->PushPopupsEnabledState(PR_TRUE);
+      inst->PushPopupsEnabledState(true);
     }
   }
 
-  sInMessageDispatch = PR_TRUE;
+  sInMessageDispatch = true;
 
   LRESULT res = TRUE;
   NS_TRY_SAFE_CALL_RETURN(res, 
                           ::CallWindowProc((WNDPROC)win->GetWindowProc(), hWnd, msg, wParam, lParam),
                           inst);
 
-  sInMessageDispatch = PR_FALSE;
+  sInMessageDispatch = false;
 
   if (inst) {
     // Popups are enabled (were enabled before the call to
     // CallWindowProc()). Some plugins (at least the flash player)
     // post messages from their key handlers etc that delay the actual
     // processing, so we need to delay the disabling of popups so that
     // popups remain enabled when the flash player ends up processing
     // the actual key handlers. We do this by posting an event that
@@ -422,18 +422,18 @@ SetWindowLongHookCheck(HWND hWnd,
                        int nIndex,
                        LONG_PTR newLong)
 {
   nsPluginNativeWindowWin * win =
     (nsPluginNativeWindowWin *)GetProp(hWnd, NS_PLUGIN_WINDOW_PROPERTY_ASSOCIATION);
   if (!win || (win && win->mPluginType != nsPluginType_Flash) ||
       (nIndex == GWLP_WNDPROC &&
        newLong == reinterpret_cast<LONG_PTR>(PluginWndProc)))
-    return PR_TRUE;
-  return PR_FALSE;
+    return true;
+  return false;
 }
 
 #ifdef _WIN64
 LONG_PTR WINAPI
 SetWindowLongPtrAHook(HWND hWnd,
                       int nIndex,
                       LONG_PTR newLong)
 #else
--- a/dom/plugins/base/nsPluginSafety.h
+++ b/dom/plugins/base/nsPluginSafety.h
@@ -68,17 +68,17 @@ PR_BEGIN_MACRO                          
   if(gSkipPluginSafeCalls)                         \
     ret = fun;                                     \
   else                                             \
   {                                                \
     MOZ_SEH_TRY                                    \
     {                                              \
       ret = fun;                                   \
     }                                              \
-    MOZ_SEH_EXCEPT(PR_TRUE)                        \
+    MOZ_SEH_EXCEPT(true)                        \
     {                                              \
       nsresult res;                                \
       nsCOMPtr<nsIPluginHost> host(do_GetService(MOZ_PLUGIN_HOST_CONTRACTID, &res));\
       if(NS_SUCCEEDED(res) && (host != nsnull))    \
         static_cast<nsPluginHost*>(host.get())->HandleBadPlugin(nsnull, pluginInst); \
       ret = (NPError)NS_ERROR_FAILURE;             \
     }                                              \
   }                                                \
@@ -91,17 +91,17 @@ PR_BEGIN_MACRO                          
   if(gSkipPluginSafeCalls)                  \
     fun;                                    \
   else                                      \
   {                                         \
     MOZ_SEH_TRY                             \
     {                                       \
       fun;                                  \
     }                                       \
-    MOZ_SEH_EXCEPT(PR_TRUE)                 \
+    MOZ_SEH_EXCEPT(true)                 \
     {                                       \
       nsresult res;                         \
       nsCOMPtr<nsIPluginHost> host(do_GetService(MOZ_PLUGIN_HOST_CONTRACTID, &res));\
       if(NS_SUCCEEDED(res) && (host != nsnull))\
         static_cast<nsPluginHost*>(host.get())->HandleBadPlugin(nsnull, pluginInst);\
     }                                       \
   }                                         \
   NS_NotifyPluginCall(startTime);		   \
--- a/dom/plugins/base/nsPluginStreamListenerPeer.cpp
+++ b/dom/plugins/base/nsPluginStreamListenerPeer.cpp
@@ -88,17 +88,17 @@ private:
 NS_IMPL_ISUPPORTS3(nsPluginByteRangeStreamListener,
                    nsIRequestObserver,
                    nsIStreamListener,
                    nsIInterfaceRequestor)
 
 nsPluginByteRangeStreamListener::nsPluginByteRangeStreamListener(nsIWeakReference* aWeakPtr)
 {
   mWeakPtrPluginStreamListenerPeer = aWeakPtr;
-  mRemoveMagicNumber = PR_FALSE;
+  mRemoveMagicNumber = false;
 }
 
 nsPluginByteRangeStreamListener::~nsPluginByteRangeStreamListener()
 {
   mStreamConverter = 0;
   mWeakPtrPluginStreamListenerPeer = 0;
 }
 
@@ -160,28 +160,28 @@ nsPluginByteRangeStreamListener::OnStart
   }
   
   if (responseCode != 200) {
     bool bWantsAllNetworkStreams = false;
     rv = pslp->GetPluginInstance()->GetValueFromPlugin(NPPVpluginWantsAllNetworkStreams,
                                                        &bWantsAllNetworkStreams);
     // If the call returned an error code make sure we still use our default value.
     if (NS_FAILED(rv)) {
-      bWantsAllNetworkStreams = PR_FALSE;
+      bWantsAllNetworkStreams = false;
     }
 
     if (!bWantsAllNetworkStreams){
       return NS_ERROR_FAILURE;
     }
   }
   
   // if server cannot continue with byte range (206 status) and sending us whole object (200 status)
   // reset this seekable stream & try serve it to plugin instance as a file
   mStreamConverter = finalStreamListener;
-  mRemoveMagicNumber = PR_TRUE;
+  mRemoveMagicNumber = true;
   
   rv = pslp->ServeStreamAsFile(request, ctxt);
   return rv;
 }
 
 NS_IMETHODIMP
 nsPluginByteRangeStreamListener::OnStopRequest(nsIRequest *request, nsISupports *ctxt,
                                                nsresult status)
@@ -224,17 +224,17 @@ nsPluginByteRangeStreamListener::OnStopR
 CachedFileHolder::CachedFileHolder(nsIFile* cacheFile)
 : mFile(cacheFile)
 {
   NS_ASSERTION(mFile, "Empty CachedFileHolder");
 }
 
 CachedFileHolder::~CachedFileHolder()
 {
-  mFile->Remove(PR_FALSE);
+  mFile->Remove(false);
 }
 
 void
 CachedFileHolder::AddRef()
 {
   ++mRefCnt;
   NS_LOG_ADDREF(this, mRefCnt, "CachedFileHolder", sizeof(*this));
 }
@@ -306,25 +306,25 @@ NS_IMPL_ISUPPORTS8(nsPluginStreamListene
                    nsIPluginStreamInfo,
                    nsINPAPIPluginStreamInfo,
                    nsIInterfaceRequestor,
                    nsIChannelEventSink)
 
 nsPluginStreamListenerPeer::nsPluginStreamListenerPeer()
 {
   mStreamType = NP_NORMAL;
-  mStartBinding = PR_FALSE;
-  mAbort = PR_FALSE;
-  mRequestFailed = PR_FALSE;
+  mStartBinding = false;
+  mAbort = false;
+  mRequestFailed = false;
   
   mPendingRequests = 0;
-  mHaveFiredOnStartRequest = PR_FALSE;
+  mHaveFiredOnStartRequest = false;
   mDataForwardToRequest = nsnull;
   
-  mSeekable = PR_FALSE;
+  mSeekable = false;
   mModified = 0;
   mStreamOffset = 0;
   mStreamComplete = 0;
 }
 
 nsPluginStreamListenerPeer::~nsPluginStreamListenerPeer()
 {
 #ifdef PLUGIN_LOGGING
@@ -366,17 +366,17 @@ nsresult nsPluginStreamListenerPeer::Ini
   
   mPluginInstance = aInstance;
 
   mPStreamListener = static_cast<nsNPAPIPluginStreamListener*>(aListener);
   mPStreamListener->SetStreamListenerPeer(this);
 
   mPendingRequests = 1;
   
-  mDataForwardToRequest = new nsHashtable(16, PR_FALSE);
+  mDataForwardToRequest = new nsHashtable(16, false);
   if (!mDataForwardToRequest)
     return NS_ERROR_FAILURE;
   
   return NS_OK;
 }
 
 /* Called by NewEmbeddedPluginStream() - if this is called, we weren't
  * able to load the plugin, so we need to load it later once we figure
@@ -403,17 +403,17 @@ nsresult nsPluginStreamListenerPeer::Ini
     NS_ASSERTION(mPluginInstance == nsnull, "nsPluginStreamListenerPeer::InitializeEmbedded mPluginInstance != nsnull");
     mPluginInstance = aInstance;
   } else {
     mOwner = aOwner;
   }
   
   mPendingRequests = 1;
   
-  mDataForwardToRequest = new nsHashtable(16, PR_FALSE);
+  mDataForwardToRequest = new nsHashtable(16, false);
   if (!mDataForwardToRequest)
     return NS_ERROR_FAILURE;
   
   return NS_OK;
 }
 
 // Called by NewFullPagePluginStream()
 nsresult nsPluginStreamListenerPeer::InitializeFullPage(nsIURI* aURL, nsNPAPIPluginInstance *aInstance)
@@ -421,17 +421,17 @@ nsresult nsPluginStreamListenerPeer::Ini
   PLUGIN_LOG(PLUGIN_LOG_NORMAL,
              ("nsPluginStreamListenerPeer::InitializeFullPage instance=%p\n",aInstance));
   
   NS_ASSERTION(mPluginInstance == nsnull, "nsPluginStreamListenerPeer::InitializeFullPage mPluginInstance != nsnull");
   mPluginInstance = aInstance;
   
   mURL = aURL;
   
-  mDataForwardToRequest = new nsHashtable(16, PR_FALSE);
+  mDataForwardToRequest = new nsHashtable(16, false);
   if (!mDataForwardToRequest)
     return NS_ERROR_FAILURE;
 
   mPendingRequests = 1;
   
   return NS_OK;
 }
 
@@ -529,47 +529,47 @@ nsPluginStreamListenerPeer::OnStartReque
                  "Only our initial stream should be unknown!");
     TrackRequest(request);
   }
   
   if (mHaveFiredOnStartRequest) {
     return NS_OK;
   }
   
-  mHaveFiredOnStartRequest = PR_TRUE;
+  mHaveFiredOnStartRequest = true;
   
   nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
   NS_ENSURE_TRUE(channel, NS_ERROR_FAILURE);
   
   // deal with 404 (Not Found) HTTP response,
   // just return, this causes the request to be ignored.
   nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
   if (httpChannel) {
     PRUint32 responseCode = 0;
     rv = httpChannel->GetResponseStatus(&responseCode);
     if (NS_FAILED(rv)) {
       // NPP_Notify() will be called from OnStopRequest
       // in nsNPAPIPluginStreamListener::CleanUpStream
       // return error will cancel this request
       // ...and we also need to tell the plugin that
-      mRequestFailed = PR_TRUE;
+      mRequestFailed = true;
       return NS_ERROR_FAILURE;
     }
     
     if (responseCode > 206) { // not normal
       bool bWantsAllNetworkStreams = false;
       rv = mPluginInstance->GetValueFromPlugin(NPPVpluginWantsAllNetworkStreams,
                                                &bWantsAllNetworkStreams);
       // If the call returned an error code make sure we still use our default value.
       if (NS_FAILED(rv)) {
-        bWantsAllNetworkStreams = PR_FALSE;
+        bWantsAllNetworkStreams = false;
       }
 
       if (!bWantsAllNetworkStreams) {
-        mRequestFailed = PR_TRUE;
+        mRequestFailed = true;
         return NS_ERROR_FAILURE;
       }
     }
   }
   
   // do a little sanity check to make sure our frame isn't gone
   // by getting the tag type and checking for an error, we can determine if
   // the frame is gone
@@ -599,17 +599,17 @@ nsPluginStreamListenerPeer::OnStartReque
   
   // it's possible for the server to not send a Content-Length.
   // we should still work in this case.
   if (NS_FAILED(rv) || length == -1) {
     // check out if this is file channel
     nsCOMPtr<nsIFileChannel> fileChannel = do_QueryInterface(channel);
     if (fileChannel) {
       // file does not exist
-      mRequestFailed = PR_TRUE;
+      mRequestFailed = true;
       return NS_ERROR_FAILURE;
     }
     mLength = 0;
   }
   else {
     mLength = length;
   }
   
@@ -750,17 +750,17 @@ nsPluginStreamListenerPeer::MakeByteRang
     string.AppendInt(range->offset + range->length - 1);
     if (range->next)
       string += ",";
     
     requestCnt++;
   }
   
   // get rid of possible trailing comma
-  string.Trim(",", PR_FALSE);
+  string.Trim(",", false);
   
   rangeRequest = string;
   *numRequests  = requestCnt;
   return;
 }
 
 NS_IMETHODIMP
 nsPluginStreamListenerPeer::RequestRead(NPByteRange* rangeList)
@@ -781,19 +781,19 @@ nsPluginStreamListenerPeer::RequestRead(
   rv = NS_NewChannel(getter_AddRefs(channel), mURL, nsnull, loadGroup, callbacks);
   if (NS_FAILED(rv))
     return rv;
   
   nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
   if (!httpChannel)
     return NS_ERROR_FAILURE;
   
-  httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("Range"), rangeString, PR_FALSE);
+  httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("Range"), rangeString, false);
   
-  mAbort = PR_TRUE; // instruct old stream listener to cancel
+  mAbort = true; // instruct old stream listener to cancel
   // the request on the next ODA.
   
   nsCOMPtr<nsIStreamListener> converter;
   
   if (numRequests == 1) {
     converter = this;
     // set current stream offset equal to the first offset in the range list
     // it will work for single byte range request
@@ -860,51 +860,51 @@ nsresult nsPluginStreamListenerPeer::Ser
     ((nsPluginNativeWindow*)window)->GetPluginWidget(getter_AddRefs(widget));
     if (widget) {
       window->window = widget->GetNativeData(NS_NATIVE_PLUGIN_PORT);
     }
 #endif
     owner->SetWindow();
   }
   
-  mSeekable = PR_FALSE;
+  mSeekable = false;
   mPStreamListener->OnStartBinding(this);
   mStreamOffset = 0;
   
   // force the plugin to use stream as file
   mStreamType = NP_ASFILE;
   
   // then check it out if browser cache is not available
   nsCOMPtr<nsICachingChannel> cacheChannel = do_QueryInterface(request);
-  if (!(cacheChannel && (NS_SUCCEEDED(cacheChannel->SetCacheAsFile(PR_TRUE))))) {
+  if (!(cacheChannel && (NS_SUCCEEDED(cacheChannel->SetCacheAsFile(true))))) {
     nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
     if (channel) {
       SetupPluginCacheFile(channel);
     }
   }
   
   // unset mPendingRequests
   mPendingRequests = 0;
   
   return NS_OK;
 }
 
 bool
 nsPluginStreamListenerPeer::UseExistingPluginCacheFile(nsPluginStreamListenerPeer* psi)
 {
-  NS_ENSURE_TRUE(psi, PR_FALSE);
+  NS_ENSURE_TRUE(psi, false);
   
   if (psi->mLength == mLength &&
       psi->mModified == mModified &&
       mStreamComplete &&
       mURLSpec.Equals(psi->mURLSpec))
   {
-    return PR_TRUE;
+    return true;
   }
-  return PR_FALSE;
+  return false;
 }
 
 NS_IMETHODIMP nsPluginStreamListenerPeer::OnDataAvailable(nsIRequest *request,
                                                           nsISupports* aContext,
                                                           nsIInputStream *aIStream,
                                                           PRUint32 sourceOffset,
                                                           PRUint32 aLength)
 {
@@ -917,17 +917,17 @@ NS_IMETHODIMP nsPluginStreamListenerPeer
   if (mAbort) {
     PRUint32 magicNumber = 0;  // set it to something that is not the magic number.
     nsCOMPtr<nsISupportsPRUint32> container = do_QueryInterface(aContext);
     if (container)
       container->GetData(&magicNumber);
     
     if (magicNumber != MAGIC_REQUEST_CONTEXT) {
       // this is not one of our range requests
-      mAbort = PR_FALSE;
+      mAbort = false;
       return NS_BINDING_ABORTED;
     }
   }
   
   nsresult rv = NS_OK;
   
   if (!mPStreamListener)
     return NS_ERROR_FAILURE;
@@ -1119,17 +1119,17 @@ NS_IMETHODIMP nsPluginStreamListenerPeer
     mPStreamListener->OnStopBinding(this, aStatus);
   } else {
     // OnStartBinding hasn't been called, so complete the action.
     mPStreamListener->OnStartBinding(this);
     mPStreamListener->OnStopBinding(this, aStatus);
   }
   
   if (NS_SUCCEEDED(aStatus)) {
-    mStreamComplete = PR_TRUE;
+    mStreamComplete = true;
   }
   
   return NS_OK;
 }
 
 nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIRequest *request,
                                                          nsIURI* aURL)
 {
@@ -1198,74 +1198,74 @@ nsresult nsPluginStreamListenerPeer::Set
       nsPrintfCString status(100, "HTTP%s %lu %s", ver.get(), statusNum,
                              statusText.get());
       static_cast<nsIHTTPHeaderListener*>(mPStreamListener)->StatusLine(status.get());
     }
 
     // Also provide all HTTP response headers to our listener.
     httpChannel->VisitResponseHeaders(this);
     
-    mSeekable = PR_FALSE;
+    mSeekable = false;
     // first we look for a content-encoding header. If we find one, we tell the
     // plugin that stream is not seekable, because the plugin always sees
     // uncompressed data, so it can't make meaningful range requests on a
     // compressed entity.  Also, we force the plugin to use
     // nsPluginStreamType_AsFile stream type and we have to save decompressed
     // file into local plugin cache, because necko cache contains original
     // compressed file.
     nsCAutoString contentEncoding;
     if (NS_SUCCEEDED(httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("Content-Encoding"),
                                                     contentEncoding))) {
-      useLocalCache = PR_TRUE;
+      useLocalCache = true;
     } else {
       // set seekability (seekable if the stream has a known length and if the
       // http server accepts byte ranges).
       PRUint32 length;
       GetLength(&length);
       if (length) {
         nsCAutoString range;
         if (NS_SUCCEEDED(httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("accept-ranges"), range)) &&
             range.Equals(NS_LITERAL_CSTRING("bytes"), nsCaseInsensitiveCStringComparator())) {
-          mSeekable = PR_TRUE;
+          mSeekable = true;
         }
       }
     }
     
     // we require a content len
     // get Last-Modified header for plugin info
     nsCAutoString lastModified;
     if (NS_SUCCEEDED(httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("last-modified"), lastModified)) &&
         !lastModified.IsEmpty()) {
       PRTime time64;
-      PR_ParseTimeString(lastModified.get(), PR_TRUE, &time64);  //convert string time to integer time
+      PR_ParseTimeString(lastModified.get(), true, &time64);  //convert string time to integer time
       
       // Convert PRTime to unix-style time_t, i.e. seconds since the epoch
       double fpTime;
       LL_L2D(fpTime, time64);
       mModified = (PRUint32)(fpTime * 1e-6 + 0.5);
     }
   }
   
   rv = mPStreamListener->OnStartBinding(this);
   
-  mStartBinding = PR_TRUE;
+  mStartBinding = true;
   
   if (NS_FAILED(rv))
     return rv;
   
   mPStreamListener->GetStreamType(&mStreamType);
   
   if (!useLocalCache && mStreamType >= NP_ASFILE) {
     // check it out if this is not a file channel.
     nsCOMPtr<nsIFileChannel> fileChannel = do_QueryInterface(request);
     if (!fileChannel) {
       // and browser cache is not available
       nsCOMPtr<nsICachingChannel> cacheChannel = do_QueryInterface(request);
-      if (!(cacheChannel && (NS_SUCCEEDED(cacheChannel->SetCacheAsFile(PR_TRUE))))) {
-        useLocalCache = PR_TRUE;
+      if (!(cacheChannel && (NS_SUCCEEDED(cacheChannel->SetCacheAsFile(true))))) {
+        useLocalCache = true;
       }
     }
   }
   
   if (useLocalCache) {
     SetupPluginCacheFile(channel);
   }
   
--- a/dom/plugins/base/nsPluginStreamListenerPeer.h
+++ b/dom/plugins/base/nsPluginStreamListenerPeer.h
@@ -128,21 +128,21 @@ private:
   nsresult SetupPluginCacheFile(nsIChannel* channel);
   nsresult GetInterfaceGlobal(const nsIID& aIID, void** result);
 
   nsCOMPtr<nsIURI> mURL;
   nsCString mURLSpec; // Have to keep this member because GetURL hands out char*
   nsCOMPtr<nsIPluginInstanceOwner> mOwner;
   nsRefPtr<nsNPAPIPluginStreamListener> mPStreamListener;
 
-  // Set to PR_TRUE if we request failed (like with a HTTP response of 404)
+  // Set to true if we request failed (like with a HTTP response of 404)
   bool                    mRequestFailed;
   
   /*
-   * Set to PR_TRUE after nsIPluginStreamListener::OnStartBinding() has
+   * Set to true after nsIPluginStreamListener::OnStartBinding() has
    * been called.  Checked in ::OnStopRequest so we can call the
    * plugin's OnStartBinding if, for some reason, it has not already
    * been called.
    */
   bool              mStartBinding;
   bool              mHaveFiredOnStartRequest;
   // these get passed to the plugin stream listener
   PRUint32                mLength;
--- a/dom/plugins/base/nsPluginTags.cpp
+++ b/dom/plugins/base/nsPluginTags.cpp
@@ -75,17 +75,17 @@ inline char* new_str(const char* str)
 nsPluginTag::nsPluginTag(nsPluginTag* aPluginTag)
 : mPluginHost(nsnull),
 mName(aPluginTag->mName),
 mDescription(aPluginTag->mDescription),
 mMimeTypes(aPluginTag->mMimeTypes),
 mMimeDescriptions(aPluginTag->mMimeDescriptions),
 mExtensions(aPluginTag->mExtensions),
 mLibrary(nsnull),
-mCanUnloadLibrary(PR_TRUE),
+mCanUnloadLibrary(true),
 mIsJavaPlugin(aPluginTag->mIsJavaPlugin),
 mIsNPRuntimeEnabledJavaPlugin(aPluginTag->mIsNPRuntimeEnabledJavaPlugin),
 mIsFlashPlugin(aPluginTag->mIsFlashPlugin),
 mFileName(aPluginTag->mFileName),
 mFullPath(aPluginTag->mFullPath),
 mVersion(aPluginTag->mVersion),
 mLastModifiedTime(0),
 mFlags(NS_PLUGIN_FLAG_ENABLED)
@@ -93,23 +93,23 @@ mFlags(NS_PLUGIN_FLAG_ENABLED)
 }
 
 nsPluginTag::nsPluginTag(nsPluginInfo* aPluginInfo)
 : mPluginHost(nsnull),
 mName(aPluginInfo->fName),
 mDescription(aPluginInfo->fDescription),
 mLibrary(nsnull),
 #ifdef XP_MACOSX
-mCanUnloadLibrary(PR_FALSE),
+mCanUnloadLibrary(false),
 #else
-mCanUnloadLibrary(PR_TRUE),
+mCanUnloadLibrary(true),
 #endif
-mIsJavaPlugin(PR_FALSE),
-mIsNPRuntimeEnabledJavaPlugin(PR_FALSE),
-mIsFlashPlugin(PR_FALSE),
+mIsJavaPlugin(false),
+mIsNPRuntimeEnabledJavaPlugin(false),
+mIsFlashPlugin(false),
 mFileName(aPluginInfo->fFileName),
 mFullPath(aPluginInfo->fFullPath),
 mVersion(aPluginInfo->fVersion),
 mLastModifiedTime(0),
 mFlags(NS_PLUGIN_FLAG_ENABLED)
 {
   if (!aPluginInfo->fMimeTypeArray) {
     return;
@@ -119,26 +119,26 @@ mFlags(NS_PLUGIN_FLAG_ENABLED)
     // First fill in the MIME types.
     char* currentMIMEType = aPluginInfo->fMimeTypeArray[i];
     if (currentMIMEType) {
       if (mIsJavaPlugin) {
         if (strcmp(currentMIMEType, "application/x-java-vm-npruntime") == 0) {
           // This "magic MIME type" should not be exposed, but is just a signal
           // to the browser that this is new-style java.
           // Don't add it or its associated information to our arrays.
-          mIsNPRuntimeEnabledJavaPlugin = PR_TRUE;
+          mIsNPRuntimeEnabledJavaPlugin = true;
           continue;
         }
       }
       mMimeTypes.AppendElement(nsCString(currentMIMEType));
       if (nsPluginHost::IsJavaMIMEType(currentMIMEType)) {
-        mIsJavaPlugin = PR_TRUE;
+        mIsJavaPlugin = true;
       }
       else if (strcmp(currentMIMEType, "application/x-shockwave-flash") == 0) {
-        mIsFlashPlugin = PR_TRUE;
+        mIsFlashPlugin = true;
       }
     } else {
       continue;
     }
 
     // Now fill in the MIME descriptions.
     if (aPluginInfo->fMimeDescriptionArray &&
         aPluginInfo->fMimeDescriptionArray[i]) {
@@ -192,35 +192,35 @@ nsPluginTag::nsPluginTag(const char* aNa
                          PRInt64 aLastModifiedTime,
                          bool aCanUnload,
                          bool aArgsAreUTF8)
 : mPluginHost(nsnull),
 mName(aName),
 mDescription(aDescription),
 mLibrary(nsnull),
 mCanUnloadLibrary(aCanUnload),
-mIsJavaPlugin(PR_FALSE),
-mIsNPRuntimeEnabledJavaPlugin(PR_FALSE),
+mIsJavaPlugin(false),
+mIsNPRuntimeEnabledJavaPlugin(false),
 mFileName(aFileName),
 mFullPath(aFullPath),
 mVersion(aVersion),
 mLastModifiedTime(aLastModifiedTime),
 mFlags(0) // Caller will read in our flags from cache
 {
   for (PRInt32 i = 0; i < aVariants; i++) {
     if (mIsJavaPlugin && aMimeTypes[i] &&
         strcmp(aMimeTypes[i], "application/x-java-vm-npruntime") == 0) {
-      mIsNPRuntimeEnabledJavaPlugin = PR_TRUE;
+      mIsNPRuntimeEnabledJavaPlugin = true;
       continue;
     }
     mMimeTypes.AppendElement(nsCString(aMimeTypes[i]));
     mMimeDescriptions.AppendElement(nsCString(aMimeDescriptions[i]));
     mExtensions.AppendElement(nsCString(aExtensions[i]));
     if (nsPluginHost::IsJavaMIMEType(mMimeTypes[i].get())) {
-      mIsJavaPlugin = PR_TRUE;
+      mIsJavaPlugin = true;
     }
   }
 
   if (!aArgsAreUTF8)
     EnsureMembersAreUTF8();
 }
 
 nsPluginTag::~nsPluginTag()
@@ -419,32 +419,32 @@ nsPluginTag::RegisterWithCategoryManager
       nsXPIDLCString value;
       if (NS_SUCCEEDED(catMan->GetCategoryEntry("Gecko-Content-Viewers",
                                                 mMimeTypes[i].get(),
                                                 getter_Copies(value)))) {
         // Only delete the entry if a plugin registered for it
         if (strcmp(value, contractId) == 0) {
           catMan->DeleteCategoryEntry("Gecko-Content-Viewers",
                                       mMimeTypes[i].get(),
-                                      PR_TRUE);
+                                      true);
         }
       }
     } else {
       overrideTypesFormatted.BeginReading(start);
       overrideTypesFormatted.EndReading(end);
       
       nsCAutoString commaSeparated; 
       commaSeparated.Assign(',');
       commaSeparated += mMimeTypes[i];
       commaSeparated.Append(',');
       if (!FindInReadable(commaSeparated, start, end)) {
         catMan->AddCategoryEntry("Gecko-Content-Viewers",
                                  mMimeTypes[i].get(),
                                  contractId,
-                                 PR_FALSE, /* persist: broken by bug 193031 */
+                                 false, /* persist: broken by bug 193031 */
                                  aOverrideInternalTypes, /* replace if we're told to */
                                  nsnull);
       }
     }
     
     PLUGIN_LOG(PLUGIN_LOG_NOISY,
                ("nsPluginTag::RegisterWithCategoryManager mime=%s, plugin=%s\n",
                 mMimeTypes[i].get(), mFileName.get()));
@@ -453,32 +453,32 @@ nsPluginTag::RegisterWithCategoryManager
 
 void nsPluginTag::Mark(PRUint32 mask)
 {
   bool wasEnabled = IsEnabled();
   mFlags |= mask;
   // Update entries in the category manager if necessary.
   if (mPluginHost && wasEnabled != IsEnabled()) {
     if (wasEnabled)
-      RegisterWithCategoryManager(PR_FALSE, nsPluginTag::ePluginUnregister);
+      RegisterWithCategoryManager(false, nsPluginTag::ePluginUnregister);
     else
-      RegisterWithCategoryManager(PR_FALSE, nsPluginTag::ePluginRegister);
+      RegisterWithCategoryManager(false, nsPluginTag::ePluginRegister);
   }
 }
 
 void nsPluginTag::UnMark(PRUint32 mask)
 {
   bool wasEnabled = IsEnabled();
   mFlags &= ~mask;
   // Update entries in the category manager if necessary.
   if (mPluginHost && wasEnabled != IsEnabled()) {
     if (wasEnabled)
-      RegisterWithCategoryManager(PR_FALSE, nsPluginTag::ePluginUnregister);
+      RegisterWithCategoryManager(false, nsPluginTag::ePluginUnregister);
     else
-      RegisterWithCategoryManager(PR_FALSE, nsPluginTag::ePluginRegister);
+      RegisterWithCategoryManager(false, nsPluginTag::ePluginRegister);
   }
 }
 
 bool nsPluginTag::HasFlag(PRUint32 flag)
 {
   return (mFlags & flag) != 0;
 }
 
@@ -489,31 +489,31 @@ PRUint32 nsPluginTag::Flags()
 
 bool nsPluginTag::IsEnabled()
 {
   return HasFlag(NS_PLUGIN_FLAG_ENABLED) && !HasFlag(NS_PLUGIN_FLAG_BLOCKLISTED);
 }
 
 bool nsPluginTag::Equals(nsPluginTag *aPluginTag)
 {
-  NS_ENSURE_TRUE(aPluginTag, PR_FALSE);
+  NS_ENSURE_TRUE(aPluginTag, false);
   
   if ((!mName.Equals(aPluginTag->mName)) ||
       (!mDescription.Equals(aPluginTag->mDescription)) ||
       (mMimeTypes.Length() != aPluginTag->mMimeTypes.Length())) {
-    return PR_FALSE;
+    return false;
   }
 
   for (PRUint32 i = 0; i < mMimeTypes.Length(); i++) {
     if (!mMimeTypes[i].Equals(aPluginTag->mMimeTypes[i])) {
-      return PR_FALSE;
+      return false;
     }
   }
 
-  return PR_TRUE;
+  return true;
 }
 
 void nsPluginTag::TryUnloadPlugin()
 {
   if (mEntryPoint) {
     mEntryPoint->Shutdown();
     mEntryPoint = nsnull;
   }
@@ -528,11 +528,11 @@ void nsPluginTag::TryUnloadPlugin()
   // CleanUnsedLibraries before we need to call the library
   // again so the calling code should not be fooled and reload
   // the library fresh
   mLibrary = nsnull;
   
   // Remove mime types added to the category manager
   // only if we were made 'active' by setting the host
   if (mPluginHost) {
-    RegisterWithCategoryManager(PR_FALSE, nsPluginTag::ePluginUnregister);
+    RegisterWithCategoryManager(false, nsPluginTag::ePluginUnregister);
   }
 }
--- a/dom/plugins/base/nsPluginsDirDarwin.cpp
+++ b/dom/plugins/base/nsPluginsDirDarwin.cpp
@@ -109,19 +109,19 @@ bool nsPluginsDir::IsPluginFile(nsIFile*
   nsCString fileName;
   file->GetNativeLeafName(fileName);
   /*
    * Don't load the VDP fake plugin, to avoid tripping a bad bug in OS X
    * 10.5.3 (see bug 436575).
    */
   if (!strcmp(fileName.get(), "VerifiedDownloadPlugin.plugin")) {
     NS_WARNING("Preventing load of VerifiedDownloadPlugin.plugin (see bug 436575)");
-    return PR_FALSE;
+    return false;
   }
-  return PR_TRUE;
+  return true;
 }
 
 // Caller is responsible for freeing returned buffer.
 static char* CFStringRefToUTF8Buffer(CFStringRef cfString)
 {
   const char* buffer = ::CFStringGetCStringPtr(cfString, kCFStringEncodingUTF8);
   if (buffer) {
     return PL_strdup(buffer);
@@ -387,17 +387,17 @@ static char* GetNextPluginStringFromHand
   *index += (ret ? PL_strlen(ret) : 0) + 1;
   return ret;
 }
 
 static bool IsCompatibleArch(nsIFile *file)
 {
   CFURLRef pluginURL = NULL;
   if (NS_FAILED(toCFURLRef(file, pluginURL)))
-    return PR_FALSE;
+    return false;
   
   bool isPluginFile = false;
 
   CFBundleRef pluginBundle = ::CFBundleCreate(kCFAllocatorDefault, pluginURL);
   if (pluginBundle) {
     UInt32 packageType, packageCreator;
     ::CFBundleGetPackageInfo(pluginBundle, &packageType, &packageCreator);
     if (packageType == 'BRPL' || packageType == 'IEPL' || packageType == 'NSPL') {
@@ -406,17 +406,17 @@ static bool IsCompatibleArch(nsIFile *fi
       executablePath[0] = '\0';
       if (!::CFURLGetFileSystemRepresentation(pluginURL, true, (UInt8*)&executablePath, PATH_MAX)) {
         executablePath[0] = '\0';
       }
 
       uint32 pluginLibArchitectures;
       nsresult rv = mozilla::ipc::GeckoChildProcessHost::GetArchitecturesForBinary(executablePath, &pluginLibArchitectures);
       if (NS_FAILED(rv)) {
-        return PR_FALSE;
+        return false;
       }
 
       uint32 containerArchitectures = mozilla::ipc::GeckoChildProcessHost::GetSupportedArchitecturesForProcessType(GeckoProcessType_Plugin);
 
       // Consider the plugin architecture valid if there is any overlap in the masks.
       isPluginFile = !!(containerArchitectures & pluginLibArchitectures);
     }
     ::CFRelease(pluginBundle);
--- a/dom/plugins/base/nsPluginsDirOS2.cpp
+++ b/dom/plugins/base/nsPluginsDirOS2.cpp
@@ -167,31 +167,31 @@ static void FreeStringArray(PRUint32 var
 }
 
 // nsPluginsDir class
 
 bool nsPluginsDir::IsPluginFile(nsIFile* file)
 {
     nsCAutoString leaf;
     if (NS_FAILED(file->GetNativeLeafName(leaf)))
-        return PR_FALSE;
+        return false;
 
     const char *leafname = leaf.get();
     
     if( nsnull != leafname)
     {
       int len = strlen( leafname);
       if( len > 6 &&                 // np*.dll
           (0 == strnicmp( &(leafname[len - 4]), ".dll", 4)) &&
           (0 == strnicmp( leafname, "np", 2)))
       {
-        return PR_TRUE;
+        return true;
       }
     }
-    return PR_FALSE;
+    return false;
 }
 
 // nsPluginFile implementation
 
 nsPluginFile::nsPluginFile(nsIFile* file)
 : mPlugin(file)
 {}
 
--- a/dom/plugins/base/nsPluginsDirUnix.cpp
+++ b/dom/plugins/base/nsPluginsDirUnix.cpp
@@ -116,22 +116,22 @@ static bool LoadExtraSharedLib(const cha
 {
     bool ret = true;
     PRLibSpec tempSpec;
     PRLibrary *handle;
     tempSpec.type = PR_LibSpec_Pathname;
     tempSpec.value.pathname = name;
     handle = PR_LoadLibraryWithFlags(tempSpec, PR_LD_NOW|PR_LD_GLOBAL);
     if (!handle) {
-        ret = PR_FALSE;
+        ret = false;
         DisplayPR_LoadLibraryErrorMessage(name);
         if (tryToGetSoname) {
             SearchForSoname(name, soname);
             if (*soname) {
-                ret = LoadExtraSharedLib((const char *) *soname, NULL, PR_FALSE);
+                ret = LoadExtraSharedLib((const char *) *soname, NULL, false);
             }
         }
     }
     return ret;
 }
 
 #define PLUGIN_MAX_NUMBER_OF_EXTRA_LIBS 32
 #define PREF_PLUGINS_SONAME "plugin.soname.list"
@@ -153,17 +153,17 @@ static void LoadExtraSharedLibs()
     nsresult res;
     nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID, &res));
     if (NS_SUCCEEDED(res) && (prefs != nsnull)) {
         char *sonameList = NULL;
         bool prefSonameListIsSet = true;
         res = prefs->GetCharPref(PREF_PLUGINS_SONAME, &sonameList);
         if (!sonameList) {
             // pref is not set, lets use hardcoded list
-            prefSonameListIsSet = PR_FALSE;
+            prefSonameListIsSet = false;
             sonameList = PL_strdup(DEFAULT_EXTRA_LIBS_LIST);
         }
         if (sonameList) {
             char *arrayOfLibs[PLUGIN_MAX_NUMBER_OF_EXTRA_LIBS] = {0};
             int numOfLibs = 0;
             char *nextToken;
             char *p = nsCRT::strtok(sonameList,":",&nextToken);
             if (p) {
@@ -182,32 +182,32 @@ static void LoadExtraSharedLibs()
                 while (*p) {
                     if (*p == ' ' || *p == '\t') {
                         if (head) {
                             arrayOfLibs[i] = ++p;
                         } else {
                             *p = 0;
                         }
                     } else {
-                        head = PR_FALSE;
+                        head = false;
                         p++;
                     }
                 }
                 if (!arrayOfLibs[i][0]) {
                     continue; // null string
                 }
                 bool tryToGetSoname = true;
                 if (PL_strchr(arrayOfLibs[i], '/')) {
                     //assuming it's real name, try to stat it
                     struct stat st;
                     if (stat((const char*) arrayOfLibs[i], &st)) {
                         //get just a file name
                         arrayOfLibs[i] = PL_strrchr(arrayOfLibs[i], '/') + 1;
                     } else
-                        tryToGetSoname = PR_FALSE;
+                        tryToGetSoname = false;
                 }
                 char *soname = NULL;
                 if (LoadExtraSharedLib(arrayOfLibs[i], &soname, tryToGetSoname)) {
                     //construct soname's list to save in prefs
                     p = soname ? soname : arrayOfLibs[i];
                     int n = PLUGIN_MAX_LEN_OF_TMP_ARR -
                         (PL_strlen(sonameListToSave) + PL_strlen(p));
                     if (n > 0) {
@@ -240,40 +240,40 @@ static void LoadExtraSharedLibs()
 #endif //MOZ_WIDGET_GTK2
 
 /* nsPluginsDir implementation */
 
 bool nsPluginsDir::IsPluginFile(nsIFile* file)
 {
     nsCAutoString filename;
     if (NS_FAILED(file->GetNativeLeafName(filename)))
-        return PR_FALSE;
+        return false;
 
 #ifdef ANDROID
     // It appears that if you load
     // 'libstagefright_honeycomb.so' on froyo, or
     // 'libstagefright_froyo.so' on honeycomb, we will abort.
     // Since these are just helper libs, we can ignore.
     const char *cFile = filename.get();
     if (strstr(cFile, "libstagefright") != NULL)
-        return PR_FALSE;
+        return false;
 #endif
 
     NS_NAMED_LITERAL_CSTRING(dllSuffix, LOCAL_PLUGIN_DLL_SUFFIX);
     if (filename.Length() > dllSuffix.Length() &&
         StringEndsWith(filename, dllSuffix))
-        return PR_TRUE;
+        return true;
     
 #ifdef LOCAL_PLUGIN_DLL_ALT_SUFFIX
     NS_NAMED_LITERAL_CSTRING(dllAltSuffix, LOCAL_PLUGIN_DLL_ALT_SUFFIX);
     if (filename.Length() > dllAltSuffix.Length() &&
         StringEndsWith(filename, dllAltSuffix))
-        return PR_TRUE;
+        return true;
 #endif
-    return PR_FALSE;
+    return false;
 }
 
 /* nsPluginFile implementation */
 
 nsPluginFile::nsPluginFile(nsIFile* file)
 : mPlugin(file)
 {
 }
--- a/dom/plugins/base/nsPluginsDirWin.cpp
+++ b/dom/plugins/base/nsPluginsDirWin.cpp
@@ -203,28 +203,28 @@ static bool CanLoadPlugin(const PRUnicha
       CloseHandle(map);
     }
     CloseHandle(file);
   }
 
   return canLoad;
 #else
   // Assume correct binaries for unhandled cases.
-  return PR_TRUE;
+  return true;
 #endif
 }
 
 /* nsPluginsDir implementation */
 
 // The file name must be in the form "np*.dll"
 bool nsPluginsDir::IsPluginFile(nsIFile* file)
 {
   nsCAutoString path;
   if (NS_FAILED(file->GetNativePath(path)))
-    return PR_FALSE;
+    return false;
 
   const char *cPath = path.get();
 
   // this is most likely a path, so skip to the filename
   const char* filename = PL_strrchr(cPath, '\\');
   if (filename)
     ++filename;
   else
@@ -236,22 +236,22 @@ bool nsPluginsDir::IsPluginFile(nsIFile*
 
   PRUint32 fullLength = PL_strlen(filename);
   PRUint32 extLength = PL_strlen(extension);
   if (fullLength >= 7 && extLength == 3) {
     if (!PL_strncasecmp(filename, "np", 2) && !PL_strncasecmp(extension, "dll", 3)) {
       // don't load OJI-based Java plugins
       if (!PL_strncasecmp(filename, "npoji", 5) ||
           !PL_strncasecmp(filename, "npjava", 6))
-        return PR_FALSE;
-      return PR_TRUE;
+        return false;
+      return true;
     }
   }
 
-  return PR_FALSE;
+  return false;
 }
 
 /* nsPluginFile implementation */
 
 nsPluginFile::nsPluginFile(nsIFile* file)
 : mPlugin(file)
 {
   // nada
@@ -278,17 +278,17 @@ nsresult nsPluginFile::LoadPlugin(PRLibr
   nsAutoString pluginFolderPath;
   plugin->GetPath(pluginFolderPath);
 
   PRInt32 idx = pluginFolderPath.RFindChar('\\');
   if (kNotFound == idx)
     return NS_ERROR_FILE_INVALID_PATH;
 
   if (Substring(pluginFolderPath, idx).LowerCaseEqualsLiteral("\\np32dsw.dll")) {
-    protectCurrentDirectory = PR_FALSE;
+    protectCurrentDirectory = false;
   }
 
   pluginFolderPath.SetLength(idx);
 
   BOOL restoreOrigDir = FALSE;
   WCHAR aOrigDir[MAX_PATH + 1];
   DWORD dwCheck = GetCurrentDirectoryW(MAX_PATH, aOrigDir);
   NS_ASSERTION(dwCheck <= MAX_PATH + 1, "Error in Loading plugin");