Change DCHECK_IS_ON() to DCHECK_IS_ON

net/spdy/spdy_session.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/spdy/spdy_session.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/basictypes.h"
@@ skipping 738 matching lines @@
   return OK;
 }
 
 void SpdySession::CancelStreamRequest(
     const base::WeakPtr<SpdyStreamRequest>& request) {
   DCHECK(request);
   RequestPriority priority = request->priority();
   CHECK_GE(priority, MINIMUM_PRIORITY);
   CHECK_LE(priority, MAXIMUM_PRIORITY);
 
-  if (DCHECK_IS_ON()) {
-    // |request| should not be in a queue not matching its priority.
-    for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
-      if (priority == i)
-        continue;
-      PendingStreamRequestQueue* queue = &pending_create_stream_queues_[i];
-      DCHECK(std::find_if(queue->begin(),
-                          queue->end(),
-                          RequestEquals(request)) == queue->end());
-    }
+#if DCHECK_IS_ON
+  // |request| should not be in a queue not matching its priority.
+  for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
+    if (priority == i)
+      continue;
+    PendingStreamRequestQueue* queue = &pending_create_stream_queues_[i];
+    DCHECK(std::find_if(queue->begin(),
+                        queue->end(),
+                        RequestEquals(request)) == queue->end());
   }
+#endif
 
   PendingStreamRequestQueue* queue =
       &pending_create_stream_queues_[priority];
   // Remove |request| from |queue| while preserving the order of the
   // other elements.
   PendingStreamRequestQueue::iterator it =
       std::find_if(queue->begin(), queue->end(), RequestEquals(request));
   // The request may already be removed if there's a
   // CompleteStreamRequest() in flight.
   if (it != queue->end()) {
@@ skipping 672 matching lines @@
       in_flight_write_frame_size_ = 0;
       in_flight_write_stream_.reset();
     }
   }
 
   write_state_ = WRITE_STATE_DO_WRITE;
   return OK;
 }
 
 void SpdySession::DcheckGoingAway() const {
+#if DCHECK_IS_ON
   DCHECK_GE(availability_state_, STATE_GOING_AWAY);
-  if (DCHECK_IS_ON()) {
-    for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
-      DCHECK(pending_create_stream_queues_[i].empty());
-    }
+  for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
+    DCHECK(pending_create_stream_queues_[i].empty());
   }
   DCHECK(created_streams_.empty());
+#endif
 }
 
 void SpdySession::DcheckClosed() const {
   DcheckGoingAway();
   DCHECK_EQ(availability_state_, STATE_CLOSED);
   DCHECK_LT(error_on_close_, ERR_IO_PENDING);
   DCHECK(active_streams_.empty());
   DCHECK(unclaimed_pushed_streams_.empty());
   DCHECK(write_queue_.IsEmpty());
 }
@@ skipping 1528 matching lines @@
 void SpdySession::ResumeSendStalledStreams() {
   DCHECK_EQ(flow_control_state_, FLOW_CONTROL_STREAM_AND_SESSION);
 
   // We don't have to worry about new streams being queued, since
   // doing so would cause IsSendStalled() to return true. But we do
   // have to worry about streams being closed, as well as ourselves
   // being closed.
 
   while (availability_state_ != STATE_CLOSED && !IsSendStalled()) {
     size_t old_size = 0;
-    if (DCHECK_IS_ON())
-      old_size = GetTotalSize(stream_send_unstall_queue_);
+#if DCHECK_IS_ON
+    old_size = GetTotalSize(stream_send_unstall_queue_);
+#endif
 
     SpdyStreamId stream_id = PopStreamToPossiblyResume();
     if (stream_id == 0)
       break;
     ActiveStreamMap::const_iterator it = active_streams_.find(stream_id);
     // The stream may actually still be send-stalled after this (due
     // to its own send window) but that's okay -- it'll then be
     // resumed once its send window increases.
     if (it != active_streams_.end())
       it->second.stream->PossiblyResumeIfSendStalled();
@@ skipping 10 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net