Add quic_logging

net/quic/core/quic_headers_stream_test.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/quic/core/quic_headers_stream.h"
 
 #include <cstdint>
 #include <ostream>
 #include <string>
 #include <tuple>
 #include <utility>
 
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/core/spdy_utils.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"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_stream_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/spdy/spdy_alt_svc_wire_format.h"
 #include "net/spdy/spdy_flags.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "net/test/gtest_util.h"
@@ skipping 166 matching lines @@
     switch (hpack_decoder) {
       case HPACK_DECODER_SPDY:
         FLAGS_spdy_use_hpack_decoder2 = false;
         break;
       case HPACK_DECODER_NEW:
         FLAGS_spdy_use_hpack_decoder2 = true;
         // Needs new header methods to be used.
         FLAGS_spdy_framer_use_new_methods4 = true;
         break;
     }
-    VLOG(1) << "TestParams: version: " << QuicVersionToString(version)
-            << ", perspective: " << perspective
-            << ", http2_decoder: " << http2_decoder
-            << ", hpack_decoder: " << hpack_decoder;
+    QUIC_LOG(INFO) << "TestParams: version: " << QuicVersionToString(version)
+                   << ", perspective: " << perspective
+                   << ", http2_decoder: " << http2_decoder
+                   << ", hpack_decoder: " << hpack_decoder;
   }
 
   QuicVersion version;
   Perspective perspective;
   Http2DecoderChoice http2_decoder;
   HpackDecoderChoice hpack_decoder;
 };
 
 class QuicHeadersStreamTest : public ::testing::TestWithParam<TestParamsTuple> {
  public:
@@ skipping 385 matching lines @@
         EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0)).Times(1);
       } else {
         SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
         headers_frame.set_fin(fin);
         frames[stream_num] = framer_->SerializeFrame(headers_frame);
       }
       stream_frames[stream_num].stream_id = stream_frame_.stream_id;
       stream_frames[stream_num].offset = stream_frame_.offset;
       stream_frames[stream_num].data_buffer = frames[stream_num].data();
       stream_frames[stream_num].data_length = frames[stream_num].size();
-      DVLOG(1) << "make frame for stream " << stream_num << " offset "
-               << stream_frames[stream_num].offset;
+      QUIC_DVLOG(1) << "make frame for stream " << stream_num << " offset "
+                    << stream_frames[stream_num].offset;
       stream_frame_.offset += frames[stream_num].size();
       EXPECT_CALL(session_, OnStreamHeaderList(stream_id, fin, _, _)).Times(1);
     }
   }
 
   // Actually writing the frames in reverse order will cause HOL blocking.
   EXPECT_CALL(session_, OnHeadersHeadOfLineBlocking(_)).Times(9);
 
   for (int stream_num = 9; stream_num >= 0; --stream_num) {
-    DVLOG(1) << "OnStreamFrame for stream " << stream_num << " offset "
-             << stream_frames[stream_num].offset;
+    QUIC_DVLOG(1) << "OnStreamFrame for stream " << stream_num << " offset "
+                  << stream_frames[stream_num].offset;
     headers_stream_->OnStreamFrame(stream_frames[stream_num]);
     connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
   }
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessLargeRawData) {
   QuicSpdySessionPeer::SetMaxUncompressedHeaderBytes(&session_, 256 * 1024);
   // We want to create a frame that is more than the SPDY Framer's max control
   // frame size, which is 16K, but less than the HPACK decoders max decode
   // buffer size, which is 32K.
@@ skipping 408 matching lines @@
   consumed_data = session_.WritevStreamData(id, MakeIOVector(data, &iov),
                                             offset, fin, nullptr);
 
   EXPECT_EQ(consumed_data.bytes_consumed, 0u);
   EXPECT_EQ(consumed_data.fin_consumed, false);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net