Upstream version 7.36.149.0

[platform/framework/web/crosswalk.git] / src / media / cast / logging / logging_impl_unittest.cc

diff --git a/src/media/cast/logging/logging_impl_unittest.cc b/src/media/cast/logging/logging_impl_unittest.cc
index d9a67dd..cced0ac 100644 (file)
--- a/src/media/cast/logging/logging_impl_unittest.cc
+++ b/src/media/cast/logging/logging_impl_unittest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stdint.h>
+
 #include <vector>
 
 #include "base/rand_util.h"
@@ -21,7 +23,7 @@ const int64 kIntervalTime1S = 1;
 // Test frame rate goal - 30fps.
 const int kFrameIntervalMs = 33;
 
-static const int64 kStartMillisecond = GG_INT64_C(12345678900000);
+static const int64 kStartMillisecond = INT64_C(12345678900000);
 
 class LoggingImplTest : public ::testing::Test {
  protected:
@@ -50,8 +52,8 @@ TEST_F(LoggingImplTest, BasicFrameLogging) {
   base::TimeTicks now;
   do {
     now = testing_clock_.NowTicks();
-    logging_.InsertFrameEvent(now, kAudioFrameCaptured, rtp_timestamp,
-                               frame_id);
+    logging_.InsertFrameEvent(
+        now, kAudioFrameCaptureBegin, rtp_timestamp, frame_id);
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
     rtp_timestamp += kFrameIntervalMs * 90;
@@ -76,13 +78,14 @@ TEST_F(LoggingImplTest, FrameLoggingWithSize) {
   uint32 rtp_timestamp = 0;
   uint32 frame_id = 0;
   size_t sum_size = 0;
+  int target_bitrate = 1234;
   do {
     int size = kBaseFrameSizeBytes +
         base::RandInt(-kRandomSizeInterval, kRandomSizeInterval);
     sum_size += static_cast<size_t>(size);
-    logging_.InsertFrameEventWithSize(testing_clock_.NowTicks(),
-                                       kAudioFrameCaptured, rtp_timestamp,
-                                       frame_id, size);
+    logging_.InsertEncodedFrameEvent(testing_clock_.NowTicks(),
+                                     kVideoFrameEncoded, rtp_timestamp,
+                                     frame_id, size, true, target_bitrate);
     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
     rtp_timestamp += kFrameIntervalMs * 90;
     ++frame_id;
@@ -108,7 +111,10 @@ TEST_F(LoggingImplTest, FrameLoggingWithDelay) {
     int delay = kPlayoutDelayMs +
                 base::RandInt(-kRandomSizeInterval, kRandomSizeInterval);
     logging_.InsertFrameEventWithDelay(
-        testing_clock_.NowTicks(), kAudioFrameCaptured, rtp_timestamp, frame_id,
+        testing_clock_.NowTicks(),
+        kAudioFrameCaptureBegin,
+        rtp_timestamp,
+        frame_id,
         base::TimeDelta::FromMilliseconds(delay));
     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
     rtp_timestamp += kFrameIntervalMs * 90;
@@ -129,13 +135,15 @@ TEST_F(LoggingImplTest, MultipleEventFrameLogging) {
   uint32 frame_id = 0u;
   uint32 num_events = 0u;
   do {
-    logging_.InsertFrameEvent(testing_clock_.NowTicks(), kAudioFrameCaptured,
-                               rtp_timestamp, frame_id);
+    logging_.InsertFrameEvent(testing_clock_.NowTicks(),
+                              kAudioFrameCaptureBegin,
+                              rtp_timestamp,
+                              frame_id);
     ++num_events;
     if (frame_id % 2) {
-      logging_.InsertFrameEventWithSize(testing_clock_.NowTicks(),
-                                         kAudioFrameEncoded, rtp_timestamp,
-                                         frame_id, 1500);
+      logging_.InsertEncodedFrameEvent(testing_clock_.NowTicks(),
+                                       kAudioFrameEncoded, rtp_timestamp,
+                                       frame_id, 1500, true, 0);
     } else if (frame_id % 3) {
       logging_.InsertFrameEvent(testing_clock_.NowTicks(), kVideoFrameDecoded,
                                  rtp_timestamp, frame_id);
@@ -196,84 +204,16 @@ TEST_F(LoggingImplTest, PacketLogging) {
   EXPECT_EQ(num_packets, static_cast<int>(packet_events.size()));
 }
 
-TEST_F(LoggingImplTest, GenericLogging) {
-  // Insert multiple generic types.
-  const size_t kNumRuns = 20;//1000;
-  const int kBaseValue = 20;
-  int sum_value_rtt = 0;
-  int sum_value_pl = 0;
-  int sum_value_jitter = 0;
-  uint64 sumsq_value_rtt = 0;
-  uint64 sumsq_value_pl = 0;
-  uint64 sumsq_value_jitter = 0;
-  int min_value, max_value;
-
-  uint32 num_events = 0u;
-  uint32 expected_rtt_count = 0u;
-  uint32 expected_packet_loss_count = 0u;
-  uint32 expected_jitter_count = 0u;
-  for (size_t i = 0; i < kNumRuns; ++i) {
-    int value = kBaseValue + base::RandInt(-5, 5);
-    sum_value_rtt += value;
-    sumsq_value_rtt += value * value;
-    logging_.InsertGenericEvent(testing_clock_.NowTicks(), kRttMs, value);
-    ++num_events;
-    ++expected_rtt_count;
-    if (i % 2) {
-      logging_.InsertGenericEvent(testing_clock_.NowTicks(), kPacketLoss,
-                                   value);
-      ++num_events;
-      ++expected_packet_loss_count;
-      sum_value_pl += value;
-      sumsq_value_pl += value * value;
-    }
-    if (!(i % 4)) {
-      logging_.InsertGenericEvent(testing_clock_.NowTicks(), kJitterMs, value);
-      ++num_events;
-      ++expected_jitter_count;
-      sum_value_jitter += value;
-      sumsq_value_jitter += value * value;
-    }
-    if (i == 0) {
-      min_value = value;
-      max_value = value;
-    } else if (min_value > value) {
-      min_value = value;
-    } else if (max_value < value) {
-      max_value = value;
-    }
-  }
-
-  // Size of generic event vector = number of generic events logged.
-  std::vector<GenericEvent> generic_events;
-  event_subscriber_.GetGenericEventsAndReset(&generic_events);
-  EXPECT_EQ(num_events, generic_events.size());
-
-  // Verify each type of event has expected number of events logged.
-  uint32 rtt_event_count = 0u;
-  uint32 packet_loss_event_count = 0u;
-  uint32 jitter_event_count = 0u;
-  for (std::vector<GenericEvent>::iterator it = generic_events.begin();
-       it != generic_events.end(); ++it) {
-    if (it->type == kRttMs) {
-      ++rtt_event_count;
-    } else if (it->type == kPacketLoss) {
-      ++packet_loss_event_count;
-    } else if (it->type == kJitterMs) {
-      ++jitter_event_count;
-    }
-  }
-}
-
 TEST_F(LoggingImplTest, MultipleRawEventSubscribers) {
   SimpleEventSubscriber event_subscriber_2;
 
   // Now logging_ has two subscribers.
   logging_.AddRawEventSubscriber(&event_subscriber_2);
 
-  logging_.InsertFrameEvent(testing_clock_.NowTicks(), kAudioFrameCaptured,
-                             /*rtp_timestamp*/ 0u,
-                             /*frame_id*/ 0u);
+  logging_.InsertFrameEvent(testing_clock_.NowTicks(),
+                            kAudioFrameCaptureBegin,
+                            /*rtp_timestamp*/ 0u,
+                            /*frame_id*/ 0u);
 
   std::vector<FrameEvent> frame_events;
   event_subscriber_.GetFrameEventsAndReset(&frame_events);