Rename some variables and methods in RTC event log.

webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 265 matching lines @@
         GenerateRtpPacket(&extensions, csrcs_count, packet_size, &prng));
   }
   // Create rtcp_count RTCP packets containing random data.
   for (size_t i = 0; i < rtcp_count; i++) {
     rtcp_packets.push_back(GenerateRtcpPacket(&prng));
   }
   // Create playout_count random SSRCs to use when logging AudioPlayout events.
   for (size_t i = 0; i < playout_count; i++) {
     playout_ssrcs.push_back(prng.Rand<uint32_t>());
   }
-  // Create bwe_loss_count random bitrate updates for BwePacketLoss.
+  // Create bwe_loss_count random bitrate updates for LossBasedBwe.
   for (size_t i = 0; i < bwe_loss_count; i++) {
     bwe_loss_updates.push_back(
         std::make_pair(prng.Rand<int32_t>(), prng.Rand<uint8_t>()));
   }
   // Create configurations for the video streams.
   GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config, &prng);
   GenerateVideoSendConfig(extensions_bitvector, &sender_config, &prng);
   const int config_count = 2;
 
   // Find the name of the current test, in order to use it as a temporary
@@ skipping 29 matching lines @@
             rtcp_packets[rtcp_index - 1].size());
         rtcp_index++;
         fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
       }
       if (i * playout_count >= playout_index * rtp_count) {
         log_dumper->LogAudioPlayout(playout_ssrcs[playout_index - 1]);
         playout_index++;
         fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
       }
       if (i * bwe_loss_count >= bwe_loss_index * rtp_count) {
-        log_dumper->LogBwePacketLossEvent(
+        log_dumper->LogLossBasedBweUpdate(
             bwe_loss_updates[bwe_loss_index - 1].first,
             bwe_loss_updates[bwe_loss_index - 1].second, i);
         bwe_loss_index++;
         fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
       }
       if (i == rtp_count / 2) {
         log_dumper->StartLogging(temp_filename, 10000000);
         fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
       }
     }
@@ skipping 146 matching lines @@
   RtcEventLogTestHelper::VerifyRtcpEvent(parsed_log, 2, kOutgoingPacket,
                                          MediaType::VIDEO, rtcp_packet.data(),
                                          rtcp_packet.size());
 
   RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 3);
 
   // Clean up temporary file - can be pretty slow.
   remove(temp_filename.c_str());
 }
 
-TEST(RtcEventLogTest, LogPacketLossEventAndReadBack) {
+TEST(RtcEventLogTest, LogLossBasedBweUpdateAndReadBack) {
   Random prng(1234);
 
   // Generate a random packet loss event.
   int32_t bitrate = prng.Rand(0, 10000000);
   uint8_t fraction_lost = prng.Rand<uint8_t>();
   int32_t total_packets = prng.Rand(1, 1000);
 
   // Find the name of the current test, in order to use it as a temporary
   // filename.
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
 
   // Start logging, add the packet loss event and then stop logging.
   rtc::ScopedFakeClock fake_clock;
   fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
   std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
   log_dumper->StartLogging(temp_filename, 10000000);
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-  log_dumper->LogBwePacketLossEvent(bitrate, fraction_lost, total_packets);
+  log_dumper->LogLossBasedBweUpdate(bitrate, fraction_lost, total_packets);
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
   log_dumper->StopLogging();
 
   // Read the generated file from disk.
   ParsedRtcEventLog parsed_log;
   ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
   // Verify that what we read back from the event log is the same as
   // what we wrote down.
   EXPECT_EQ(3u, parsed_log.GetNumberOfEvents());
   RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
   RtcEventLogTestHelper::VerifyBweLossEvent(parsed_log, 1, bitrate,
                                             fraction_lost, total_packets);
   RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 2);
 
   // Clean up temporary file - can be pretty slow.
   remove(temp_filename.c_str());
 }
 
-TEST(RtcEventLogTest, LogPacketDelayEventAndReadBack) {
+TEST(RtcEventLogTest, LogDelayBasedBweUpdateAndReadBack) {
   Random prng(1234);
 
   // Generate 3 random packet delay event.
   int32_t bitrate1 = prng.Rand(0, 10000000);
   int32_t bitrate2 = prng.Rand(0, 10000000);
   int32_t bitrate3 = prng.Rand(0, 10000000);
 
   // Find the name of the current test, in order to use it as a temporary
   // filename.
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
 
   // Start logging, add the packet delay events and then stop logging.
   rtc::ScopedFakeClock fake_clock;
   fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
   std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
   log_dumper->StartLogging(temp_filename, 10000000);
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-  log_dumper->LogBwePacketDelayEvent(bitrate1, kBwNormal);
+  log_dumper->LogDelayBasedBweUpdate(bitrate1, kBwNormal);
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-  log_dumper->LogBwePacketDelayEvent(bitrate2, kBwOverusing);
+  log_dumper->LogDelayBasedBweUpdate(bitrate2, kBwOverusing);
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
-  log_dumper->LogBwePacketDelayEvent(bitrate3, kBwUnderusing);
+  log_dumper->LogDelayBasedBweUpdate(bitrate3, kBwUnderusing);
   fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
   log_dumper->StopLogging();
 
   // Read the generated file from disk.
   ParsedRtcEventLog parsed_log;
   ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
   // Verify that what we read back from the event log is the same as
   // what we wrote down.
   EXPECT_EQ(5u, parsed_log.GetNumberOfEvents());
@@ skipping 161 matching lines @@
   VideoSendConfigReadWriteTest test;
   test.DoTest();
 }
 
 TEST(RtcEventLogTest, LogAudioNetworkAdaptation) {
   AudioNetworkAdaptationReadWriteTest test;
   test.DoTest();
 }
 
 }  // namespace webrtc