Add quic_logging

net/quic/core/congestion_control/bbr_sender_test.cc

 // Copyright 2016 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/congestion_control/bbr_sender.h"
 
 #include <algorithm>
 #include <map>
 #include <memory>
 
-#include "base/logging.h"
 #include "net/quic/core/congestion_control/rtt_stats.h"
 #include "net/quic/core/quic_packets.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_config_peer.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/simulator/quic_endpoint.h"
 #include "net/quic/test_tools/simulator/simulator.h"
 #include "net/quic/test_tools/simulator/switch.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 63 matching lines @@
                             kInitialCongestionWindowPackets,
                             kDefaultMaxCongestionWindowPackets, &random_);
     QuicConnectionPeer::SetSendAlgorithm(bbr_sender_.connection(),
                                          kDefaultPathId, sender_);
 
     clock_ = simulator_.GetClock();
     simulator_.set_random_generator(&random_);
 
     uint64_t seed = QuicRandom::GetInstance()->RandUint64();
     random_.set_seed(seed);
-    VLOG(1) << "BbrSenderTest simulator set up.  Seed: " << seed;
+    QUIC_LOG(INFO) << "BbrSenderTest simulator set up.  Seed: " << seed;
   }
 
   simulator::Simulator simulator_;
   simulator::QuicEndpoint bbr_sender_;
   simulator::QuicEndpoint receiver_;
   std::unique_ptr<simulator::Switch> switch_;
   std::unique_ptr<simulator::SymmetricLink> bbr_sender_link_;
   std::unique_ptr<simulator::SymmetricLink> receiver_link_;
 
   SimpleRandom random_;
@@ skipping 30 matching lines @@
         kTestPropagationDelay));
   }
 
   void DoSimpleTransfer(QuicByteCount transfer_size, QuicTime::Delta deadline) {
     bbr_sender_.AddBytesToTransfer(transfer_size);
     bool simulator_result = simulator_.RunUntilOrTimeout(
         [this]() { return bbr_sender_.bytes_to_transfer() == 0; }, deadline);
     EXPECT_TRUE(simulator_result)
         << "Simple transfer failed.  Bytes remaining: "
         << bbr_sender_.bytes_to_transfer();
-    VLOG(1) << "Simple transfer state: " << sender_->ExportDebugState();
+    QUIC_LOG(INFO) << "Simple transfer state: " << sender_->ExportDebugState();
   }
 
   // Drive the simulator by sending enough data to enter PROBE_BW.
   void DriveOutOfStartup() {
     ASSERT_FALSE(sender_->ExportDebugState().is_at_full_bandwidth);
     DoSimpleTransfer(1024 * 1024, QuicTime::Delta::FromSeconds(15));
     EXPECT_EQ(BbrSender::PROBE_BW, sender_->ExportDebugState().mode);
     ExpectApproxEq(kTestLinkBandwidth,
                    sender_->ExportDebugState().max_bandwidth, 0.01f);
   }
@@ skipping 299 matching lines @@
   // Send another packet.
   bbr_sender_.AddBytesToTransfer(1000);
   simulator_result = simulator_.RunUntilOrTimeout(
       [this]() { return receiver_.bytes_received() == 2000; }, timeout);
   ASSERT_TRUE(simulator_result);
   EXPECT_GE(sender_->PacingRate(0), initial_rate);
 }
 
 }  // namespace test
 }  // namespace net