LOG(INFO) tidying in net/

net/spdy/spdy_framer.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.
 
 // TODO(rtenhove) clean up frame buffer size calculations so that we aren't
 // constantly adding and subtracting header sizes; this is ugly and error-
 // prone.
 
 #include "net/spdy/spdy_framer.h"
 
@@ skipping 43 matching lines @@
 const SpdyStreamId SpdyFramer::kInvalidStream = -1;
 const size_t SpdyFramer::kHeaderDataChunkMaxSize = 1024;
 // The size of the control frame buffer. Must be >= the minimum size of the
 // largest control frame, which is SYN_STREAM. See GetSynStreamMinimumSize() for
 // calculation details.
 const size_t SpdyFramer::kControlFrameBufferSize = 18;
 
 #ifdef DEBUG_SPDY_STATE_CHANGES
 #define CHANGE_STATE(newstate)                                  \
   do {                                                          \
-    LOG(INFO) << "Changing state from: "                        \
+    VLOG(0) << "Changing state from: "                        \
               << StateToString(state_)                          \
               << " to " << StateToString(newstate) << "\n";     \
     DCHECK(state_ != SPDY_ERROR);                               \
     DCHECK_EQ(previous_state_, state_);                         \
     previous_state_ = state_;                                   \
     state_ = newstate;                                          \
   } while (false)
 #else
 #define CHANGE_STATE(newstate)                                  \
   do {                                                          \
@@ skipping 570 matching lines @@
         if (current_frame_flags_ & DATA_FLAG_FIN) {
           visitor_->OnStreamFrameData(
               current_frame_stream_id_, NULL, 0, true);
         }
         CHANGE_STATE(SPDY_AUTO_RESET);
       }
     }
   } else if (version != spdy_version_) {
     // We check version before we check validity: version can never be
     // 'invalid', it can only be unsupported.
-    DLOG(INFO) << "Unsupported SPDY version " << version
+    DVLOG(0) << "Unsupported SPDY version " << version
                << " (expected " << spdy_version_ << ")";
     set_error(SPDY_UNSUPPORTED_VERSION);
   } else {
     ProcessControlFrameHeader(control_frame_type_field);
   }
 
   return original_len - len;
 }
 
 void SpdyFramer::ProcessControlFrameHeader(uint16 control_frame_type_field) {
   DCHECK_EQ(SPDY_NO_ERROR, error_code_);
   DCHECK_LE(GetControlFrameHeaderSize(), current_frame_buffer_length_);
 
   if (control_frame_type_field < FIRST_CONTROL_TYPE ||
       control_frame_type_field > LAST_CONTROL_TYPE) {
     set_error(SPDY_INVALID_CONTROL_FRAME);
     return;
   }
 
   current_frame_type_ = static_cast<SpdyFrameType>(control_frame_type_field);
 
   if (current_frame_type_ == NOOP) {
-    DLOG(INFO) << "NOOP control frame found. Ignoring.";
+    DVLOG(0) << "NOOP control frame found. Ignoring.";
     CHANGE_STATE(SPDY_AUTO_RESET);
     return;
   }
 
   // Do some sanity checking on the control frame sizes and flags.
   switch (current_frame_type_) {
     case SYN_STREAM:
       if (current_frame_length_ < GetSynStreamMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ &
@@ skipping 821 matching lines @@
 size_t SpdyFramer::ParseHeaderBlockInBuffer(const char* header_data,
                                           size_t header_length,
                                           SpdyHeaderBlock* block) const {
   SpdyFrameReader reader(header_data, header_length);
 
   // Read number of headers.
   uint32 num_headers;
   if (spdy_version_ < 3) {
     uint16 temp;
     if (!reader.ReadUInt16(&temp)) {
-      DLOG(INFO) << "Unable to read number of headers.";
+      DVLOG(0) << "Unable to read number of headers.";
       return 0;
     }
     num_headers = temp;
   } else {
     if (!reader.ReadUInt32(&num_headers)) {
-      DLOG(INFO) << "Unable to read number of headers.";
+      DVLOG(0) << "Unable to read number of headers.";
       return 0;
     }
   }
 
   // Read each header.
   for (uint32 index = 0; index < num_headers; ++index) {
     base::StringPiece temp;
 
     // Read header name.
     if ((spdy_version_ < 3) ? !reader.ReadStringPiece16(&temp)
                             : !reader.ReadStringPiece32(&temp)) {
-      DLOG(INFO) << "Unable to read header name (" << index + 1 << " of "
+      DVLOG(0) << "Unable to read header name (" << index + 1 << " of "
                  << num_headers << ").";
       return 0;
     }
     std::string name = temp.as_string();
 
     // Read header value.
     if ((spdy_version_ < 3) ? !reader.ReadStringPiece16(&temp)
                             : !reader.ReadStringPiece32(&temp)) {
-      DLOG(INFO) << "Unable to read header value (" << index + 1 << " of "
+      DVLOG(0) << "Unable to read header value (" << index + 1 << " of "
                  << num_headers << ").";
       return 0;
     }
     std::string value = temp.as_string();
 
     // Ensure no duplicates.
     if (block->find(name) != block->end()) {
-      DLOG(INFO) << "Duplicate header '" << name << "' (" << index + 1 << " of "
+      DVLOG(0) << "Duplicate header '" << name << "' (" << index + 1 << " of "
                  << num_headers << ").";
       return 0;
     }
 
     // Store header.
     (*block)[name] = value;
   }
   return reader.GetBytesConsumed();
 }
 
@@ skipping 786 matching lines @@
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 
   pre_compress_bytes.Add(uncompressed_len);
   post_compress_bytes.Add(compressed_size);
 
   compressed_frames.Increment();
 }
 
 }  // namespace net