Reducing the debug output spam.

net/spdy/spdy_stream.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_stream.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
@@ skipping 133 matching lines @@
   return ERR_IO_PENDING;
 }
 
 int SpdyStream::SendRequest(UploadDataStream* upload_data,
                             HttpResponseInfo* response,
                             CompletionCallback* callback) {
   CHECK(callback);
   CHECK(!cancelled_);
   CHECK(response);
 
-  DLOG(INFO) << "  * " << __FUNCTION__ << "()";
-
   if (response_) {
     *response = *response_;
     delete response_;
   }
   response_ = response;
 
   if (upload_data) {
     if (upload_data->size())
       request_body_stream_.reset(upload_data);
     else
@@ skipping 21 matching lines @@
 }
 
 void SpdyStream::Cancel() {
   cancelled_ = true;
   user_callback_ = NULL;
 
   session_->CancelStream(stream_id_);
 }
 
 void SpdyStream::OnResponseReceived(const HttpResponseInfo& response) {
-  DLOG(INFO) << "  >> " << __FUNCTION__ << "()";
   metrics_.StartStream();
 
   CHECK(!response_->headers);
 
   *response_ = response;  // TODO(mbelshe): avoid copy.
   DCHECK(response_->headers);
 
   recv_first_byte_time_ = base::TimeTicks::Now();
 
   if (io_state_ == STATE_NONE) {
@@ skipping 11 matching lines @@
     NOTREACHED();
   }
 
   int rv = DoLoop(OK);
 
   if (user_callback_)
     DoCallback(rv);
 }
 
 bool SpdyStream::OnDataReceived(const char* data, int length) {
-  DLOG(INFO) << "  >> " << __FUNCTION__ << "()";
   DCHECK_GE(length, 0);
   LOG(INFO) << "SpdyStream: Data (" << length << " bytes) received for "
             << stream_id_;
 
   CHECK(!response_complete_);
 
   // If we don't have a response, then the SYN_REPLY did not come through.
   // We cannot pass data up to the caller unless the reply headers have been
   // received.
   if (!response_->headers) {
@@ skipping 30 matching lines @@
   if (user_buffer_) {
     // Handing small chunks of data to the caller creates measurable overhead.
     // We buffer data in short time-spans and send a single read notification.
     ScheduleBufferedReadCallback();
   }
 
   return true;
 }
 
 void SpdyStream::OnWriteComplete(int status) {
-  DLOG(INFO) << "  >> " << __FUNCTION__ << "()";
   // TODO(mbelshe): Check for cancellation here.  If we're cancelled, we
   // should discontinue the DoLoop.
 
   if (status > 0)
     send_bytes_ += status;
 
   DoLoop(status);
 }
 
 void SpdyStream::OnClose(int status) {
-  DLOG(INFO) << "  >> " << __FUNCTION__ << "()";
   response_complete_ = true;
   response_status_ = status;
   stream_id_ = 0;
 
   if (user_callback_)
     DoCallback(status);
 
   UpdateHistograms();
 }
 
 int SpdyStream::DoLoop(int result) {
   do {
-    DLOG(INFO) << "  * " << __FUNCTION__ << "() state = " << io_state_
-        << " result = " << result;
     State state = io_state_;
     io_state_ = STATE_NONE;
     switch (state) {
       // State machine 1: Send headers and wait for response headers.
       case STATE_SEND_HEADERS:
         CHECK_EQ(OK, result);
         net_log_.BeginEvent(NetLog::TYPE_SPDY_STREAM_SEND_HEADERS);
         result = DoSendHeaders();
         break;
       case STATE_SEND_HEADERS_COMPLETE:
@@ skipping 206 matching lines @@
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamDownloadTime",
       recv_last_byte_time_ - recv_first_byte_time_);
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamTime",
       recv_last_byte_time_ - send_time_);
 
   UMA_HISTOGRAM_COUNTS("Net.SpdySendBytes", send_bytes_);
   UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_);
 }
 
 }  // namespace net