Bug 690834: Replace PR_TRUE and PR_FALSE with true and false in in plugin code outside of dom/plugins. r=roc
authorJosh Aas <joshmoz@gmail.com>
Sat, 01 Oct 2011 11:43:07 -0400
changeset 77959 31bad59be74f68070ccf1ca166b048b771ae94e7
parent 77958 164fd1bbd06f7e1e0f501469043d53f703e3039b
child 77960 cc1ac56df6ae891c72d1497cc389d8bf763ff41b
push id2320
push userjosh@mozilla.com
push dateSat, 01 Oct 2011 15:43:45 +0000
treeherdermozilla-inbound@31bad59be74f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersroc
bugs690834
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 690834: Replace PR_TRUE and PR_FALSE with true and false in in plugin code outside of dom/plugins. r=roc
content/base/src/nsObjectLoadingContent.cpp
layout/generic/nsObjectFrame.cpp
--- a/content/base/src/nsObjectLoadingContent.cpp
+++ b/content/base/src/nsObjectLoadingContent.cpp
@@ -161,17 +161,17 @@ nsAsyncInstantiateEvent::Run()
         mURI->GetSpec(spec);
       }
       LOG(("OBJLC [%p]: Handling Instantiate event: Type=<%s> URI=%p<%s>\n",
            mContent, mContentType.get(), mURI.get(), spec.get()));
     }
 
     nsresult rv = mContent->Instantiate(frame, mContentType, mURI);
     if (NS_FAILED(rv)) {
-      mContent->Fallback(PR_TRUE);
+      mContent->Fallback(true);
     }
   } else {
     LOG(("OBJLC [%p]: Discarding event, data changed\n", mContent));
   }
 
   return NS_OK;
 }
 
@@ -211,17 +211,17 @@ nsPluginErrorEvent::Run()
       break;
     case ePluginOutdated:
       type = NS_LITERAL_STRING("PluginOutdated");
       break;
     default:
       return NS_OK;
   }
   nsContentUtils::DispatchTrustedEvent(mContent->GetDocument(), mContent,
-                                       type, PR_TRUE, PR_TRUE);
+                                       type, true, true);
 
   return NS_OK;
 }
 
 /**
  * A task for firing PluginCrashed DOM Events.
  */
 class nsPluginCrashedEvent : public nsRunnable {
@@ -270,18 +270,18 @@ nsPluginCrashedEvent::Run()
                       getter_AddRefs(event));
   nsCOMPtr<nsIPrivateDOMEvent> privateEvent(do_QueryInterface(event));
   nsCOMPtr<nsIDOMDataContainerEvent> containerEvent(do_QueryInterface(event));
   if (!privateEvent || !containerEvent) {
     NS_WARNING("Couldn't QI event for PluginCrashed event!");
     return NS_OK;
   }
 
