SPDY: Minor code cleanup.

net/spdy/spdy_session.cc

 // Copyright (c) 2010 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 "base/basictypes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
@@ skipping 542 matching lines @@
       spdy_framer_.Reset();
   }
 
   if (state_ != CLOSED)
     ReadSocket();
 }
 
 void SpdySession::OnWriteComplete(int result) {
   DCHECK(write_pending_);
   DCHECK(in_flight_write_.size());
-  DCHECK(result != 0);  // This shouldn't happen for write.
+  DCHECK_NE(result, 0);  // This shouldn't happen for write.
 
   write_pending_ = false;
 
   scoped_refptr<SpdyStream> stream = in_flight_write_.stream();
 
   LOG(INFO) << "Spdy write complete (result=" << result << ")"
-            << (stream ? " for stream " + stream->stream_id() : "");
+            << (stream ? std::string(" for stream ") +
+                IntToString(stream->stream_id()) : "");
 
   if (result >= 0) {
     // It should not be possible to have written more bytes than our
     // in_flight_write_.
     DCHECK_LE(result, in_flight_write_.buffer()->BytesRemaining());
 
     in_flight_write_.buffer()->DidConsume(result);
 
     // We only notify the stream when we've fully written the pending frame.
     if (!in_flight_write_.buffer()->BytesRemaining()) {
@@ skipping 87 matching lines @@
   // again when the socket connection completes.  If the socket is
   // closed, just return.
   if (state_ < CONNECTED || state_ == CLOSED)
     return;
 
   if (write_pending_)   // Another write is in progress still.
     return;
 
   // Loop sending frames until we've sent everything or until the write
   // returns error (or ERR_IO_PENDING).
-  while (in_flight_write_.buffer() || queue_.size()) {
+  while (in_flight_write_.buffer() || !queue_.empty()) {
     if (!in_flight_write_.buffer()) {
       // Grab the next SpdyFrame to send.
       SpdyIOBuffer next_buffer = queue_.top();
       queue_.pop();
 
       // We've deferred compression until just before we write it to the socket,
       // which is now.  At this time, we don't compress our data frames.
       spdy::SpdyFrame uncompressed_frame(next_buffer.buffer()->data(), false);
       size_t size;
       if (spdy_framer_.IsCompressible(&uncompressed_frame)) {
         scoped_ptr<spdy::SpdyFrame> compressed_frame(
             spdy_framer_.CompressFrame(&uncompressed_frame));
         if (!compressed_frame.get()) {
           LOG(ERROR) << "SPDY Compression failure";
           CloseSessionOnError(net::ERR_SPDY_PROTOCOL_ERROR);
           return;
         }
 
         size = compressed_frame->length() + spdy::SpdyFrame::size();
 
-        DCHECK(size > 0);
+        DCHECK_GT(size, 0u);
 
         // TODO(mbelshe): We have too much copying of data here.
         IOBufferWithSize* buffer = new IOBufferWithSize(size);
         memcpy(buffer->data(), compressed_frame->data(), size);
 
         // Attempt to send the frame.
         in_flight_write_ = SpdyIOBuffer(buffer, size, 0, next_buffer.stream());
       } else {
         size = uncompressed_frame.length() + spdy::SpdyFrame::size();
         in_flight_write_ = next_buffer;
@@ skipping 413 matching lines @@
   if (settings.empty())
     return;
 
   // Create the SETTINGS frame and send it.
   scoped_ptr<spdy::SpdySettingsControlFrame> settings_frame(
       spdy_framer_.CreateSettings(settings));
   QueueFrame(settings_frame.get(), 0, NULL);
 }
 
 }  // namespace net