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 79234 7558f15d82410a11cb9ecf4f6bcd0764854e66ee
parent 79233 b5b082d183d0a3913b93ff3d8dd7f759c56894d4
child 79235 98bb04b061d2dfc29e848390e55d8f23486a7334
push id434
push userclegnitto@mozilla.com
push dateWed, 21 Dec 2011 12:10:54 +0000
treeherdermozilla-beta@bddb6ed8dd47 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjst
bugs690459
milestone10.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 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");