Backed out changeset 4ad4623f3840 (bug 1237458) for build bustage ON A CLOSED TREE
authorNigel Babu <nigelbabu@gmail.com>
Thu, 07 Jan 2016 11:51:34 +0530
changeset 278929 9dd94eccd36a8bc910cba69b62f7c0c9974ec0aa
parent 278928 31c319b09ec07c21f7fe164aab728391cf6b8f38
child 278930 2f6e12a6f04f8e676c357bd50ec88e81f2037306
push id29860
push usercbook@mozilla.com
push dateThu, 07 Jan 2016 10:51:20 +0000
treeherdermozilla-central@e0bcd16e1d4b [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1237458
milestone46.0a1
backs out4ad4623f38408bb19c1b4e5e8b4a61d3aa06a1d4
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
Backed out changeset 4ad4623f3840 (bug 1237458) for build bustage ON A CLOSED TREE
ipc/glue/MessageChannel.cpp
--- a/ipc/glue/MessageChannel.cpp
+++ b/ipc/glue/MessageChannel.cpp
@@ -136,34 +136,34 @@ public:
       : mMessageName(strdup(msg->name())),
         mMessageRoutingId(msg->routing_id()),
         mMesageSemantics(msg->is_interrupt() ? INTR_SEMS :
                           msg->is_sync() ? SYNC_SEMS :
                           ASYNC_SEMS),
         mDirection(direction),
         mMoved(false)
     {
-        MOZ_RELEASE_ASSERT(mMessageName);
+        MOZ_ASSERT(mMessageName);
     }
 
     InterruptFrame(InterruptFrame&& aOther)
     {
-        MOZ_RELEASE_ASSERT(aOther.mMessageName);
+        MOZ_ASSERT(aOther.mMessageName);
         mMessageName = aOther.mMessageName;
         aOther.mMessageName = nullptr;
         aOther.mMoved = true;
 
         mMessageRoutingId = aOther.mMessageRoutingId;
         mMesageSemantics = aOther.mMesageSemantics;
         mDirection = aOther.mDirection;
     }
 
     ~InterruptFrame()
     {
-        MOZ_RELEASE_ASSERT(mMessageName || mMoved);
+        MOZ_ASSERT_IF(!mMessageName, mMoved);
 
         if (mMessageName)
             free(const_cast<char*>(mMessageName));
     }
 
     InterruptFrame& operator=(InterruptFrame&& aOther)
     {
         MOZ_RELEASE_ASSERT(&aOther != this);
@@ -237,17 +237,17 @@ public:
             mThat.EnteredSyncSend();
 
         mThat.mSawInterruptOutMsg |= frame.IsInterruptOutcall();
     }
 
     ~CxxStackFrame() {
         mThat.AssertWorkerThread();
 
-        MOZ_RELEASE_ASSERT(!mThat.mCxxStackFrames.empty());
+        MOZ_ASSERT(!mThat.mCxxStackFrames.empty());
 
         const InterruptFrame& frame = mThat.mCxxStackFrames.back();
         bool exitingSync = frame.IsOutgoingSync();
         bool exitingCall = frame.IsInterruptIncall();
         mThat.mCxxStackFrames.shrinkBy(1);
 
         bool exitingStack = mThat.mCxxStackFrames.empty();
 
@@ -607,17 +607,17 @@ MessageChannel::ShouldDeferMessage(const
     // Never defer messages that have the highest priority, even async
     // ones. This is safe because only the child can send these messages, so
     // they can never nest.
     if (aMsg.priority() == IPC::Message::PRIORITY_URGENT)
         return false;
 
     // Unless they're urgent, we always defer async messages.
     if (!aMsg.is_sync()) {
-        MOZ_RELEASE_ASSERT(aMsg.priority() == IPC::Message::PRIORITY_NORMAL);
+        MOZ_ASSERT(aMsg.priority() == IPC::Message::PRIORITY_NORMAL);
         return true;
     }
 
     int msgPrio = aMsg.priority();
     int waitingPrio = AwaitingSyncReplyPriority();
 
     // Always defer if the priority of the incoming message is less than the
     // priority of the message we're awaiting.
@@ -666,19 +666,19 @@ MessageChannel::OnMessageReceivedFromLin
     // we know that it needs to be immediately handled to unblock us.
     if (aMsg.is_sync() && aMsg.is_reply()) {
         if (aMsg.seqno() == mTimedOutMessageSeqno) {
             // Drop the message, but allow future sync messages to be sent.
             mTimedOutMessageSeqno = 0;
             return;
         }
 
-        MOZ_RELEASE_ASSERT(aMsg.transaction_id() == mCurrentTransaction);
-        MOZ_RELEASE_ASSERT(AwaitingSyncReply());
-        MOZ_RELEASE_ASSERT(!mRecvd);
+        MOZ_ASSERT(aMsg.transaction_id() == mCurrentTransaction);
+        MOZ_ASSERT(AwaitingSyncReply());
+        MOZ_ASSERT(!mRecvd);
 
         // Rather than storing errors in mRecvd, we mark them in
         // mRecvdErrors. We need a counter because multiple replies can arrive
         // when a timeout happens, as in the following example. Imagine the
         // child is running slowly. The parent sends a sync message P1. It times
         // out. The child eventually sends a sync message C1. While waiting for
         // the C1 response, the child dispatches P1. In doing so, it sends sync
         // message C2. At that point, it's valid for the parent to send error
@@ -690,43 +690,43 @@ MessageChannel::OnMessageReceivedFromLin
         }
 
         mRecvd = new Message(aMsg);
         NotifyWorkerThread();
         return;
     }
 
     // Prioritized messages cannot be compressed.
-    MOZ_RELEASE_ASSERT(!(aMsg.compress_type() != IPC::Message::COMPRESSION_NONE) ||
-                       aMsg.priority() == IPC::Message::PRIORITY_NORMAL);
+    MOZ_ASSERT_IF(aMsg.compress_type() != IPC::Message::COMPRESSION_NONE,
+                  aMsg.priority() == IPC::Message::PRIORITY_NORMAL);
 
     bool compress = false;
     if (aMsg.compress_type() == IPC::Message::COMPRESSION_ENABLED) {
         compress = (!mPending.empty() &&
                     mPending.back().type() == aMsg.type() &&
                     mPending.back().routing_id() == aMsg.routing_id());
         if (compress) {
             // This message type has compression enabled, and the back of the
             // queue was the same message type and routed to the same destination.
             // Replace it with the newer message.
-            MOZ_RELEASE_ASSERT(mPending.back().compress_type() ==
-                               IPC::Message::COMPRESSION_ENABLED);
+            MOZ_ASSERT(mPending.back().compress_type() ==
+                       IPC::Message::COMPRESSION_ENABLED);
             mPending.pop_back();
         }
     } else if (aMsg.compress_type() == IPC::Message::COMPRESSION_ALL) {
         // Check the message queue for another message with this type/destination.
         auto it = std::find_if(mPending.rbegin(), mPending.rend(),
                                MatchingKinds(aMsg.type(), aMsg.routing_id()));
         if (it != mPending.rend()) {
             // This message type has compression enabled, and the queue holds
             // a message with the same message type and routed to the same destination.
             // Erase it.  Note that, since we always compress these redundancies, There Can
             // Be Only One.
             compress = true;
-            MOZ_RELEASE_ASSERT((*it).compress_type() == IPC::Message::COMPRESSION_ALL);
+            MOZ_ASSERT((*it).compress_type() == IPC::Message::COMPRESSION_ALL);
             mPending.erase((++it).base());
         }
     }
 
     bool shouldWakeUp = AwaitingInterruptReply() ||
                         (AwaitingSyncReply() && !ShouldDeferMessage(aMsg)) ||
                         AwaitingIncomingMessage();
 
@@ -932,17 +932,17 @@ MessageChannel::Send(Message* aMsg, Mess
             mRecvdErrors--;
             return false;
         }
 
         if (mRecvd) {
             break;
         }
 
-        MOZ_RELEASE_ASSERT(!mTimedOutMessageSeqno);
+        MOZ_ASSERT(!mTimedOutMessageSeqno);
 
         bool maybeTimedOut = !WaitForSyncNotify(handleWindowsMessages);
 
         if (!Connected()) {
             ReportConnectionError("MessageChannel::SendAndWait");
             return false;
         }
 
@@ -967,22 +967,22 @@ MessageChannel::Send(Message* aMsg, Mess
             }
 
             mTimedOutMessageSeqno = seqno;
             mTimedOutMessagePriority = prio;
             return false;
         }
     }
 
