Cast: Added missing DCHECKs to ThreadChecker calls and minor cleanup.

media/cast/logging/logging_impl_unittest.cc

 // Copyright 2014 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 <vector>
 
 #include "base/rand_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
@@ skipping 18 matching lines @@
   LoggingImplTest() {
     // Enable all logging types.
     config_.enable_raw_data_collection = true;
     config_.enable_stats_data_collection = true;
     config_.enable_tracing = true;
 
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     task_runner_ = new test::FakeSingleThreadTaskRunner(&testing_clock_);
     logging_.reset(new LoggingImpl(task_runner_, config_));
-    event_subscriber_.reset(new SimpleEventSubscriber(task_runner_));
-    logging_->AddRawEventSubscriber(event_subscriber_.get());
+    logging_->AddRawEventSubscriber(&event_subscriber_);
   }
 
   virtual ~LoggingImplTest() {
-    logging_->RemoveRawEventSubscriber(event_subscriber_.get());
+    logging_->RemoveRawEventSubscriber(&event_subscriber_);
   }
 
   CastLoggingConfig config_;
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   scoped_ptr<LoggingImpl> logging_;
   base::SimpleTestTickClock testing_clock_;
-  scoped_ptr<SimpleEventSubscriber> event_subscriber_;
+  SimpleEventSubscriber event_subscriber_;
 
   DISALLOW_COPY_AND_ASSIGN(LoggingImplTest);
 };
 
 TEST_F(LoggingImplTest, BasicFrameLogging) {
   base::TimeTicks start_time = testing_clock_.NowTicks();
   base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
   uint32 rtp_timestamp = 0;
   uint32 frame_id = 0;
   base::TimeTicks now;
   do {
     now = testing_clock_.NowTicks();
     logging_->InsertFrameEvent(now, kAudioFrameCaptured, rtp_timestamp,
                                frame_id);
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
     rtp_timestamp += kFrameIntervalMs * 90;
     ++frame_id;
     time_interval = now - start_time;
   }  while (time_interval.InSeconds() < kIntervalTime1S);
   base::TimeTicks end_time = now;
 
   // Get logging data.
   std::vector<FrameEvent> frame_events;
-  event_subscriber_->GetFrameEventsAndReset(&frame_events);
+  event_subscriber_.GetFrameEventsAndReset(&frame_events);
   // Size of vector should be equal to the number of events logged,
   // which equals to number of frames in this case.
   EXPECT_EQ(frame_id, frame_events.size());
   // Verify stats.
   FrameStatsMap frame_stats = logging_->GetFrameStatsData();
   // Size of stats equals the number of events.
   EXPECT_EQ(1u, frame_stats.size());
   FrameStatsMap::const_iterator it = frame_stats.find(kAudioFrameCaptured);
   EXPECT_TRUE(it != frame_stats.end());
   EXPECT_EQ(0, it->second.max_delay.InMilliseconds());
@@ skipping 21 matching lines @@
     logging_->InsertFrameEventWithSize(testing_clock_.NowTicks(),
                                        kAudioFrameCaptured, rtp_timestamp,
                                        frame_id, size);
     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
     rtp_timestamp += kFrameIntervalMs * 90;
     ++frame_id;
     time_interval = testing_clock_.NowTicks() - start_time;
   } while (time_interval.InSeconds() < kIntervalTime1S);
   // Get logging data.
   std::vector<FrameEvent> frame_events;
-  event_subscriber_->GetFrameEventsAndReset(&frame_events);
+  event_subscriber_.GetFrameEventsAndReset(&frame_events);
   // Size of vector should be equal to the number of events logged, which
   // equals to number of frames in this case.
   EXPECT_EQ(frame_id, frame_events.size());
   // Verify stats.
   FrameStatsMap frame_stats = logging_->GetFrameStatsData();
   // Size of stats equals the number of events.
   EXPECT_EQ(1u, frame_stats.size());
   FrameStatsMap::const_iterator it = frame_stats.find(kAudioFrameCaptured);
   EXPECT_TRUE(it != frame_stats.end());
   EXPECT_EQ(0, it->second.max_delay.InMilliseconds());
@@ skipping 16 matching lines @@
     logging_->InsertFrameEventWithDelay(
         testing_clock_.NowTicks(), kAudioFrameCaptured, rtp_timestamp, frame_id,
         base::TimeDelta::FromMilliseconds(delay));
     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
     rtp_timestamp += kFrameIntervalMs * 90;
     ++frame_id;
     time_interval = testing_clock_.NowTicks() - start_time;
   } while (time_interval.InSeconds() < kIntervalTime1S);
   // Get logging data.
   std::vector<FrameEvent> frame_events;
