Add quic_logging

net/quic/core/quic_stream_sequencer_buffer_test.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_stream_sequencer_buffer.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <string>
 #include <utility>
 
-#include "base/logging.h"
 #include "base/macros.h"
+#include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_str_cat.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_stream_sequencer_buffer_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::string;
@@ skipping 292 matching lines @@
   QuicTime t2 = clock_.ApproximateNow();
   // Write something into [0, 100).
   buffer_->OnStreamData(0, source, t2, &written, &error_details_);
   EXPECT_TRUE(buffer_->HasBytesToRead());
   EXPECT_EQ(2u, helper_->frame_arrival_time_map()->size());
   // Read into a iovec array with total capacity of 120 bytes.
   char dest[120];
   iovec iovecs[3]{iovec{dest, 40}, iovec{dest + 40, 40}, iovec{dest + 80, 40}};
   size_t read;
   EXPECT_EQ(QUIC_NO_ERROR, buffer_->Readv(iovecs, 3, &read, &error_details_));
-  LOG(ERROR) << error_details_;
+  QUIC_LOG(ERROR) << error_details_;
   EXPECT_EQ(100u, read);
   EXPECT_EQ(100u, buffer_->BytesConsumed());
   EXPECT_EQ(source, string(dest, read));
   EXPECT_EQ(1u, helper_->frame_arrival_time_map()->size());
   // The first block should be released as its data has been read out.
   EXPECT_EQ(nullptr, helper_->GetBlock(0));
   EXPECT_TRUE(helper_->CheckBufferInvariants());
 }
 
 TEST_F(QuicStreamSequencerBufferTest, ReadvAcrossBlocks) {
@@ skipping 477 matching lines @@
   void SetUp() override {
     // Test against a larger capacity then above tests. Also make sure the last
     // block is partially available to use.
     max_capacity_bytes_ = 6.25 * kBlockSizeBytes;
     // Stream to be buffered should be larger than the capacity to test wrap
     // around.
     bytes_to_buffer_ = 2 * max_capacity_bytes_;
     Initialize();
 
     uint64_t seed = QuicRandom::GetInstance()->RandUint64();
-    VLOG(1) << "**** The current seed is " << seed << " ****";
+    QUIC_LOG(INFO) << "**** The current seed is " << seed << " ****";
     rng_.set_seed(seed);
   }
 
   // Create an out-of-order source stream with given size to populate
   // shuffled_buf_.
   void CreateSourceAndShuffle(size_t max_chunk_size_bytes) {
     max_chunk_size_bytes_ = max_chunk_size_bytes;
     std::unique_ptr<OffsetSizePair[]> chopped_stream(
         new OffsetSizePair[bytes_to_buffer_]);
 
@@ skipping 10 matching lines @@
       start_chopping_offset += chunk_size;
       ++iterations;
     }
     DCHECK(start_chopping_offset == bytes_to_buffer_);
     size_t chunk_num = iterations;
 
     // Randomly change the sequence of in-ordered OffsetSizePairs to make a
     // out-of-order array of OffsetSizePairs.
     for (int i = chunk_num - 1; i >= 0; --i) {
       size_t random_idx = rng_.RandUint64() % (i + 1);
-      DVLOG(1) << "chunk offset " << chopped_stream[random_idx].first
-               << " size " << chopped_stream[random_idx].second;
+      QUIC_DVLOG(1) << "chunk offset " << chopped_stream[random_idx].first
+                    << " size " << chopped_stream[random_idx].second;
       shuffled_buf_.push_front(chopped_stream[random_idx]);
       chopped_stream[random_idx] = chopped_stream[i];
     }
   }
 
   // Write the currently first chunk of data in the out-of-order stream into
   // QuicStreamSequencerBuffer. If current chuck cannot be written into buffer
   // because it goes beyond current capacity, move it to the end of
   // shuffled_buf_ and write it later.
   void WriteNextChunkToBuffer() {
@@ skipping 10 matching lines @@
         buffer_->OnStreamData(offset, string_piece_w, clock_.ApproximateNow(),
                               &written, &error_details_);
     if (result == QUIC_NO_ERROR) {
       shuffled_buf_.pop_front();
       total_bytes_written_ += num_to_write;
     } else {
       // This chunk offset exceeds window size.
       shuffled_buf_.push_back(chunk);
       shuffled_buf_.pop_front();
     }
-    DVLOG(1) << " write at offset: " << offset
-             << " len to write: " << num_to_write << " write result: " << result
-             << " left over: " << shuffled_buf_.size();
+    QUIC_DVLOG(1) << " write at offset: " << offset
+                  << " len to write: " << num_to_write
+                  << " write result: " << result
+                  << " left over: " << shuffled_buf_.size();
   }
 
  protected:
   std::list<OffsetSizePair> shuffled_buf_;
   size_t max_chunk_size_bytes_;
   QuicStreamOffset bytes_to_buffer_;
   size_t total_bytes_written_ = 0;
   size_t total_bytes_read_ = 0;
   SimpleRandom rng_;
 };
 
 TEST_F(QuicStreamSequencerBufferRandomIOTest, RandomWriteAndReadv) {
   // Set kMaxReadSize larger than kBlockSizeBytes to test both small and large
   // read.
   const size_t kMaxReadSize = kBlockSizeBytes * 2;
   // kNumReads is larger than 1 to test how multiple read destinations work.
   const size_t kNumReads = 2;
   // Since write and read operation have equal possibility to be called. Bytes
   // to be written into and read out of should roughly the same.
   const size_t kMaxWriteSize = kNumReads * kMaxReadSize;
   size_t iterations = 0;
 
   CreateSourceAndShuffle(kMaxWriteSize);
 
   while ((!shuffled_buf_.empty() || total_bytes_read_ < bytes_to_buffer_) &&
          iterations <= 2 * bytes_to_buffer_) {
     uint8_t next_action =
         shuffled_buf_.empty() ? uint8_t{1} : rng_.RandUint64() % 2;
-    DVLOG(1) << "iteration: " << iterations;
+    QUIC_DVLOG(1) << "iteration: " << iterations;
     switch (next_action) {
       case 0: {  // write
         WriteNextChunkToBuffer();
         ASSERT_TRUE(helper_->CheckBufferInvariants());
         break;
       }
       case 1: {  // readv
         std::unique_ptr<char[][kMaxReadSize]> read_buf{
             new char[kNumReads][kMaxReadSize]};
         iovec dest_iov[kNumReads];
         size_t num_to_read = 0;
         for (size_t i = 0; i < kNumReads; ++i) {
           dest_iov[i].iov_base =
               reinterpret_cast<void*>(const_cast<char*>(read_buf[i]));
           dest_iov[i].iov_len = rng_.RandUint64() % kMaxReadSize;
           num_to_read += dest_iov[i].iov_len;
         }
         size_t actually_read;
         EXPECT_EQ(QUIC_NO_ERROR,
                   buffer_->Readv(dest_iov, kNumReads, &actually_read,
                                  &error_details_));
         ASSERT_LE(actually_read, num_to_read);
-        DVLOG(1) << " read from offset: " << total_bytes_read_
-                 << " size: " << num_to_read
-                 << " actual read: " << actually_read;
+        QUIC_DVLOG(1) << " read from offset: " << total_bytes_read_
+                      << " size: " << num_to_read
+                      << " actual read: " << actually_read;
         for (size_t i = 0; i < actually_read; ++i) {
           char ch = (i + total_bytes_read_) % 256;
           ASSERT_EQ(ch, GetCharFromIOVecs(i, dest_iov, kNumReads))
               << " at iteration " << iterations;
         }
         total_bytes_read_ += actually_read;
         ASSERT_EQ(total_bytes_read_, buffer_->BytesConsumed());
         ASSERT_TRUE(helper_->CheckBufferInvariants());
         break;
       }
@@ skipping 15 matching lines @@
   const size_t kMaxWriteSize = kMaxNumReads * kBlockSizeBytes;
   ASSERT_LE(kMaxWriteSize, max_capacity_bytes_);
   size_t iterations = 0;
 
   CreateSourceAndShuffle(kMaxWriteSize);
 
   while ((!shuffled_buf_.empty() || total_bytes_read_ < bytes_to_buffer_) &&
          iterations <= 2 * bytes_to_buffer_) {
     uint8_t next_action =
         shuffled_buf_.empty() ? uint8_t{1} : rng_.RandUint64() % 2;
-    DVLOG(1) << "iteration: " << iterations;
+    QUIC_DVLOG(1) << "iteration: " << iterations;
     switch (next_action) {
       case 0: {  // write
         WriteNextChunkToBuffer();
         ASSERT_TRUE(helper_->CheckBufferInvariants());
         break;
       }
       case 1: {  // GetReadableRegions and then MarkConsumed
         size_t num_read = rng_.RandUint64() % kMaxNumReads + 1;
         iovec dest_iov[kMaxNumReads];
         ASSERT_TRUE(helper_->CheckBufferInvariants());
@@ skipping 19 matching lines @@
                 (buffer_->BytesConsumed() + bytes_processed) % 256;
             ASSERT_EQ(char_expected,
                       reinterpret_cast<const char*>(dest_iov[i].iov_base)[j])
                 << " at iteration " << iterations;
             ++bytes_processed;
           }
         }
 
         buffer_->MarkConsumed(bytes_processed);
 
-        DVLOG(1) << "iteration " << iterations << ": try to get " << num_read
-                 << " readable regions, actually get " << actually_num_read
-                 << " from offset: " << total_bytes_read_
-                 << "\nprocesse bytes: " << bytes_processed;
+        QUIC_DVLOG(1) << "iteration " << iterations << ": try to get "
+                      << num_read << " readable regions, actually get "
+                      << actually_num_read
+                      << " from offset: " << total_bytes_read_
+                      << "\nprocesse bytes: " << bytes_processed;
         total_bytes_read_ += bytes_processed;
         ASSERT_EQ(total_bytes_read_, buffer_->BytesConsumed());
         ASSERT_TRUE(helper_->CheckBufferInvariants());
         break;
       }
     }
     ++iterations;
     ASSERT_LE(total_bytes_read_, total_bytes_written_);
   }
   EXPECT_LT(iterations, bytes_to_buffer_) << "runaway test";
   EXPECT_LE(bytes_to_buffer_, total_bytes_read_) << "iterations: "
                                                  << iterations;
   EXPECT_LE(bytes_to_buffer_, total_bytes_written_);
 }
 
 }  // anonymous namespace
 
 }  // namespace test
 
 }  // namespace net