LOG(INFO) tidying in net/

net/tools/balsa/balsa_frame.cc

 // Copyright 2013 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/tools/balsa/balsa_frame.h"
 
 #include <assert.h>
 #if __SSE2__
 #include <emmintrin.h>
 #endif  // __SSE2__
@@ skipping 612 matching lines @@
     BalsaHeadersEnums::ContentLengthStatus* status,
     size_t* length) {
   const HeaderLineDescription& header_line = headers_->header_lines_[line_idx];
   const char* stream_begin = headers_->OriginalHeaderStreamBegin();
   const char* line_end = stream_begin + header_line.last_char_idx;
   const char* value_begin = (stream_begin + header_line.value_begin_idx);
 
   if (value_begin >= line_end) {
     // There is no non-whitespace value data.
 #if DEBUGFRAMER
-      LOG(INFO) << "invalid content-length -- no non-whitespace value data";
+      VLOG(0) << "invalid content-length -- no non-whitespace value data";
 #endif
     *status = BalsaHeadersEnums::INVALID_CONTENT_LENGTH;
     return;
   }
 
   *length = 0;
   while (value_begin < line_end) {
     if (*value_begin < '0' || *value_begin > '9') {
       // bad! content-length found, and couldn't parse all of it!
       *status = BalsaHeadersEnums::INVALID_CONTENT_LENGTH;
 #if DEBUGFRAMER
-      LOG(INFO) << "invalid content-length - non numeric character detected";
+      VLOG(0) << "invalid content-length - non numeric character detected";
 #endif  // DEBUGFRAMER
       return;
     }
     const size_t kMaxDiv10 = std::numeric_limits<size_t>::max() / 10;
     size_t length_x_10 = *length * 10;
     const unsigned char c = *value_begin - '0';
     if (*length > kMaxDiv10 ||
         (std::numeric_limits<size_t>::max() - length_x_10) < c) {
       *status = BalsaHeadersEnums::CONTENT_LENGTH_OVERFLOW;
 #if DEBUGFRAMER
-      LOG(INFO) << "content-length overflow";
+      VLOG(0) << "content-length overflow";
 #endif  // DEBUGFRAMER
       return;
     }
     *length = length_x_10 + c;
     ++value_begin;
   }
 #if DEBUGFRAMER
-  LOG(INFO) << "content_length parsed: " << *length;
+  VLOG(0) << "content_length parsed: " << *length;
 #endif  // DEBUGFRAMER
   *status = BalsaHeadersEnums::VALID_CONTENT_LENGTH;
 }
 
 void BalsaFrame::ProcessTransferEncodingLine(HeaderLines::size_type line_idx) {
   const HeaderLineDescription& header_line = headers_->header_lines_[line_idx];
   const char* stream_begin = headers_->OriginalHeaderStreamBegin();
   const char* line_end = stream_begin + header_line.last_char_idx;
   const char* value_begin = stream_begin + header_line.value_begin_idx;
   size_t value_length = line_end - value_begin;
@@ skipping 76 matching lines @@
                                         BalsaHeaders* extensions) {
   ProcessChunkExtensionsManual(base::StringPiece(input, size), extensions);
 }
 
 void BalsaFrame::ProcessHeaderLines() {
   HeaderLines::size_type content_length_idx = 0;
   HeaderLines::size_type transfer_encoding_idx = 0;
 
   DCHECK(!lines_.empty());
 #if DEBUGFRAMER
-  LOG(INFO) << "******@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@**********\n";
+  VLOG(0) << "******@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@**********\n";
 #endif  // DEBUGFRAMER
 
   // There is no need to attempt to process headers if no header lines exist.
   // There are at least two lines in the message which are not header lines.
   // These two non-header lines are the first line of the message, and the
   // last line of the message (which is an empty line).
   // Thus, we test to see if we have more than two lines total before attempting
   // to parse any header lines.
   if (lines_.size() > 2) {
     const char* stream_begin = headers_->OriginalHeaderStreamBegin();
 
     // Then, for the rest of the header data, we parse these into key-value
     // pairs.
     FindColonsAndParseIntoKeyValue();
     // At this point, we've parsed all of the headers.  Time to look for those
     // headers which we require for framing.
     const HeaderLines::size_type
       header_lines_size = headers_->header_lines_.size();
     for (HeaderLines::size_type i = 0; i < header_lines_size; ++i) {
       const HeaderLineDescription& current_header_line =
         headers_->header_lines_[i];
       const char* key_begin =
         (stream_begin + current_header_line.first_char_idx);
       const char* key_end = (stream_begin + current_header_line.key_end_idx);
       const size_t key_len = key_end - key_begin;
       const char c = *key_begin;
 #if DEBUGFRAMER
-      LOG(INFO) << "[" << i << "]: " << std::string(key_begin, key_len)
+      VLOG(0) << "[" << i << "]: " << std::string(key_begin, key_len)
                 << " c: '" << c << "' key_len: " << key_len;
 #endif  // DEBUGFRAMER
       // If a header begins with either lowercase or uppercase 'c' or 't', then
       // the header may be one of content-length, connection, content-encoding
       // or transfer-encoding. These headers are special, as they change the way
       // that the message is framed, and so the framer is required to search
       // for them.
 
 
       if (c == 'c' || c == 'C') {
@@ skipping 204 matching lines @@
           const size_t relative_idx = message_current - message_start;
           const size_t message_current_idx = 1 + base_idx + relative_idx;
           lines_.push_back(std::make_pair(last_slash_n_idx_,
                                           message_current_idx));
           if (lines_.size() == 1) {
             headers_->WriteFromFramer(checkpoint,
                                       1 + message_current - checkpoint);
             checkpoint = message_current + 1;
             const char* begin = headers_->OriginalHeaderStreamBegin();
 #if DEBUGFRAMER
-          LOG(INFO) << "First line " << std::string(begin, lines_[0].second);
-          LOG(INFO) << "is_request_: " << is_request_;
+          VLOG(0) << "First line " << std::string(begin, lines_[0].second);
+          VLOG(0) << "is_request_: " << is_request_;
 #endif
             ProcessFirstLine(begin, begin + lines_[0].second);
             if (parse_state_ == BalsaFrameEnums::MESSAGE_FULLY_READ)
               goto process_lines;
             else if (parse_state_ == BalsaFrameEnums::PARSE_ERROR)
               goto bottom;
           }
           const size_t chars_since_last_slash_n = (message_current_idx -
                                                    last_slash_n_idx_);
           last_slash_n_idx_ = message_current_idx;
@@ skipping 22 matching lines @@
         const size_t relative_idx = message_current - message_start;
         const size_t message_current_idx = 1 + base_idx + relative_idx;
         lines_.push_back(std::make_pair(last_slash_n_idx_,
                                         message_current_idx));
         if (lines_.size() == 1) {
           headers_->WriteFromFramer(checkpoint,
                                     1 + message_current - checkpoint);
           checkpoint = message_current + 1;
           const char* begin = headers_->OriginalHeaderStreamBegin();
 #if DEBUGFRAMER
-          LOG(INFO) << "First line " << std::string(begin, lines_[0].second);
-          LOG(INFO) << "is_request_: " << is_request_;
+          VLOG(0) << "First line " << std::string(begin, lines_[0].second);
+          VLOG(0) << "is_request_: " << is_request_;
 #endif
           ProcessFirstLine(begin, begin + lines_[0].second);
           if (parse_state_ == BalsaFrameEnums::MESSAGE_FULLY_READ)
             goto process_lines;
           else if (parse_state_ == BalsaFrameEnums::PARSE_ERROR)
             goto bottom;
         }
         const size_t chars_since_last_slash_n = (message_current_idx -
                                                  last_slash_n_idx_);
         last_slash_n_idx_ = message_current_idx;
@@ skipping 142 matching lines @@
 // also one label at the bottom of the function. When it is appropriate to
 // return from the function, that part of the state machine instead issues a
 // goto bottom; This results in less code duplication, and makes debugging
 // easier (as you can add a statement to a section of code which is guaranteed
 // to be invoked when the function is exiting.
 size_t BalsaFrame::ProcessInput(const char* input, size_t size) {
   const char* current = input;
   const char* on_entry = current;
   const char* end = current + size;
 #if DEBUGFRAMER
-  LOG(INFO) << "\n=============="
+  VLOG(0) << "\n=============="
             << BalsaFrameEnums::ParseStateToString(parse_state_)
             << "===============\n";
 #endif  // DEBUGFRAMER
 
   DCHECK(headers_ != NULL);
   if (headers_ == NULL) return 0;
 
   if (parse_state_ == BalsaFrameEnums::READING_HEADER_AND_FIRSTLINE) {
     const size_t header_length = headers_->GetReadableBytesFromHeaderStream();
     // Yes, we still have to check this here as the user can change the
@@ skipping 274 matching lines @@
             visitor_->ProcessBodyInput(current, bytes_remaining);
             visitor_->ProcessBodyData(current, bytes_remaining);
             current += bytes_remaining;
           }
         }
         goto bottom;  // case BalsaFrameEnums::READING_UNTIL_CLOSE
 
         // label_reading_content:
       case BalsaFrameEnums::READING_CONTENT:
 #if DEBUGFRAMER
-        LOG(INFO) << "ReadingContent: " << content_length_remaining_;
+        VLOG(0) << "ReadingContent: " << content_length_remaining_;
 #endif  // DEBUGFRAMER
         while (content_length_remaining_ && current < end) {
           // read in the content
           const size_t bytes_remaining = end - current;
           const size_t consumed_bytes =
             (content_length_remaining_ < bytes_remaining) ?
             content_length_remaining_ : bytes_remaining;
           visitor_->ProcessBodyInput(current, consumed_bytes);
           visitor_->ProcessBodyData(current, consumed_bytes);
           current += consumed_bytes;
           content_length_remaining_ -= consumed_bytes;
         }
         if (content_length_remaining_ == 0) {
           parse_state_ = BalsaFrameEnums::MESSAGE_FULLY_READ;
           visitor_->MessageDone();
         }
         goto bottom;  // case BalsaFrameEnums::READING_CONTENT
 
       default:
         // The state-machine should never be in a state that isn't handled
         // above.  This is a glaring logic error, and we should do something
         // drastic to ensure that this gets looked-at and fixed.
         LOG(FATAL) << "Unknown state: " << parse_state_  // COV_NF_LINE
           << " memory corruption?!";                     // COV_NF_LINE
     }
   }
  bottom:
 #if DEBUGFRAMER
-  LOG(INFO) << "\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\n"
+  VLOG(0) << "\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\n"
     << std::string(input, current)
     << "\n$$$$$$$$$$$$$$"
     << BalsaFrameEnums::ParseStateToString(parse_state_)
     << "$$$$$$$$$$$$$$$"
     << " consumed: " << (current - input);
   if (Error()) {
-    LOG(INFO) << BalsaFrameEnums::ErrorCodeToString(ErrorCode());
+    VLOG(0) << BalsaFrameEnums::ErrorCodeToString(ErrorCode());
   }
 #endif  // DEBUGFRAMER
   return current - input;
 }
 
 const uint32 BalsaFrame::kValidTerm1;
 const uint32 BalsaFrame::kValidTerm1Mask;
 const uint32 BalsaFrame::kValidTerm2;
 const uint32 BalsaFrame::kValidTerm2Mask;
 
 }  // namespace net