-  event_subscriber_->GetFrameEventsAndReset(&frame_events);
+  event_subscriber_.GetFrameEventsAndReset(&frame_events);
   // Size of vector should be equal to the number of frames logged.
   EXPECT_EQ(frame_id, frame_events.size());
   // Verify stats.
   FrameStatsMap frame_stats = logging_->GetFrameStatsData();
   // Size of stats equals the number of events.
   EXPECT_EQ(1u, frame_stats.size());
   FrameStatsMap::const_iterator it = frame_stats.find(kAudioFrameCaptured);
   EXPECT_TRUE(it != frame_stats.end());
   EXPECT_GE(kPlayoutDelayMs + kRandomSizeInterval,
       it->second.max_delay.InMilliseconds());
@@ skipping 25 matching lines @@
     }
     ++num_events;
 
     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
     rtp_timestamp += kFrameIntervalMs * 90;
     ++frame_id;
     time_interval = testing_clock_.NowTicks() - start_time;
   } while (time_interval.InSeconds() < kIntervalTime1S);
   // Get logging data.
   std::vector<FrameEvent> frame_events;
-  event_subscriber_->GetFrameEventsAndReset(&frame_events);
+  event_subscriber_.GetFrameEventsAndReset(&frame_events);
   // Size of vector should be equal to the number of frames logged.
   EXPECT_EQ(num_events, frame_events.size());
   // Multiple events captured per frame.
 }
 
 TEST_F(LoggingImplTest, PacketLogging) {
   const int kNumPacketsPerFrame = 10;
   const int kBaseSize = 2500;
   const int kSizeInterval = 100;
   base::TimeTicks start_time = testing_clock_.NowTicks();
   base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
   uint32 rtp_timestamp = 0;
   uint32 frame_id = 0;
   do {
     for (int i = 0; i < kNumPacketsPerFrame; ++i) {
       int size = kBaseSize + base::RandInt(-kSizeInterval, kSizeInterval);
       logging_->InsertPacketEvent(testing_clock_.NowTicks(), kPacketSentToPacer,
                                   rtp_timestamp, frame_id, i,
                                   kNumPacketsPerFrame, size);
     }
     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
     rtp_timestamp += kFrameIntervalMs * 90;
     ++frame_id;
     time_interval = testing_clock_.NowTicks() - start_time;
   } while (time_interval.InSeconds() < kIntervalTime1S);
   // Get logging data.
   std::vector<PacketEvent> packet_events;
-  event_subscriber_->GetPacketEventsAndReset(&packet_events);
+  event_subscriber_.GetPacketEventsAndReset(&packet_events);
   // Size of vector should be equal to the number of packets logged.
   EXPECT_EQ(frame_id * kNumPacketsPerFrame, packet_events.size());
   // Verify stats.
   PacketStatsMap stats_map = logging_->GetPacketStatsData();
   // Size of stats equals the number of events.
   EXPECT_EQ(1u, stats_map.size());
   PacketStatsMap::const_iterator it = stats_map.find(kPacketSentToPacer);
   EXPECT_TRUE(it != stats_map.end());
 }
 
@@ skipping 40 matching lines @@
       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);
+  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;
@@ skipping 18 matching lines @@
   EXPECT_EQ(sumsq_value_pl, sit->second.sum_squared);
   EXPECT_LE(min_value, sit->second.min);
   EXPECT_GE(max_value, sit->second.max);
   sit = stats_map.find(kJitterMs);
   EXPECT_EQ(sumsq_value_jitter, sit->second.sum_squared);
   EXPECT_LE(min_value, sit->second.min);
   EXPECT_GE(max_value, sit->second.max);
 }
 
 TEST_F(LoggingImplTest, MultipleRawEventSubscribers) {
-  SimpleEventSubscriber event_subscriber_2(task_runner_);
+  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);
 
   std::vector<FrameEvent> frame_events;
-  event_subscriber_->GetFrameEventsAndReset(&frame_events);
+  event_subscriber_.GetFrameEventsAndReset(&frame_events);
   EXPECT_EQ(1u, frame_events.size());
   frame_events.clear();
   event_subscriber_2.GetFrameEventsAndReset(&frame_events);
   EXPECT_EQ(1u, frame_events.size());
 
   logging_->RemoveRawEventSubscriber(&event_subscriber_2);
 }
 
 }  // namespace cast
 }  // namespace media