Add quic_logging

net/quic/core/quic_stream_sequencer_test.cc

 // Copyright (c) 2012 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.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <memory>
 #include <utility>
 #include <vector>
 
-#include "base/logging.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_stream.h"
 #include "net/quic/core/quic_utils.h"
+#include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_stream_sequencer_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 base::StringPiece;
 using std::string;
@@ skipping 81 matching lines @@
                        expected[0].substr(start_position, iovecs[i].iov_len))) {
         return false;
       }
       start_position += iovecs[i].iov_len;
     }
     return true;
   }
 
   bool VerifyIovec(const iovec& iovec, StringPiece expected) {
     if (iovec.iov_len != expected.length()) {
-      LOG(ERROR) << "Invalid length: " << iovec.iov_len << " vs "
-                 << expected.length();
+      QUIC_LOG(ERROR) << "Invalid length: " << iovec.iov_len << " vs "
+                      << expected.length();
       return false;
     }
     if (memcmp(iovec.iov_base, expected.data(), expected.length()) != 0) {
-      LOG(ERROR) << "Invalid data: " << static_cast<char*>(iovec.iov_base)
-                 << " vs " << expected;
+      QUIC_LOG(ERROR) << "Invalid data: " << static_cast<char*>(iovec.iov_base)
+                      << " vs " << expected;
       return false;
     }
     return true;
   }
 
   void OnFinFrame(QuicStreamOffset byte_offset, const char* data) {
     QuicStreamFrame frame;
     frame.stream_id = 1;
     frame.offset = byte_offset;
     frame.data_buffer = data;
@@ skipping 295 matching lines @@
 // Infinite buffering, so all frames are acked right away.
 TEST_F(QuicSequencerRandomTest, RandomFramesNoDroppingNoBackup) {
   InSequence s;
   EXPECT_CALL(stream_, OnDataAvailable())
       .Times(AnyNumber())
       .WillRepeatedly(
           Invoke(this, &QuicSequencerRandomTest::ReadAvailableData));
 
   while (!list_.empty()) {
     int index = OneToN(list_.size()) - 1;
-    LOG(ERROR) << "Sending index " << index << " " << list_[index].second;
+    QUIC_LOG(ERROR) << "Sending index " << index << " " << list_[index].second;
     OnFrame(list_[index].first, list_[index].second.data());
 
     list_.erase(list_.begin() + index);
   }
 
   ASSERT_EQ(arraysize(kPayload) - 1, output_.size());
   EXPECT_EQ(kPayload, output_);
 }
 
 TEST_F(QuicSequencerRandomTest, RandomFramesNoDroppingBackup) {
@@ skipping 220 matching lines @@
   source.set(nullptr, 5u);
   QuicStreamFrame frame(kClientDataStreamId1, false, 1, source);
   EXPECT_CALL(stream_, CloseConnectionWithDetails(
                            QUIC_STREAM_SEQUENCER_INVALID_STATE, _));
   sequencer_->OnStreamFrame(frame);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net