-  event->InitEvent(NS_LITERAL_STRING("PluginCrashed"), PR_TRUE, PR_TRUE);
-  privateEvent->SetTrusted(PR_TRUE);
+  event->InitEvent(NS_LITERAL_STRING("PluginCrashed"), true, true);
+  privateEvent->SetTrusted(true);
   privateEvent->GetInternalNSEvent()->flags |= NS_EVENT_FLAG_ONLY_CHROME_DISPATCH;
   
   nsCOMPtr<nsIWritableVariant> variant;
 
   // add a "pluginDumpID" property to this event
   variant = do_CreateInstance("@mozilla.org/variant;1");
   if (!variant) {
     NS_WARNING("Couldn't create pluginDumpID variant for PluginCrashed event!");
@@ -333,28 +333,28 @@ nsPluginCrashedEvent::Run()
 class AutoNotifier {
   public:
     AutoNotifier(nsObjectLoadingContent* aContent, bool aNotify) :
       mContent(aContent), mNotify(aNotify) {
         mOldType = aContent->Type();
         mOldState = aContent->ObjectState();
     }
     ~AutoNotifier() {
-      mContent->NotifyStateChanged(mOldType, mOldState, PR_FALSE, mNotify);
+      mContent->NotifyStateChanged(mOldType, mOldState, false, mNotify);
     }
 
     /**
      * Send notifications now, ignoring the value of mNotify. The new type and
      * state is saved, and the destructor will notify again if mNotify is true
      * and the values changed.
      */
     void Notify() {
       NS_ASSERTION(mNotify, "Should not notify when notify=false");
 
-      mContent->NotifyStateChanged(mOldType, mOldState, PR_TRUE, PR_TRUE);
+      mContent->NotifyStateChanged(mOldType, mOldState, true, true);
       mOldType = mContent->Type();
       mOldState = mContent->ObjectState();
     }
 
   private:
     nsObjectLoadingContent*            mContent;
     bool                               mNotify;
     nsObjectLoadingContent::ObjectType mOldType;
@@ -367,17 +367,17 @@ class AutoNotifier {
  */
 class AutoFallback {
   public:
     AutoFallback(nsObjectLoadingContent* aContent, const nsresult* rv)
       : mContent(aContent), mResult(rv), mPluginState(ePluginOtherState) {}
     ~AutoFallback() {
       if (NS_FAILED(*mResult)) {
         LOG(("OBJLC [%p]: rv=%08x, falling back\n", mContent, *mResult));
-        mContent->Fallback(PR_FALSE);
+        mContent->Fallback(false);
         if (mPluginState != ePluginOtherState) {
           mContent->mFallbackReason = mPluginState;
         }
       }
     }
 
     /**
      * This should be set to something other than ePluginOtherState to indicate
@@ -395,42 +395,42 @@ class AutoFallback {
 
 /**
  * A class that automatically sets mInstantiating to false when it goes
  * out of scope.
  */
 class AutoSetInstantiatingToFalse {
   public:
     AutoSetInstantiatingToFalse(nsObjectLoadingContent* objlc) : mContent(objlc) {}
-    ~AutoSetInstantiatingToFalse() { mContent->mInstantiating = PR_FALSE; }
+    ~AutoSetInstantiatingToFalse() { mContent->mInstantiating = false; }
   private:
     nsObjectLoadingContent* mContent;
 };
 
 // helper functions
 static bool
 IsSupportedImage(const nsCString& aMimeType)
 {
   imgILoader* loader = nsContentUtils::GetImgLoader();
   if (!loader) {
-    return PR_FALSE;
+    return false;
   }
 
   bool supported;
   nsresult rv = loader->SupportImageWithMimeType(aMimeType.get(), &supported);
   return NS_SUCCEEDED(rv) && supported;
 }
 
 static bool
 IsSupportedPlugin(const nsCString& aMIMEType)
 {
   nsCOMPtr<nsIPluginHost> pluginHostCOM(do_GetService(MOZ_PLUGIN_HOST_CONTRACTID));
   nsPluginHost *pluginHost = static_cast<nsPluginHost*>(pluginHostCOM.get());
   if (!pluginHost) {
-    return PR_FALSE;
+    return false;
   }
   nsresult rv = pluginHost->IsPluginEnabledForType(aMIMEType.get());
   return NS_SUCCEEDED(rv);
 }
 
 static void
 GetExtensionFromURI(nsIURI* uri, nsCString& ext)
 {
@@ -454,41 +454,41 @@ GetExtensionFromURI(nsIURI* uri, nsCStri
  */
 static bool
 IsPluginEnabledByExtension(nsIURI* uri, nsCString& mimeType)
 {
   nsCAutoString ext;
   GetExtensionFromURI(uri, ext);
 
   if (ext.IsEmpty()) {
-    return PR_FALSE;
+    return false;
   }
 
   nsCOMPtr<nsIPluginHost> pluginHostCOM(do_GetService(MOZ_PLUGIN_HOST_CONTRACTID));
   nsPluginHost *pluginHost = static_cast<nsPluginHost*>(pluginHostCOM.get());
   if (!pluginHost) {
-    return PR_FALSE;
+    return false;
   }
 
   const char* typeFromExt;
   if (NS_SUCCEEDED(pluginHost->IsPluginEnabledForExtension(ext.get(), typeFromExt))) {
     mimeType = typeFromExt;
-    return PR_TRUE;
+    return true;
   }
-  return PR_FALSE;
+  return false;
 }
 
 nsObjectLoadingContent::nsObjectLoadingContent()
   : mPendingInstantiateEvent(nsnull)
   , mChannel(nsnull)
   , mType(eType_Loading)
-  , mInstantiating(PR_FALSE)
-  , mUserDisabled(PR_FALSE)
-  , mSuppressed(PR_FALSE)
-  , mNetworkCreated(PR_TRUE)
+  , mInstantiating(false)
+  , mUserDisabled(false)
+  , mSuppressed(false)
+  , mNetworkCreated(true)
   , mFallbackReason(ePluginOtherState)
 {
 }
 
 nsObjectLoadingContent::~nsObjectLoadingContent()
 {
   DestroyImageLoadingContent();
   if (mFrameLoader) {
@@ -502,21 +502,21 @@ nsObjectLoadingContent::OnStartRequest(n
                                        nsISupports *aContext)
 {
   if (aRequest != mChannel) {
     // This is a bit of an edge case - happens when a new load starts before the
     // previous one got here
     return NS_BINDING_ABORTED;
   }
 
-  AutoNotifier notifier(this, PR_TRUE);
+  AutoNotifier notifier(this, true);
 
   if (!IsSuccessfulRequest(aRequest)) {
     LOG(("OBJLC [%p]: OnStartRequest: Request failed\n", this));
-    Fallback(PR_FALSE);
+    Fallback(false);
     return NS_BINDING_ABORTED;
   }
 
   nsCOMPtr<nsIChannel> chan(do_QueryInterface(aRequest));
   NS_ASSERTION(chan, "Why is our request not a channel?");
 
   nsresult rv = NS_ERROR_UNEXPECTED;
   // This fallback variable MUST be declared after the notifier variable. Do NOT
@@ -593,17 +593,17 @@ nsObjectLoadingContent::OnStartRequest(n
       break;
   }
   nsCOMPtr<nsIContent> thisContent = 
     do_QueryInterface(static_cast<nsIImageLoadingContent*>(this));
   NS_ASSERTION(thisContent, "must be a content");
 
   nsIDocument* doc = thisContent->GetOwnerDoc();
   if (!doc) {
-    Fallback(PR_FALSE);
+    Fallback(false);
     return NS_BINDING_ABORTED;    
   }
 
   PRInt16 shouldProcess = nsIContentPolicy::ACCEPT;
   rv =
     NS_CheckContentProcessPolicy(contentPolicyType,
                                  uri,
                                  doc->NodePrincipal(),
@@ -635,24 +635,24 @@ nsObjectLoadingContent::OnStartRequest(n
         mType = newType;
         return NS_BINDING_ABORTED;
       }
       break;
     case eType_Document: {
       if (!mFrameLoader) {
         mFrameLoader = nsFrameLoader::Create(thisContent, mNetworkCreated);
         if (!mFrameLoader) {
-          Fallback(PR_FALSE);
+          Fallback(false);
           return NS_ERROR_UNEXPECTED;
         }
       }
 
       rv = mFrameLoader->CheckForRecursiveLoad(uri);
       if (NS_FAILED(rv)) {
-        Fallback(PR_FALSE);
+        Fallback(false);
         return rv;
       }
 
       if (mType != newType) {
         // XXX We must call this before getting the docshell to work around
         // bug 300540; when that's fixed, this if statement can be removed.
         mType = newType;
         notifier.Notify();
@@ -682,56 +682,56 @@ nsObjectLoadingContent::OnStartRequest(n
       nsCOMPtr<nsIURILoader>
         uriLoader(do_GetService(NS_URI_LOADER_CONTRACTID, &rv));
       NS_ENSURE_SUCCESS(rv, rv);
       rv = uriLoader->OpenChannel(chan, nsIURILoader::DONT_RETARGET, req,
                                   getter_AddRefs(mFinalListener));
       break;
     }
     case eType_Plugin:
-      mInstantiating = PR_TRUE;
+      mInstantiating = true;
       if (mType != newType) {
         // This can go away once plugin loading moves to content (bug 90268)
         mType = newType;
         notifier.Notify();
       }
       nsIObjectFrame* frame;
       frame = GetExistingFrame(eFlushLayout);
       if (!frame) {
         // Do nothing in this case: This is probably due to a display:none
         // frame. If we ever get a frame, HasNewFrame will do the right thing.
         // Abort the load though, we have no use for the data.
-        mInstantiating = PR_FALSE;
+        mInstantiating = false;
         return NS_BINDING_ABORTED;
       }
 
       {
         nsIFrame *nsiframe = do_QueryFrame(frame);
 
         nsWeakFrame weakFrame(nsiframe);
 
         rv = frame->Instantiate(chan, getter_AddRefs(mFinalListener));
 
-        mInstantiating = PR_FALSE;
+        mInstantiating = false;
 
         if (!weakFrame.IsAlive()) {
           // The frame was destroyed while instantiating. Abort the load.
           return NS_BINDING_ABORTED;
         }
       }
 
       break;
     case eType_Loading:
       NS_NOTREACHED("Should not have a loading type here!");
     case eType_Null:
       LOG(("OBJLC [%p]: Unsupported type, falling back\n", this));
       // Need to fallback here (instead of using the case below), so that we can
       // set mFallbackReason without it being overwritten. This is also why we
       // return early.
-      Fallback(PR_FALSE);
+      Fallback(false);
 
       PluginSupportState pluginState = GetPluginSupportState(thisContent,
                                                              mContentType);
       // Do nothing, but fire the plugin not found event if needed
       if (pluginState != ePluginOtherState) {
         mFallbackReason = pluginState;
         FirePluginError(thisContent, pluginState);
       }
@@ -748,31 +748,31 @@ nsObjectLoadingContent::OnStartRequest(n
       // Shockwave on Mac is special and returns an error here even when it
       // handles the content
       if (mContentType.EqualsLiteral("application/x-director")) {
         LOG(("OBJLC [%p]: (ignoring)\n", this));
         rv = NS_OK; // otherwise, the AutoFallback will make us fall back
         return NS_BINDING_ABORTED;
       }
 #endif
-      Fallback(PR_FALSE);
+      Fallback(false);
     } else if (mType == eType_Plugin) {
       nsIObjectFrame* frame = GetExistingFrame(eFlushContent);
       if (frame) {
         // We have to notify the wrapper here instead of right after
         // Instantiate because the plugin only gets instantiated by
         // OnStartRequest, not by Instantiate.
         frame->TryNotifyContentObjectWrapper();
       }
     }
     return rv;
   }
 
   LOG(("OBJLC [%p]: Found no listener, falling back\n", this));
-  Fallback(PR_FALSE);
+  Fallback(false);
   return NS_BINDING_ABORTED;
 }
 
 NS_IMETHODIMP
 nsObjectLoadingContent::OnStopRequest(nsIRequest *aRequest,
                                       nsISupports *aContext,
                                       nsresult aStatusCode)
 {
@@ -869,32 +869,32 @@ nsObjectLoadingContent::EnsureInstantiat
   } else {
     // mInstantiating is true if we're in LoadObject; we shouldn't
     // recreate frames in that case, we'd confuse that function.
     if (mInstantiating) {
       return NS_OK;
     }
 
     // Trigger frame construction
-    mInstantiating = PR_TRUE;
+    mInstantiating = true;
 
     nsCOMPtr<nsIContent> thisContent = 
       do_QueryInterface(static_cast<nsIImageLoadingContent*>(this));
     NS_ASSERTION(thisContent, "must be a content");
 
     nsIDocument* doc = thisContent->GetCurrentDoc();
     if (!doc) {
       // Nothing we can do while plugin loading is done in layout...
-      mInstantiating = PR_FALSE;
+      mInstantiating = false;
       return NS_OK;
     }
 
     doc->FlushPendingNotifications(Flush_Frames);
 
-    mInstantiating = PR_FALSE;
+    mInstantiating = false;
 
     frame = GetExistingFrame(eFlushContent);
     if (!frame) {
       return NS_OK;
     }
   }
 
   nsIFrame *nsiframe = do_QueryFrame(frame);
@@ -917,17 +917,17 @@ nsObjectLoadingContent::EnsureInstantiat
 
   // We may have a plugin instance already; if so, do nothing
   nsresult rv = frame->GetPluginInstance(aInstance);
   if (!*aInstance && weakFrame.IsAlive()) {
     rv = Instantiate(frame, mContentType, mURI);
     if (NS_SUCCEEDED(rv) && weakFrame.IsAlive()) {
       rv = frame->GetPluginInstance(aInstance);
     } else {
-      Fallback(PR_TRUE);
+      Fallback(true);
     }
   }
   return rv;
 }
 
 NS_IMETHODIMP
 nsObjectLoadingContent::HasNewFrame(nsIObjectFrame* aFrame)
 {
@@ -1168,20 +1168,20 @@ nsObjectLoadingContent::LoadObject(nsIUR
   }
 
   AutoNotifier notifier(this, aNotify);
 
   // AutoSetInstantiatingToFalse is instantiated after AutoNotifier, so that if
   // the AutoNotifier triggers frame construction, events can be posted as
   // appropriate.
   NS_ASSERTION(!mInstantiating, "LoadObject was reentered?");
-  mInstantiating = PR_TRUE;
+  mInstantiating = true;
   AutoSetInstantiatingToFalse autoset(this);
 
-  mUserDisabled = mSuppressed = PR_FALSE;
+  mUserDisabled = mSuppressed = false;
 
   mURI = aURI;
   mContentType = aTypeHint;
 
   nsCOMPtr<nsIContent> thisContent = 
     do_QueryInterface(static_cast<nsIImageLoadingContent*>(this));
   NS_ASSERTION(thisContent, "must be a content");
 
@@ -1208,32 +1208,32 @@ nsObjectLoadingContent::LoadObject(nsIUR
       mFinalListener = nsnull;
     }
     mChannel = nsnull;
   }
 
   // Security checks
   if (doc->IsLoadedAsData()) {
     if (!doc->IsStaticDocument()) {
-      Fallback(PR_FALSE);
+      Fallback(false);
     }
     return NS_OK;
   }
 
   // Can't do security checks without a URI - hopefully the plugin will take
   // care of that
   // Null URIs happen when the URL to load is specified via other means than the
   // data/src attribute, for example via custom <param> elements.
   if (aURI) {
     nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
     NS_ASSERTION(secMan, "No security manager!?");
     nsresult rv =
       secMan->CheckLoadURIWithPrincipal(thisContent->NodePrincipal(), aURI, 0);
     if (NS_FAILED(rv)) {
-      Fallback(PR_FALSE);
+      Fallback(false);
       return NS_OK;
     }
 
     PRInt16 shouldLoad = nsIContentPolicy::ACCEPT; // default permit
     rv =
       NS_CheckContentLoadPolicy(nsIContentPolicy::TYPE_OBJECT,
                                 aURI,
                                 doc->NodePrincipal(),
@@ -1291,17 +1291,17 @@ nsObjectLoadingContent::LoadObject(nsIUR
       mType = newType;
       if (aNotify)
         notifier.Notify();
     }
     switch (newType) {
       case eType_Image:
         // Don't notify, because we will take care of that ourselves.
         if (aURI) {
-          rv = LoadImage(aURI, aForceLoad, PR_FALSE);
+          rv = LoadImage(aURI, aForceLoad, false);
         } else {
           rv = NS_ERROR_NOT_AVAILABLE;
         }
         break;
       case eType_Plugin:
         rv = TryInstantiate(mContentType, mURI);
         break;
       case eType_Document:
@@ -1319,23 +1319,23 @@ nsObjectLoadingContent::LoadObject(nsIUR
         break;
     };
     return NS_OK;
   }
 
   // If the class ID specifies a supported plugin, or if we have no explicit URI
   // but a type, immediately instantiate the plugin.
   bool isSupportedClassID = false;
-  nsCAutoString typeForID; // Will be set iff isSupportedClassID == PR_TRUE
+  nsCAutoString typeForID; // Will be set iff isSupportedClassID == true
   bool hasID = false;
   if (caps & eSupportClassID) {
     nsAutoString classid;
     thisContent->GetAttr(kNameSpaceID_None, nsGkAtoms::classid, classid);
     if (!classid.IsEmpty()) {
-      hasID = PR_TRUE;
+      hasID = true;
       isSupportedClassID = NS_SUCCEEDED(TypeForClassID(classid, typeForID));
     }
   }
 
   if (hasID && !isSupportedClassID) {
     // We have a class ID and it's unsupported.  Fallback in that case.
     LOG(("OBJLC [%p]: invalid classid\n", this));
     rv = NS_ERROR_NOT_AVAILABLE;
@@ -1439,17 +1439,17 @@ nsObjectLoadingContent::LoadObject(nsIUR
     NS_ParseContentType(aTypeHint, typeHint, dummy);
     if (!typeHint.IsEmpty()) {
       chan->SetContentType(typeHint);
     }
   }
 
   // Set up the channel's principal and such, like nsDocShell::DoURILoad does
   nsContentUtils::SetUpChannelOwner(thisContent->NodePrincipal(),
-                                    chan, aURI, PR_TRUE);
+                                    chan, aURI, true);
 
   nsCOMPtr<nsIScriptChannel> scriptChannel = do_QueryInterface(chan);
   if (scriptChannel) {
     // Allow execution against our context if the principals match
     scriptChannel->
       SetExecutionPolicy(nsIScriptChannel::EXECUTE_NORMAL);
   }
 
@@ -1510,49 +1510,49 @@ nsObjectLoadingContent::Traverse(nsObjec
 
 // <private>
 /* static */ bool
 nsObjectLoadingContent::IsSuccessfulRequest(nsIRequest* aRequest)
 {
   nsresult status;
   nsresult rv = aRequest->GetStatus(&status);
   if (NS_FAILED(rv) || NS_FAILED(status)) {
-    return PR_FALSE;
+    return false;
   }
 
   // This may still be an error page or somesuch
   nsCOMPtr<nsIHttpChannel> httpChan(do_QueryInterface(aRequest));
   if (httpChan) {
     bool success;
     rv = httpChan->GetRequestSucceeded(&success);
     if (NS_FAILED(rv) || !success) {
-      return PR_FALSE;
+      return false;
     }
   }
 
   // Otherwise, the request is successful
-  return PR_TRUE;
+  return true;
 }
 
 /* static */ bool
 nsObjectLoadingContent::CanHandleURI(nsIURI* aURI)
 {
   nsCAutoString scheme;
   if (NS_FAILED(aURI->GetScheme(scheme))) {
-    return PR_FALSE;
+    return false;
   }
 
   nsIIOService* ios = nsContentUtils::GetIOService();
   if (!ios)
-    return PR_FALSE;
+    return false;
   
   nsCOMPtr<nsIProtocolHandler> handler;
   ios->GetProtocolHandler(scheme.get(), getter_AddRefs(handler));
   if (!handler) {
-    return PR_FALSE;
+    return false;
   }
   
   nsCOMPtr<nsIExternalProtocolHandler> extHandler =
     do_QueryInterface(handler);
   // We can handle this URI if its protocol handler is not the external one
   return extHandler == nsnull;
 }
 
@@ -1591,30 +1591,30 @@ nsObjectLoadingContent::IsSupportedDocum
 
       return NS_SUCCEEDED(rv) && canConvert;
     }
 
     // Don't want to support plugins as documents
     return supported != nsIWebNavigationInfo::PLUGIN;
   }
 
-  return PR_FALSE;
+  return false;
 }
 
 void
 nsObjectLoadingContent::UnloadContent()
 {
   // Don't notify in CancelImageRequests. We do it ourselves.
-  CancelImageRequests(PR_FALSE);
+  CancelImageRequests(false);
   if (mFrameLoader) {
     mFrameLoader->Destroy();
     mFrameLoader = nsnull;
   }
   mType = eType_Null;
-  mUserDisabled = mSuppressed = PR_FALSE;
+  mUserDisabled = mSuppressed = false;
   mFallbackReason = ePluginOtherState;
 }
 
 void
 nsObjectLoadingContent::NotifyStateChanged(ObjectType aOldType,
                                            nsEventStates aOldState,
                                            bool aSync,
                                            bool aNotify)
@@ -1799,19 +1799,19 @@ nsObjectLoadingContent::HandleBeingBlock
                                                           PRInt16 aRetval)
 {
   // Must call UnloadContent first, as it overwrites
   // mSuppressed/mUserDisabled. It also takes care of setting the type to
   // eType_Null.
   UnloadContent();
   if (NS_SUCCEEDED(aStatus)) {
     if (aRetval == nsIContentPolicy::REJECT_TYPE) {
-      mUserDisabled = PR_TRUE;
+      mUserDisabled = true;
     } else if (aRetval == nsIContentPolicy::REJECT_SERVER) {
-      mSuppressed = PR_TRUE;
+      mSuppressed = true;
     }
   }
 }
 
 nsresult
 nsObjectLoadingContent::TryInstantiate(const nsACString& aMIMEType,
                                        nsIURI* aURI)
 {
@@ -1851,17 +1851,17 @@ nsObjectLoadingContent::Instantiate(nsIO
 
   // We're instantiating now, invalidate any pending async instantiate
   // calls.
   mPendingInstantiateEvent = nsnull;
 
   // Mark that we're instantiating now so that we don't end up
   // re-entering instantiation code.
   bool oldInstantiatingValue = mInstantiating;
-  mInstantiating = PR_TRUE;
+  mInstantiating = true;
 
   nsCString typeToUse(aMIMEType);
   if (typeToUse.IsEmpty() && aURI) {
     IsPluginEnabledByExtension(aURI, typeToUse);
   }
 
   nsCOMPtr<nsIContent> thisContent = 
     do_QueryInterface(static_cast<nsIImageLoadingContent*>(this));
@@ -1931,17 +1931,17 @@ nsObjectLoadingContent::GetPluginSupport
        child = child->GetNextSibling()) {
     if (child->IsHTML(nsGkAtoms::param)) {
       if (child->AttrValueIs(kNameSpaceID_None, nsGkAtoms::name,
                              NS_LITERAL_STRING("pluginurl"), eIgnoreCase)) {
         return GetPluginDisabledState(aContentType);
       }
     } else if (!hasAlternateContent) {
       hasAlternateContent =
-        nsStyleUtil::IsSignificantChild(child, PR_TRUE, PR_FALSE);
+        nsStyleUtil::IsSignificantChild(child, true, false);
     }
   }
 
   return hasAlternateContent ? ePluginOtherState :
     GetPluginDisabledState(aContentType);
 }
 
 /* static */ PluginSupportState
@@ -1975,17 +1975,17 @@ nsObjectLoadingContent::CreateStaticClon
       const_cast<nsObjectLoadingContent*>(this)->GetExistingFrame(eDontFlush);
     nsIFrame* f = do_QueryFrame(frame);
     aDest->mPrintFrame = f;
   }
 
   if (mFrameLoader) {
     nsCOMPtr<nsIContent> content =
       do_QueryInterface(static_cast<nsIImageLoadingContent*>((aDest)));
-    nsFrameLoader* fl = nsFrameLoader::Create(content, PR_FALSE);
+    nsFrameLoader* fl = nsFrameLoader::Create(content, false);
     if (fl) {
       aDest->mFrameLoader = fl;
       mFrameLoader->CreateStaticClone(fl);
     }
   }
 }
 
 NS_IMETHODIMP
@@ -1996,17 +1996,17 @@ nsObjectLoadingContent::GetPrintFrame(ns
 }
 
 NS_IMETHODIMP
 nsObjectLoadingContent::PluginCrashed(nsIPluginTag* aPluginTag,
                                       const nsAString& pluginDumpID,
                                       const nsAString& browserDumpID,
                                       bool submittedCrashReport)
 {
-  AutoNotifier notifier(this, PR_TRUE);
+  AutoNotifier notifier(this, true);
   UnloadContent();
   mFallbackReason = ePluginCrashed;
   nsCOMPtr<nsIContent> thisContent = do_QueryInterface(static_cast<nsIImageLoadingContent*>(this));
 
   // Note that aPluginTag in invalidated after we're called, so copy 
   // out any data we need now.
   nsCAutoString pluginName;
   aPluginTag->GetName(pluginName);
--- a/layout/generic/nsObjectFrame.cpp
+++ b/layout/generic/nsObjectFrame.cpp
@@ -270,28 +270,28 @@ public:
 
   void Destroy() { mFrame = nsnull; }
 
 protected:
   bool AcceptUpdate(PRUint64 aSequenceNumber) {
     if (aSequenceNumber > mLastSequenceNumber && mFrame &&
         mFrame->mInstanceOwner) {
       mLastSequenceNumber = aSequenceNumber;
-      return PR_TRUE;
+      return true;
     }
-    return PR_FALSE;
+    return false;
   }
 
   PRUint64 mLastSequenceNumber;
   nsObjectFrame* mFrame;
 };
 
 nsObjectFrame::nsObjectFrame(nsStyleContext* aContext)
   : nsObjectFrameSuper(aContext)
-  , mReflowCallbackPosted(PR_FALSE)
+  , mReflowCallbackPosted(false)
 {
   PR_LOG(nsObjectFrameLM, PR_LOG_DEBUG,
          ("Created new nsObjectFrame %p\n", this));
 }
 
 nsObjectFrame::~nsObjectFrame()
 {
   PR_LOG(nsObjectFrameLM, PR_LOG_DEBUG,
@@ -345,17 +345,17 @@ void
 nsObjectFrame::DestroyFrom(nsIFrame* aDestructRoot)
 {
   NS_ASSERTION(!mPreventInstantiation ||
                (mContent && mContent->GetCurrentDoc()->GetDisplayDocument()),
                "about to crash due to bug 136927");
 
   // we need to finish with the plugin before native window is destroyed
   // doing this in the destructor is too late.
-  StopPluginInternal(PR_TRUE);
+  StopPluginInternal(true);
 
   // StopPluginInternal might have disowned the widget; if it has,
   // mWidget will be null.
   if (mWidget) {
     mInnerView->DetachWidgetEventHandler(mWidget);
     mWidget->Destroy();
   }
 
@@ -445,50 +445,50 @@ nsObjectFrame::CreateWidget(nscoord aWid
     if (!parentWidget)
       return NS_ERROR_FAILURE;
 
     mInnerView = viewMan->CreateView(GetContentRectRelativeToSelf(), view);
     if (!mInnerView) {
       NS_ERROR("Could not create inner view");
       return NS_ERROR_OUT_OF_MEMORY;
     }
-    viewMan->InsertChild(view, mInnerView, nsnull, PR_TRUE);
+    viewMan->InsertChild(view, mInnerView, nsnull, true);
 
     nsresult rv;
     mWidget = do_CreateInstance(kWidgetCID, &rv);
     if (NS_FAILED(rv))
       return rv;
 
     nsWidgetInitData initData;
     initData.mWindowType = eWindowType_plugin;
-    initData.mUnicode = PR_FALSE;
-    initData.clipChildren = PR_TRUE;
-    initData.clipSiblings = PR_TRUE;
+    initData.mUnicode = false;
+    initData.clipChildren = true;
+    initData.clipSiblings = true;
     // We want mWidget to be able to deliver events to us, especially on
     // Mac where events to the plugin are routed through Gecko. So we
     // allow the view to attach its event handler to mWidget even though
     // mWidget isn't the view's designated widget.
     EVENT_CALLBACK eventHandler = mInnerView->AttachWidgetEventHandler(mWidget);
     rv = mWidget->Create(parentWidget, nsnull, nsIntRect(0,0,0,0),
                          eventHandler, dx, nsnull, nsnull, &initData);
     if (NS_FAILED(rv)) {
       mWidget->Destroy();
       mWidget = nsnull;
       return rv;
     }
 
-    mWidget->EnableDragDrop(PR_TRUE);
+    mWidget->EnableDragDrop(true);
 
     // If this frame has an ancestor with a widget which is not
     // the root prescontext's widget, then this plugin should not be
     // displayed, so don't show the widget. If we show the widget, the
     // plugin may appear in the main window. In Web content this would
     // only happen with a plugin in a XUL popup.
     if (parentWidget == GetNearestWidget()) {
-      mWidget->Show(PR_TRUE);
+      mWidget->Show(true);
 #ifdef XP_MACOSX
       // On Mac, we need to invalidate ourselves since even windowed
       // plugins are painted through Thebes and we need to ensure
       // the Thebes layer containing the plugin is updated.
       Invalidate(GetContentRectRelativeToSelf());
 #endif
     }
   }
@@ -540,17 +540,17 @@ nsObjectFrame::CreateWidget(nscoord aWid
 #define EMBED_DEF_WIDTH 240
 #define EMBED_DEF_HEIGHT 200
 
 /* virtual */ nscoord
 nsObjectFrame::GetMinWidth(nsRenderingContext *aRenderingContext)
 {
   nscoord result = 0;
 
-  if (!IsHidden(PR_FALSE)) {
+  if (!IsHidden(false)) {
     nsIAtom *atom = mContent->Tag();
     if (atom == nsGkAtoms::applet || atom == nsGkAtoms::embed) {
       result = nsPresContext::CSSPixelsToAppUnits(EMBED_DEF_WIDTH);
     }
   }
 
   DISPLAY_MIN_WIDTH(this, result);
   return result;
@@ -566,17 +566,17 @@ void
 nsObjectFrame::GetDesiredSize(nsPresContext* aPresContext,
                               const nsHTMLReflowState& aReflowState,
                               nsHTMLReflowMetrics& aMetrics)
 {
   // By default, we have no area
   aMetrics.width = 0;
   aMetrics.height = 0;
 
-  if (IsHidden(PR_FALSE)) {
+  if (IsHidden(false)) {
     return;
   }
   
   aMetrics.width = aReflowState.ComputedWidth();
   aMetrics.height = aReflowState.ComputedHeight();
 
   // for EMBED and APPLET, default to 240x200 for compatibility
   nsIAtom *atom = mContent->Tag();
@@ -657,45 +657,45 @@ nsObjectFrame::Reflow(nsPresContext*    
   }
 
   nsRect r(0, 0, aMetrics.width, aMetrics.height);
   r.Deflate(aReflowState.mComputedBorderPadding);
 
   if (mInnerView) {
     nsIViewManager* vm = mInnerView->GetViewManager();
     vm->MoveViewTo(mInnerView, r.x, r.y);
-    vm->ResizeView(mInnerView, nsRect(nsPoint(0, 0), r.Size()), PR_TRUE);
+    vm->ResizeView(mInnerView, nsRect(nsPoint(0, 0), r.Size()), true);
   }
 
   FixupWindow(r.Size());
   if (!mReflowCallbackPosted) {
-    mReflowCallbackPosted = PR_TRUE;
+    mReflowCallbackPosted = true;
     aPresContext->PresShell()->PostReflowCallback(this);
   }
 
   aStatus = NS_FRAME_COMPLETE;
 
   NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aMetrics);
   return NS_OK;
 }
 
 ///////////// nsIReflowCallback ///////////////
 
 bool
 nsObjectFrame::ReflowFinished()
 {
-  mReflowCallbackPosted = PR_FALSE;
+  mReflowCallbackPosted = false;
   CallSetWindow();
-  return PR_TRUE;
+  return true;
 }
 
 void
 nsObjectFrame::ReflowCallbackCanceled()
 {
-  mReflowCallbackPosted = PR_FALSE;
+  mReflowCallbackPosted = false;
 }
 
 nsresult
 nsObjectFrame::InstantiatePlugin(nsPluginHost* aPluginHost, 
                                  const char* aMimeType,
                                  nsIURI* aURI)
 {
   NS_ASSERTION(mPreventInstantiation,
@@ -768,17 +768,17 @@ nsObjectFrame::FixupWindow(const nsSize&
   // us from drawing on screen until the widget is properly positioned, which will not
   // happen until we have finished the reflow process.
 #ifdef XP_MACOSX
   window->clipRect.top = 0;
   window->clipRect.left = 0;
   window->clipRect.bottom = 0;
   window->clipRect.right = 0;
 #else
-  mInstanceOwner->UpdateWindowPositionAndClipRect(PR_FALSE);
+  mInstanceOwner->UpdateWindowPositionAndClipRect(false);
 #endif
 
   NotifyPluginReflowObservers();
 }
 
 nsresult
 nsObjectFrame::CallSetWindow(bool aCheckIsHidden)
 {
@@ -840,17 +840,17 @@ nsObjectFrame::IsFocusable(PRInt32 *aTab
   return nsObjectFrameSuper::IsFocusable(aTabIndex, aWithMouse);
 }
 
 bool
 nsObjectFrame::IsHidden(bool aCheckVisibilityStyle) const
 {
   if (aCheckVisibilityStyle) {
     if (!GetStyleVisibility()->IsVisibleOrCollapsed())
-      return PR_TRUE;    
+      return true;    
   }
 
   // only <embed> tags support the HIDDEN attribute
   if (mContent->Tag() == nsGkAtoms::embed) {
     // Yes, these are really the kooky ways that you could tell 4.x
     // not to hide the <embed> once you'd put the 'hidden' attribute
     // on the tag...
 
@@ -858,21 +858,21 @@ nsObjectFrame::IsHidden(bool aCheckVisib
     // compatibility w/ 4.x and IE so we don't create a non-painting
     // widget in layout. See bug 188959.
     nsAutoString hidden;
     if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::hidden, hidden) &&
        (hidden.IsEmpty() ||
         (!hidden.LowerCaseEqualsLiteral("false") &&
          !hidden.LowerCaseEqualsLiteral("no") &&
          !hidden.LowerCaseEqualsLiteral("off")))) {
-      return PR_TRUE;
+      return true;
     }
   }
 
-  return PR_FALSE;
+  return false;
 }
 
 nsIntPoint nsObjectFrame::GetWindowOriginInPixels(bool aWindowless)
 {
   nsIView * parentWithView;
   nsPoint origin(0,0);
 
   GetOffsetFromView(origin, &parentWithView);
@@ -980,25 +980,25 @@ nsDisplayPluginReadback::GetBounds(nsDis
 
 bool
 nsDisplayPluginReadback::ComputeVisibility(nsDisplayListBuilder* aBuilder,
                                            nsRegion* aVisibleRegion,
                                            const nsRect& aAllowVisibleRegionExpansion)
 {
   if (!nsDisplayItem::ComputeVisibility(aBuilder, aVisibleRegion,
                                         aAllowVisibleRegionExpansion))
-    return PR_FALSE;
+    return false;
 
   nsRect expand;
   expand.IntersectRect(aAllowVisibleRegionExpansion, GetBounds(aBuilder));
   // *Add* our bounds to the visible region so that stuff underneath us is
   // likely to be made visible, so we can use it for a background! This is
   // a bit crazy since we normally only subtract from the visible region.
   aVisibleRegion->Or(*aVisibleRegion, expand);
-  return PR_TRUE;
+  return true;
 }
 
 nsRect
 nsDisplayPlugin::GetBounds(nsDisplayListBuilder* aBuilder)
 {
   return GetDisplayItemBounds(aBuilder, this, mFrame);
 }
 
@@ -1020,17 +1020,17 @@ nsDisplayPlugin::ComputeVisibility(nsDis
                                           aAllowVisibleRegionExpansion);
 }
 
 nsRegion
 nsDisplayPlugin::GetOpaqueRegion(nsDisplayListBuilder* aBuilder,
                                  bool* aForceTransparentSurface)
 {
   if (aForceTransparentSurface) {
-    *aForceTransparentSurface = PR_FALSE;
+    *aForceTransparentSurface = false;
   }
   nsRegion result;
   nsObjectFrame* f = static_cast<nsObjectFrame*>(mFrame);
   if (!aBuilder->IsForPluginGeometry()) {
     nsIWidget* widget = f->GetWidget();
     if (widget) {
       nsTArray<nsIntRect> clip;
       widget->GetWindowClipRegion(&clip);
@@ -1137,42 +1137,42 @@ nsObjectFrame::DidSetWidgetGeometry()
 #endif
 }
 
 bool
 nsObjectFrame::IsOpaque() const
 {
 #if defined(XP_MACOSX)
   // ???
-  return PR_FALSE;
+  return false;
 #else
   return !IsTransparentMode();
 #endif
 }
 
 bool
 nsObjectFrame::IsTransparentMode() const
 {
 #if defined(XP_MACOSX)
   // ???
-  return PR_FALSE;
+  return false;
 #else
   if (!mInstanceOwner)
-    return PR_FALSE;
+    return false;
 
   NPWindow *window;
   mInstanceOwner->GetWindow(window);
   if (window->type != NPWindowTypeDrawable)
-    return PR_FALSE;
+    return false;
 
   nsresult rv;
   nsRefPtr<nsNPAPIPluginInstance> pi;
   rv = mInstanceOwner->GetInstance(getter_AddRefs(pi));
   if (NS_FAILED(rv) || !pi)
-    return PR_FALSE;
+    return false;
 
   bool transparent = false;
   pi->IsTransparent(&transparent);
   return transparent;
 #endif
 }
 
 NS_IMETHODIMP
@@ -1205,17 +1205,17 @@ nsObjectFrame::BuildDisplayList(nsDispla
   nsDisplayList replacedContent;
 
   if (aBuilder->IsForPainting() && mInstanceOwner && mInstanceOwner->UseAsyncRendering()) {
     NPWindow* window = nsnull;
     mInstanceOwner->GetWindow(window);
     bool isVisible = window && window->width > 0 && window->height > 0;
     if (isVisible && aBuilder->ShouldSyncDecodeImages()) {
   #ifndef XP_MACOSX
-      mInstanceOwner->UpdateWindowVisibility(PR_TRUE);
+      mInstanceOwner->UpdateWindowVisibility(true);
   #endif
     }
 
     nsRefPtr<ImageContainer> container = GetImageContainer();
     nsRefPtr<Image> currentImage = container ? container->GetCurrentImage() : nsnull;
     if (!currentImage || !isVisible ||
         container->GetCurrentSize() != gfxIntSize(window->width, window->height)) {
       mInstanceOwner->NotifyPaintWaiter(aBuilder);
@@ -1783,17 +1783,17 @@ nsObjectFrame::PaintPlugin(nsDisplayList
       // (If SetPluginPortAndDetectChange() made any changes itself, this has
       // already been detected in that method, and will likewise result in a
       // call to SetWindow() from FixUpPluginWindow().)
       NP_CGContext* windowContext = static_cast<NP_CGContext*>(window->window);
       if (mInstanceOwner->GetEventModel() == NPEventModelCarbon &&
           windowContext->context != cgContext) {
         windowContext->context = cgContext;
         cgPluginPortCopy->context = cgContext;
-        mInstanceOwner->SetPluginPortChanged(PR_TRUE);
+        mInstanceOwner->SetPluginPortChanged(true);
       }
 #endif
 
       mInstanceOwner->BeginCGPaint();
       if (mInstanceOwner->GetDrawingModel() == NPDrawingModelCoreAnimation ||
           mInstanceOwner->GetDrawingModel() == 
                                    NPDrawingModelInvalidatingCoreAnimation) {
         // CoreAnimation is updated, render the layer and perform a readback.
@@ -1834,17 +1834,17 @@ nsObjectFrame::PaintPlugin(nsDisplayList
   if (inst) {
     gfxRect frameGfxRect =
       PresContext()->AppUnitsToGfxUnits(aPluginRect);
     gfxRect dirtyGfxRect =
       PresContext()->AppUnitsToGfxUnits(aDirtyRect);
     gfxContext *ctx = aRenderingContext.ThebesContext();
     gfxMatrix currentMatrix = ctx->CurrentMatrix();
 
-    if (ctx->UserToDevicePixelSnapped(frameGfxRect, PR_FALSE)) {
+    if (ctx->UserToDevicePixelSnapped(frameGfxRect, false)) {
       dirtyGfxRect = ctx->UserToDevice(dirtyGfxRect);
       ctx->IdentityMatrix();
     }
     dirtyGfxRect.RoundOut();
 
     // Look if it's windowless
     NPWindow *window;
     mInstanceOwner->GetWindow(window);
@@ -1896,17 +1896,17 @@ nsObjectFrame::PaintPlugin(nsDisplayList
         // it shouldn't.
         //
         // since the two uses of the rectangle are mutually exclusive in some cases, and
         // since I don't see any incorrect painting (at least with Flash and ViewPoint -
         // the originator of bug 135737), it seems that windowless plugins are not relying
         // on information here for clipping their drawing, and we can safely use this message
         // to tell the plugin exactly where it is in all cases.
 
-        nsIntPoint origin = GetWindowOriginInPixels(PR_TRUE);
+        nsIntPoint origin = GetWindowOriginInPixels(true);
         nsIntRect winlessRect = nsIntRect(origin, nsIntSize(window->width, window->height));
 
         if (!mWindowlessRect.IsEqualEdges(winlessRect)) {
           mWindowlessRect = winlessRect;
 
           WINDOWPOS winpos;
           memset(&winpos, 0, sizeof(winpos));
           winpos.x = mWindowlessRect.x;
@@ -1987,34 +1987,34 @@ nsObjectFrame::PaintPlugin(nsDisplayList
         NS_WARNING("Plugin is being asked to render to a surface that's in error!");
         return;
       }
 
       // check if we need to update the PS
       HPS hps = (HPS)GetPSFromRC(aRenderingContext);
       if (reinterpret_cast<HPS>(window->window) != hps) {
         window->window = reinterpret_cast<void*>(hps);
-        doupdatewindow = PR_TRUE;
+        doupdatewindow = true;
       }
       LONG lPSid = GpiSavePS(hps);
       RECTL rclViewport;
       if (GpiQueryDevice(hps) != NULLHANDLE) { // ensure that we have an associated HDC
         if (GpiQueryPageViewport(hps, &rclViewport)) {
           rclViewport.xLeft += (LONG)xoff;
           rclViewport.xRight += (LONG)xoff;
           rclViewport.yBottom += (LONG)yoff;
           rclViewport.yTop += (LONG)yoff;
           GpiSetPageViewport(hps, &rclViewport);
         }
       }
 
       if ((window->x != origin.x) || (window->y != origin.y)) {
         window->x = origin.x;
         window->y = origin.y;
-        doupdatewindow = PR_TRUE;
+        doupdatewindow = true;
       }
 
       // if our location or visible area has changed, we need to tell the plugin
       if (doupdatewindow) {
         inst->SetWindow(window);        
       }
 
       mInstanceOwner->Paint(aDirtyRect, hps);
@@ -2108,17 +2108,17 @@ nsObjectFrame::GetPluginInstance(nsNPAPI
 }
 
 nsresult
 nsObjectFrame::PrepareInstanceOwner()
 {
   nsWeakFrame weakFrame(this);
 
   // First, have to stop any possibly running plugins.
-  StopPluginInternal(PR_FALSE);
+  StopPluginInternal(false);
 
   if (!weakFrame.IsAlive()) {
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   NS_ASSERTION(!mInstanceOwner, "Must not have an instance owner here");
 
   mInstanceOwner = new nsPluginInstanceOwner();
@@ -2155,26 +2155,26 @@ nsObjectFrame::Instantiate(nsIChannel* a
   FixupWindow(GetContentRectRelativeToSelf().Size());
 
   // Ensure we redraw when a plugin is instantiated
   Invalidate(GetContentRectRelativeToSelf());
 
   nsWeakFrame weakFrame(this);
 
   NS_ASSERTION(!mPreventInstantiation, "Say what?");
-  mPreventInstantiation = PR_TRUE;
+  mPreventInstantiation = true;
   rv = pluginHost->InstantiatePluginForChannel(aChannel, mInstanceOwner, aStreamListener);
 
   if (!weakFrame.IsAlive()) {
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   NS_ASSERTION(mPreventInstantiation,
                "Instantiation should still be prevented!");
-  mPreventInstantiation = PR_FALSE;
+  mPreventInstantiation = false;
 
 #ifdef ACCESSIBILITY
   nsAccessibilityService* accService = nsIPresShell::AccService();
   if (accService) {
     accService->RecreateAccessible(PresContext()->PresShell(), mContent);
   }
 #endif
 
@@ -2213,17 +2213,17 @@ nsObjectFrame::Instantiate(const char* a
 
   // get the nsIPluginHost service
   nsCOMPtr<nsIPluginHost> pluginHost(do_GetService(MOZ_PLUGIN_HOST_CONTRACTID, &rv));
   if (NS_FAILED(rv))
     return rv;
   mInstanceOwner->SetPluginHost(pluginHost);
 
   NS_ASSERTION(!mPreventInstantiation, "Say what?");
-  mPreventInstantiation = PR_TRUE;
+  mPreventInstantiation = true;
 
   rv = InstantiatePlugin(static_cast<nsPluginHost*>(pluginHost.get()), aMimeType, aURI);
 
   if (!weakFrame.IsAlive()) {
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   // finish up
@@ -2242,17 +2242,17 @@ nsObjectFrame::Instantiate(const char* a
 
 #ifdef ACCESSIBILITY
   nsAccessibilityService* accService = nsIPresShell::AccService();
   if (accService) {
     accService->RecreateAccessible(PresContext()->PresShell(), mContent);
   }
 #endif
 
-  mPreventInstantiation = PR_FALSE;
+  mPreventInstantiation = false;
 
   return rv;
 }
 
 void
 nsObjectFrame::TryNotifyContentObjectWrapper()
 {
   nsRefPtr<nsNPAPIPluginInstance> inst;
@@ -2304,34 +2304,34 @@ GetMIMEType(nsNPAPIPluginInstance *aPlug
 #endif // XP_WIN
 
 static bool
 DoDelayedStop(nsPluginInstanceOwner *aInstanceOwner, bool aDelayedStop)
 {
 #if (MOZ_PLATFORM_MAEMO==5)
   // Don't delay stop on Maemo/Hildon (bug 530739).
   if (aDelayedStop && aInstanceOwner->MatchPluginName("Shockwave Flash"))
-    return PR_FALSE;
+    return false;
 #endif
 
   // Don't delay stopping QuickTime (bug 425157), Flip4Mac (bug 426524),
   // XStandard (bug 430219), CMISS Zinc (bug 429604).
   if (aDelayedStop
 #if !(defined XP_WIN || defined MOZ_X11)
       && !aInstanceOwner->MatchPluginName("QuickTime")
       && !aInstanceOwner->MatchPluginName("Flip4Mac")
       && !aInstanceOwner->MatchPluginName("XStandard plugin")
       && !aInstanceOwner->MatchPluginName("CMISS Zinc Plugin")
 #endif
       ) {
     nsCOMPtr<nsIRunnable> evt = new nsStopPluginRunnable(aInstanceOwner);
     NS_DispatchToCurrentThread(evt);
-    return PR_TRUE;
+    return true;
   }
-  return PR_FALSE;
+  return false;
 }
 
 static void
 DoStopPlugin(nsPluginInstanceOwner *aInstanceOwner, bool aDelayedStop)
 {
   nsRefPtr<nsNPAPIPluginInstance> inst;
   aInstanceOwner->GetInstance(getter_AddRefs(inst));
   if (inst) {
@@ -2394,17 +2394,17 @@ nsStopPluginRunnable::Run()
       }
       NS_ERROR("Failed to setup a timer to stop the plugin later (at a safe "
                "time). Stopping the plugin now, this might crash.");
     }
   }
 
   mTimer = nsnull;
 
-  DoStopPlugin(mInstanceOwner, PR_FALSE);
+  DoStopPlugin(mInstanceOwner, false);
 
   return NS_OK;
 }
 
 void
 nsObjectFrame::StopPlugin()
 {
   bool delayedStop = false;
@@ -2460,17 +2460,17 @@ nsObjectFrame::StopPluginInternal(bool a
   nsRefPtr<nsPluginInstanceOwner> owner;
   owner.swap(mInstanceOwner);
 
   // Make sure that our windowless rect has been zeroed out, so if we
   // get reinstantiated we'll send the right messages to the plug-in.
   mWindowlessRect.SetEmpty();
 
   bool oldVal = mPreventInstantiation;
-  mPreventInstantiation = PR_TRUE;
+  mPreventInstantiation = true;
 
   nsWeakFrame weakFrame(this);
 
 #if defined(XP_WIN) || defined(MOZ_X11)
   if (aDelayedStop && mWidget) {
     // If we're asked to do a delayed stop it means we're stopping the
     // plugin because we're destroying the frame. In that case, disown
     // the widget.