-    MOZ_RELEASE_ASSERT(mRecvd);
-    MOZ_RELEASE_ASSERT(mRecvd->is_reply(), "expected reply");
-    MOZ_RELEASE_ASSERT(!mRecvd->is_reply_error());
-    MOZ_RELEASE_ASSERT(mRecvd->type() == replyType, "wrong reply type");
-    MOZ_RELEASE_ASSERT(mRecvd->seqno() == seqno);
-    MOZ_RELEASE_ASSERT(mRecvd->is_sync());
+    MOZ_ASSERT(mRecvd);
+    MOZ_ASSERT(mRecvd->is_reply(), "expected reply");
+    MOZ_ASSERT(!mRecvd->is_reply_error());
+    MOZ_ASSERT(mRecvd->type() == replyType, "wrong reply type");
+    MOZ_ASSERT(mRecvd->seqno() == seqno);
+    MOZ_ASSERT(mRecvd->is_sync());
 
     *aReply = Move(*mRecvd);
     mRecvd = nullptr;
     return true;
 }
 
 bool
 MessageChannel::Call(Message* aMsg, Message* aReply)
@@ -1266,17 +1266,17 @@ MessageChannel::OnMaybeDequeueOne()
     if (IsOnCxxStack() && recvd.is_interrupt() && recvd.is_reply()) {
         // We probably just received a reply in a nested loop for an
         // Interrupt call sent before entering that loop.
         mOutOfTurnReplies[recvd.seqno()] = Move(recvd);
         return false;
     }
 
     // We should not be in a transaction yet if we're not blocked.
