Revert of Add quic_logging

net/quic/core/quic_spdy_session.cc

 // Copyright (c) 2015 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/quic/core/quic_spdy_session.h"
 
 #include <utility>
 
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_headers_stream.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
-#include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_str_cat.h"
 
 using base::StringPiece;
 using std::string;
 
 namespace net {
 
 namespace {
 
 class HeaderTableDebugVisitor
     : public HpackHeaderTable::DebugVisitorInterface {
  public:
   HeaderTableDebugVisitor(const QuicClock* clock,
                           std::unique_ptr<QuicHpackDebugVisitor> visitor)
       : clock_(clock), headers_stream_hpack_visitor_(std::move(visitor)) {}
 
   int64_t OnNewEntry(const HpackEntry& entry) override {
-    QUIC_DVLOG(1) << entry.GetDebugString();
+    DVLOG(1) << entry.GetDebugString();
     return (clock_->ApproximateNow() - QuicTime::Zero()).ToMicroseconds();
   }
 
   void OnUseEntry(const HpackEntry& entry) override {
     const QuicTime::Delta elapsed(
         clock_->ApproximateNow() -
         QuicTime::Delta::FromMicroseconds(entry.time_added()) -
         QuicTime::Zero());
-    QUIC_DVLOG(1) << entry.GetDebugString() << " " << elapsed.ToMilliseconds()
-                  << " ms";
+    DVLOG(1) << entry.GetDebugString() << " " << elapsed.ToMilliseconds()
+             << " ms";
     headers_stream_hpack_visitor_->OnUseEntry(elapsed);
   }
 
  private:
   const QuicClock* clock_;
   std::unique_ptr<QuicHpackDebugVisitor> headers_stream_hpack_visitor_;
 
   DISALLOW_COPY_AND_ASSIGN(HeaderTableDebugVisitor);
 };
 
@@ skipping 213 matching lines @@
   // SpdyFramerDebugVisitorInterface implementation
   void OnSendCompressedFrame(SpdyStreamId stream_id,
                              SpdyFrameType type,
                              size_t payload_len,
                              size_t frame_len) override {
     if (payload_len == 0) {
       QUIC_BUG << "Zero payload length.";
       return;
     }
     int compression_pct = 100 - (100 * frame_len) / payload_len;
-    QUIC_DVLOG(1) << "Net.QuicHpackCompressionPercentage: " << compression_pct;
+    DVLOG(1) << "Net.QuicHpackCompressionPercentage: " << compression_pct;
   }
 
   void OnReceiveCompressedFrame(SpdyStreamId stream_id,
                                 SpdyFrameType type,
                                 size_t frame_len) override {
     if (session_->IsConnected()) {
       session_->OnCompressedFrameSize(frame_len);
     }
   }
 
@@ skipping 304 matching lines @@
                                         const char* data,
                                         size_t len,
                                         bool fin) {
   QuicSpdyStream* stream = GetSpdyDataStream(stream_id);
   if (stream == nullptr) {
     return;
   }
   const QuicStreamOffset offset =
       stream->flow_controller()->highest_received_byte_offset();
   const QuicStreamFrame frame(stream_id, fin, offset, StringPiece(data, len));
-  QUIC_DVLOG(1) << "De-encapsulating DATA frame for stream " << stream_id
-                << " offset " << offset << " len " << len << " fin " << fin;
+  DVLOG(1) << "De-encapsulating DATA frame for stream " << stream_id
+           << " offset " << offset << " len " << len << " fin " << fin;
   OnStreamFrame(frame);
 }
 
 bool QuicSpdySession::ShouldReleaseHeadersStreamSequencerBuffer() {
   return false;
 }
 
 void QuicSpdySession::OnHeaders(SpdyStreamId stream_id,
                                 bool has_priority,
                                 SpdyPriority priority,
@@ skipping 21 matching lines @@
 void QuicSpdySession::OnPushPromise(SpdyStreamId stream_id,
                                     SpdyStreamId promised_stream_id,
                                     bool end) {
   DCHECK_EQ(kInvalidStreamId, stream_id_);
   DCHECK_EQ(kInvalidStreamId, promised_stream_id_);
   stream_id_ = stream_id;
   promised_stream_id_ = promised_stream_id;
 }
 
 void QuicSpdySession::OnHeaderList(const QuicHeaderList& header_list) {
-  QUIC_DVLOG(1) << "Received header list for stream " << stream_id_ << ": "
-                << header_list.DebugString();
+  DVLOG(1) << "Received header list for stream " << stream_id_ << ": "
+           << header_list.DebugString();
   if (prev_max_timestamp_ > cur_max_timestamp_) {
     // prev_max_timestamp_ > cur_max_timestamp_ implies that
     // headers from lower numbered streams actually came off the
     // wire after headers for the current stream, hence there was
     // HOL blocking.
     QuicTime::Delta delta = prev_max_timestamp_ - cur_max_timestamp_;
-    QUIC_DLOG(INFO) << "stream " << stream_id_
-                    << ": Net.QuicSession.HeadersHOLBlockedTime "
-                    << delta.ToMilliseconds();
+    DVLOG(1) << "stream " << stream_id_
+               << ": Net.QuicSession.HeadersHOLBlockedTime "
+               << delta.ToMilliseconds();
     OnHeadersHeadOfLineBlocking(delta);
   }
   prev_max_timestamp_ = std::max(prev_max_timestamp_, cur_max_timestamp_);
   cur_max_timestamp_ = QuicTime::Zero();
   if (promised_stream_id_ == kInvalidStreamId) {
     OnStreamHeaderList(stream_id_, fin_, frame_len_, header_list);
   } else {
     OnPromiseHeaderList(stream_id_, promised_stream_id_, frame_len_,
                         header_list);
   }
@@ skipping 37 matching lines @@
 
 bool QuicSpdySession::OnDataFrameHeader(QuicStreamId stream_id,
                                         size_t length,
                                         bool fin) {
   if (!force_hol_blocking()) {
     return false;
   }
   if (!IsConnected()) {
     return true;
   }
-  QUIC_DVLOG(1) << "DATA frame header for stream " << stream_id << " length "
-                << length << " fin " << fin;
+  DVLOG(1) << "DATA frame header for stream " << stream_id << " length "
+           << length << " fin " << fin;
   fin_ = fin;
   frame_len_ = length;
   if (fin && length == 0) {
     OnStreamFrameData(stream_id, "", 0);
   }
   return true;
 }
 
 bool QuicSpdySession::OnStreamFrameData(QuicStreamId stream_id,
                                         const char* data,
@@ skipping 16 matching lines @@
       set_max_uncompressed_header_bytes);
 }
 
 void QuicSpdySession::CloseConnectionWithDetails(QuicErrorCode error,
                                                  const string& details) {
   connection()->CloseConnection(
       error, details, ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
 }
 
 }  // namespace net