-    MOZ_RELEASE_ASSERT(mCurrentTransaction == 0);
+    MOZ_ASSERT(mCurrentTransaction == 0);
     DispatchMessage(recvd);
 
     return true;
 }
 
 void
 MessageChannel::DispatchMessage(const Message &aMsg)
 {
@@ -1285,17 +1285,17 @@ MessageChannel::DispatchMessage(const Me
         nojsapi.emplace();
 
     nsAutoPtr<Message> reply;
 
     {
         AutoEnterTransaction transaction(this, aMsg);
 
         int id = aMsg.transaction_id();
-        MOZ_RELEASE_ASSERT(!aMsg.is_sync() || id == mCurrentTransaction);
+        MOZ_ASSERT_IF(aMsg.is_sync(), id == mCurrentTransaction);
 
         {
             MonitorAutoUnlock unlock(*mMonitor);
             CxxStackFrame frame(*this, IN_MESSAGE, &aMsg);
 
             if (aMsg.is_sync())
                 DispatchSyncMessage(aMsg, *getter_Transfers(reply));
             else if (aMsg.is_interrupt())
@@ -1321,17 +1321,17 @@ MessageChannel::DispatchSyncMessage(cons
     AssertWorkerThread();
 
     int prio = aMsg.priority();
 
     // We don't want to run any code that might run a nested event loop here, so
     // we avoid running event handlers. Once we've sent the response to the
     // urgent message, it's okay to run event handlers again since the parent is
     // no longer blocked.
-    MOZ_RELEASE_ASSERT(!(prio > IPC::Message::PRIORITY_NORMAL) || NS_IsMainThread());
+    MOZ_ASSERT_IF(prio > IPC::Message::PRIORITY_NORMAL, NS_IsMainThread());
     MaybeScriptBlocker scriptBlocker(this, prio > IPC::Message::PRIORITY_NORMAL);
 
     MessageChannel* dummy;
     MessageChannel*& blockingVar = ShouldBlockScripts() ? gParentProcessBlocker : dummy;
 
     Result rv;
     if (mTimedOutMessageSeqno && mTimedOutMessagePriority >= prio) {
         // If the other side sends a message in response to one of our messages
@@ -1365,17 +1365,17 @@ MessageChannel::DispatchSyncMessage(cons
     aReply->set_seqno(aMsg.seqno());
     aReply->set_transaction_id(aMsg.transaction_id());
 }
 
 void
 MessageChannel::DispatchAsyncMessage(const Message& aMsg)
 {
     AssertWorkerThread();
-    MOZ_RELEASE_ASSERT(!aMsg.is_interrupt() && !aMsg.is_sync());
+    MOZ_ASSERT(!aMsg.is_interrupt() && !aMsg.is_sync());
 
     if (aMsg.routing_id() == MSG_ROUTING_NONE) {
         NS_RUNTIMEABORT("unhandled special message!");
     }
 
     Result rv;
     {
         int prio = aMsg.priority();
@@ -1484,17 +1484,17 @@ MessageChannel::MaybeUndeferIncall()
     // maybe time to process this message
     Message call = mDeferred.top();
     mDeferred.pop();
 
     // fix up fudge factor we added to account for race
     IPC_ASSERT(0 < mRemoteStackDepthGuess, "fatal logic error");
     --mRemoteStackDepthGuess;
 
-    MOZ_RELEASE_ASSERT(call.priority() == IPC::Message::PRIORITY_NORMAL);
+    MOZ_ASSERT(call.priority() == IPC::Message::PRIORITY_NORMAL);
     mPending.push_back(call);
 }
 
 void
 MessageChannel::FlushPendingInterruptQueue()
 {
     AssertWorkerThread();
     mMonitor->AssertNotCurrentThreadOwns();
@@ -1633,27 +1633,27 @@ MessageChannel::SetReplyTimeoutMs(int32_
     mTimeoutMs = (aTimeoutMs <= 0)
                  ? kNoTimeout
                  : (int32_t)ceil((double)aTimeoutMs / 2.0);
 }
 
 void
 MessageChannel::OnChannelConnected(int32_t peer_id)
 {
-    MOZ_RELEASE_ASSERT(!mPeerPidSet);
+    MOZ_ASSERT(!mPeerPidSet);
     mPeerPidSet = true;
     mPeerPid = peer_id;
     mWorkerLoop->PostTask(FROM_HERE, new DequeueTask(mOnChannelConnectedTask));
 }
 
 void
 MessageChannel::DispatchOnChannelConnected()
 {
     AssertWorkerThread();
-    MOZ_RELEASE_ASSERT(mPeerPidSet);
+    MOZ_ASSERT(mPeerPidSet);
     if (mListener)
         mListener->OnChannelConnected(mPeerPid);
 }
 
 void
 MessageChannel::ReportMessageRouteError(const char* channelName) const
 {
     PrintErrorMessage(mSide, channelName, "Need a route");
@@ -1881,17 +1881,17 @@ MessageChannel::CloseWithTimeout()
     }
     SynchronouslyClose();
     mChannelState = ChannelTimeout;
 }
 
 void
 MessageChannel::BlockScripts()
 {
-    MOZ_RELEASE_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(NS_IsMainThread());
     mBlockScripts = true;
 }
 
 void
 MessageChannel::Close()
 {
     AssertWorkerThread();
 
@@ -2002,17 +2002,17 @@ MessageChannel::DumpInterruptStack(const
         printf_stderr("%s[(%u) %s %s %s(actor=%d) ]\n", pfx,
                       i, dir, sems, name, id);
     }
 }
 
 int32_t
 MessageChannel::GetTopmostMessageRoutingId() const
 {
-    MOZ_RELEASE_ASSERT(MessageLoop::current() == mWorkerLoop);
+    MOZ_ASSERT(MessageLoop::current() == mWorkerLoop);
     if (mCxxStackFrames.empty()) {
         return MSG_ROUTING_NONE;
     }
     const InterruptFrame& frame = mCxxStackFrames.back();
     return frame.GetRoutingId();
 }
 
 void
@@ -2023,17 +2023,17 @@ MessageChannel::CancelCurrentTransaction
     // canceled. Consequently, we have to update the state variables below.
     //
     // We also need to ensure that when any IPC functions on the stack return,
     // they don't reset these values using an RAII class like AutoSetValue. To
     // avoid that, these RAII classes check if the variable they set has been
     // tampered with (by us). If so, they don't reset the variable to the old
     // value.
 
-    MOZ_RELEASE_ASSERT(mCurrentTransaction);
+    MOZ_ASSERT(mCurrentTransaction);
     mCurrentTransaction = 0;
 
     mAwaitingSyncReply = false;
     mAwaitingSyncReplyPriority = 0;
 
     // We could also zero out mDispatchingSyncMessage here. However, that would
     // cause a race because mDispatchingSyncMessage is a worker-thread-only
     // field and we can be called on the I/O thread. Luckily, we can check to