From 728324d1b0db65109077f64ac582d2022bf0cb52 Mon Sep 17 00:00:00 2001 From: "imcheng@chromium.org" Date: Wed, 12 Feb 2014 23:46:27 +0000 Subject: Cast: Added missing DCHECKs to ThreadChecker calls and minor cleanup. Also included in this CL are: - Removed task_runner in constructor of RawEventSubscriber impls - Minor fixes in unittests Review URL: https://codereview.chromium.org/145873007 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@250847 0039d316-1c4b-4281-b951-d872f2087c98 --- media/cast/audio_receiver/audio_receiver.cc | 2 -- media/cast/logging/logging_impl_unittest.cc | 23 +++++++++++----------- media/cast/logging/logging_raw_unittest.cc | 11 ++--------- media/cast/logging/simple_event_subscriber.cc | 19 ++++++++---------- media/cast/logging/simple_event_subscriber.h | 10 ++-------- .../logging/simple_event_subscriber_unittest.cc | 3 +-- media/cast/rtcp/receiver_rtcp_event_subscriber.cc | 15 +++++--------- media/cast/rtcp/receiver_rtcp_event_subscriber.h | 8 +------- .../receiver_rtcp_event_subscriber_unittest.cc | 4 ++-- media/cast/rtcp/sender_rtcp_event_subscriber.cc | 15 ++++++-------- media/cast/rtcp/sender_rtcp_event_subscriber.h | 13 ++---------- .../rtcp/sender_rtcp_event_subscriber_unittest.cc | 23 ++++++++++------------ media/cast/test/end2end_unittest.cc | 3 +-- media/cast/video_receiver/video_receiver.cc | 2 -- media/cast/video_sender/video_sender.cc | 5 +---- 15 files changed, 52 insertions(+), 104 deletions(-) (limited to 'media') diff --git a/media/cast/audio_receiver/audio_receiver.cc b/media/cast/audio_receiver/audio_receiver.cc index 30ce561..71c2095 100644 --- a/media/cast/audio_receiver/audio_receiver.cc +++ b/media/cast/audio_receiver/audio_receiver.cc @@ -95,8 +95,6 @@ AudioReceiver::AudioReceiver(scoped_refptr cast_environment, transport::PacedPacketSender* const packet_sender) : cast_environment_(cast_environment), event_subscriber_( - cast_environment->GetMessageSingleThreadTaskRunnerForThread( - CastEnvironment::MAIN), kMaxEventSubscriberEntries, ReceiverRtcpEventSubscriber::kAudioEventSubscriber), codec_(audio_config.codec), diff --git a/media/cast/logging/logging_impl_unittest.cc b/media/cast/logging/logging_impl_unittest.cc index b3ad6fb..190a6b4 100644 --- a/media/cast/logging/logging_impl_unittest.cc +++ b/media/cast/logging/logging_impl_unittest.cc @@ -36,19 +36,18 @@ class LoggingImplTest : public ::testing::Test { 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 task_runner_; scoped_ptr logging_; base::SimpleTestTickClock testing_clock_; - scoped_ptr event_subscriber_; + SimpleEventSubscriber event_subscriber_; DISALLOW_COPY_AND_ASSIGN(LoggingImplTest); }; @@ -73,7 +72,7 @@ TEST_F(LoggingImplTest, BasicFrameLogging) { // Get logging data. std::vector 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()); @@ -115,7 +114,7 @@ TEST_F(LoggingImplTest, FrameLoggingWithSize) { } while (time_interval.InSeconds() < kIntervalTime1S); // Get logging data. std::vector 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()); @@ -152,7 +151,7 @@ TEST_F(LoggingImplTest, FrameLoggingWithDelay) { } while (time_interval.InSeconds() < kIntervalTime1S); // Get logging data. std::vector 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. @@ -198,7 +197,7 @@ TEST_F(LoggingImplTest, MultipleEventFrameLogging) { } while (time_interval.InSeconds() < kIntervalTime1S); // Get logging data. std::vector 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. @@ -226,7 +225,7 @@ TEST_F(LoggingImplTest, PacketLogging) { } while (time_interval.InSeconds() < kIntervalTime1S); // Get logging data. std::vector 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. @@ -287,7 +286,7 @@ TEST_F(LoggingImplTest, GenericLogging) { // Size of generic event vector = number of generic events logged. std::vector 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. @@ -326,7 +325,7 @@ TEST_F(LoggingImplTest, GenericLogging) { } TEST_F(LoggingImplTest, MultipleRawEventSubscribers) { - SimpleEventSubscriber event_subscriber_2(task_runner_); + SimpleEventSubscriber event_subscriber_2; // Now logging_ has two subscribers. logging_->AddRawEventSubscriber(&event_subscriber_2); @@ -336,7 +335,7 @@ TEST_F(LoggingImplTest, MultipleRawEventSubscribers) { /*frame_id*/ 0u); std::vector 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); diff --git a/media/cast/logging/logging_raw_unittest.cc b/media/cast/logging/logging_raw_unittest.cc index 4446070..135aed5e 100644 --- a/media/cast/logging/logging_raw_unittest.cc +++ b/media/cast/logging/logging_raw_unittest.cc @@ -2,12 +2,9 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "base/memory/scoped_ptr.h" -#include "base/test/simple_test_tick_clock.h" #include "media/cast/logging/logging_defines.h" #include "media/cast/logging/logging_raw.h" #include "media/cast/logging/simple_event_subscriber.h" -#include "media/cast/test/fake_single_thread_task_runner.h" #include "testing/gtest/include/gtest/gtest.h" namespace media { @@ -15,17 +12,13 @@ namespace cast { class LoggingRawTest : public ::testing::Test { protected: - LoggingRawTest() - : task_runner_(new test::FakeSingleThreadTaskRunner(&testing_clock_)), - event_subscriber_(task_runner_) { + LoggingRawTest() { raw_.AddSubscriber(&event_subscriber_); } virtual ~LoggingRawTest() { raw_.RemoveSubscriber(&event_subscriber_); } LoggingRaw raw_; - base::SimpleTestTickClock testing_clock_; - scoped_refptr task_runner_; SimpleEventSubscriber event_subscriber_; std::vector frame_events_; std::vector packet_events_; @@ -153,7 +146,7 @@ TEST_F(LoggingRawTest, GenericEvent) { } TEST_F(LoggingRawTest, MultipleSubscribers) { - SimpleEventSubscriber event_subscriber_2(task_runner_); + SimpleEventSubscriber event_subscriber_2; // Now raw_ has two subscribers. raw_.AddSubscriber(&event_subscriber_2); diff --git a/media/cast/logging/simple_event_subscriber.cc b/media/cast/logging/simple_event_subscriber.cc index f0b2250..78f932d 100644 --- a/media/cast/logging/simple_event_subscriber.cc +++ b/media/cast/logging/simple_event_subscriber.cc @@ -7,53 +7,50 @@ #include #include "base/logging.h" -#include "base/single_thread_task_runner.h" namespace media { namespace cast { -SimpleEventSubscriber::SimpleEventSubscriber( - const scoped_refptr& main_thread_proxy) { - DCHECK(main_thread_proxy->RunsTasksOnCurrentThread()); -} +SimpleEventSubscriber::SimpleEventSubscriber() {} SimpleEventSubscriber::~SimpleEventSubscriber() { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); } void SimpleEventSubscriber::OnReceiveFrameEvent(const FrameEvent& frame_event) { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); frame_events_.push_back(frame_event); } void SimpleEventSubscriber::OnReceivePacketEvent( const PacketEvent& packet_event) { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); packet_events_.push_back(packet_event); } void SimpleEventSubscriber::OnReceiveGenericEvent( const GenericEvent& generic_event) { + DCHECK(thread_checker_.CalledOnValidThread()); generic_events_.push_back(generic_event); } void SimpleEventSubscriber::GetFrameEventsAndReset( std::vector* frame_events) { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); frame_events->swap(frame_events_); frame_events_.clear(); } void SimpleEventSubscriber::GetPacketEventsAndReset( std::vector* packet_events) { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); packet_events->swap(packet_events_); packet_events_.clear(); } void SimpleEventSubscriber::GetGenericEventsAndReset( std::vector* generic_events) { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); generic_events->swap(generic_events_); generic_events_.clear(); } diff --git a/media/cast/logging/simple_event_subscriber.h b/media/cast/logging/simple_event_subscriber.h index b8f0b49..3cf890a 100644 --- a/media/cast/logging/simple_event_subscriber.h +++ b/media/cast/logging/simple_event_subscriber.h @@ -7,8 +7,6 @@ #include -#include "base/memory/ref_counted.h" -#include "base/single_thread_task_runner.h" #include "base/threading/thread_checker.h" #include "media/cast/logging/raw_event_subscriber.h" @@ -21,17 +19,13 @@ namespace cast { // list of events that have acccumulated since last inovcation. class SimpleEventSubscriber : public RawEventSubscriber { public: - // |main_thread_proxy|: Only used for ensuring the subscriber is only called - // on the main thread. This object does not keep a reference on it. - explicit SimpleEventSubscriber( - const scoped_refptr& main_thread_proxy); + SimpleEventSubscriber(); virtual ~SimpleEventSubscriber(); + // RawEventSubscriber implementations. virtual void OnReceiveFrameEvent(const FrameEvent& frame_event) OVERRIDE; - virtual void OnReceivePacketEvent(const PacketEvent& packet_event) OVERRIDE; - virtual void OnReceiveGenericEvent(const GenericEvent& generic_event) OVERRIDE; diff --git a/media/cast/logging/simple_event_subscriber_unittest.cc b/media/cast/logging/simple_event_subscriber_unittest.cc index 5a6b09d..ab03126 100644 --- a/media/cast/logging/simple_event_subscriber_unittest.cc +++ b/media/cast/logging/simple_event_subscriber_unittest.cc @@ -23,8 +23,7 @@ class SimpleEventSubscriberTest : public ::testing::Test { cast_environment_(new CastEnvironment( scoped_ptr(testing_clock_).Pass(), task_runner_, task_runner_, task_runner_, task_runner_, task_runner_, - task_runner_, GetLoggingConfigWithRawEventsAndStatsEnabled())), - event_subscriber_(task_runner_) { + task_runner_, GetLoggingConfigWithRawEventsAndStatsEnabled())) { cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber_); } diff --git a/media/cast/rtcp/receiver_rtcp_event_subscriber.cc b/media/cast/rtcp/receiver_rtcp_event_subscriber.cc index a5f963e..ac60d2d2 100644 --- a/media/cast/rtcp/receiver_rtcp_event_subscriber.cc +++ b/media/cast/rtcp/receiver_rtcp_event_subscriber.cc @@ -6,28 +6,23 @@ #include -#include "base/single_thread_task_runner.h" -#include "media/cast/cast_environment.h" - namespace media { namespace cast { ReceiverRtcpEventSubscriber::ReceiverRtcpEventSubscriber( - const scoped_refptr& main_thread_proxy, const size_t max_size_to_retain, Type type) : max_size_to_retain_(max_size_to_retain), type_(type) { - DCHECK(main_thread_proxy->RunsTasksOnCurrentThread()); DCHECK(max_size_to_retain_ > 0u); DCHECK(type_ == kAudioEventSubscriber || type_ == kVideoEventSubscriber); } ReceiverRtcpEventSubscriber::~ReceiverRtcpEventSubscriber() { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); } void ReceiverRtcpEventSubscriber::OnReceiveFrameEvent( const FrameEvent& frame_event) { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); if (ShouldProcessEvent(frame_event.type)) { RtcpEvent rtcp_event; @@ -59,7 +54,7 @@ void ReceiverRtcpEventSubscriber::OnReceiveFrameEvent( void ReceiverRtcpEventSubscriber::OnReceivePacketEvent( const PacketEvent& packet_event) { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); if (ShouldProcessEvent(packet_event.type)) { RtcpEvent rtcp_event; @@ -80,13 +75,13 @@ void ReceiverRtcpEventSubscriber::OnReceivePacketEvent( void ReceiverRtcpEventSubscriber::OnReceiveGenericEvent( const GenericEvent& generic_event) { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); // Do nothing as RTP receiver is not interested in generic events for RTCP. } void ReceiverRtcpEventSubscriber::GetReceiverLogMessageAndReset( RtcpReceiverLogMessage* receiver_log) { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); receiver_log->clear(); diff --git a/media/cast/rtcp/receiver_rtcp_event_subscriber.h b/media/cast/rtcp/receiver_rtcp_event_subscriber.h index caf0bc7..2200cdd 100644 --- a/media/cast/rtcp/receiver_rtcp_event_subscriber.h +++ b/media/cast/rtcp/receiver_rtcp_event_subscriber.h @@ -7,14 +7,12 @@ #include -#include "base/memory/ref_counted.h" #include "base/threading/thread_checker.h" #include "media/cast/logging/logging_defines.h" #include "media/cast/logging/raw_event_subscriber.h" #include "media/cast/rtcp/rtcp_defines.h" namespace base { - class SingleThreadTaskRunner; } @@ -39,17 +37,13 @@ class ReceiverRtcpEventSubscriber : public RawEventSubscriber { kVideoEventSubscriber // Only processes video events }; - // |main_thread_proxy|: Check that the object is created in main thread. - // This object does not hold a reference on it. // |max_size_to_retain|: The object will keep up to |max_size_to_retain| // events // in the map. Once threshold has been reached, an event with the smallest // RTP timestamp will be removed. // |type|: Determines whether the subscriber will process only audio or video // events. - ReceiverRtcpEventSubscriber( - const scoped_refptr& main_thread_proxy, - const size_t max_size_to_retain, Type type); + ReceiverRtcpEventSubscriber(const size_t max_size_to_retain, Type type); virtual ~ReceiverRtcpEventSubscriber(); diff --git a/media/cast/rtcp/receiver_rtcp_event_subscriber_unittest.cc b/media/cast/rtcp/receiver_rtcp_event_subscriber_unittest.cc index 8158f8d..a19c6a3 100644 --- a/media/cast/rtcp/receiver_rtcp_event_subscriber_unittest.cc +++ b/media/cast/rtcp/receiver_rtcp_event_subscriber_unittest.cc @@ -17,7 +17,7 @@ namespace cast { namespace { -const size_t kSizeThreshold = 10u; +const size_t kMaxEventEntries = 10u; const int64 kDelayMs = 20L; } // namespace @@ -43,7 +43,7 @@ class ReceiverRtcpEventSubscriberTest : public ::testing::Test { void Init(ReceiverRtcpEventSubscriber::Type type) { event_subscriber_.reset( - new ReceiverRtcpEventSubscriber(task_runner_, kSizeThreshold, type)); + new ReceiverRtcpEventSubscriber(kMaxEventEntries, type)); cast_environment_->Logging()->AddRawEventSubscriber( event_subscriber_.get()); } diff --git a/media/cast/rtcp/sender_rtcp_event_subscriber.cc b/media/cast/rtcp/sender_rtcp_event_subscriber.cc index f16ff01..7b82f4a 100644 --- a/media/cast/rtcp/sender_rtcp_event_subscriber.cc +++ b/media/cast/rtcp/sender_rtcp_event_subscriber.cc @@ -6,28 +6,25 @@ #include -#include "base/single_thread_task_runner.h" -#include "media/cast/cast_environment.h" +#include "base/logging.h" #include "media/cast/rtcp/rtcp_defines.h" namespace media { namespace cast { SenderRtcpEventSubscriber::SenderRtcpEventSubscriber( - const scoped_refptr& main_thread_proxy, const size_t max_size_to_retain) : max_size_to_retain_(max_size_to_retain) { - DCHECK(main_thread_proxy->RunsTasksOnCurrentThread()); DCHECK(max_size_to_retain_ > 0u); } SenderRtcpEventSubscriber::~SenderRtcpEventSubscriber() { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); } void SenderRtcpEventSubscriber::OnReceiveFrameEvent( const FrameEvent& frame_event) { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); if (frame_event.type != kVideoFrameCaptured && frame_event.type != kVideoFrameSentToEncoder && frame_event.type != kVideoFrameEncoded) { @@ -68,19 +65,19 @@ void SenderRtcpEventSubscriber::OnReceiveFrameEvent( void SenderRtcpEventSubscriber::OnReceivePacketEvent( const PacketEvent& packet_event) { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); // Do nothing as RTP sender is not interested in packet events for RTCP. } void SenderRtcpEventSubscriber::OnReceiveGenericEvent( const GenericEvent& generic_event) { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); // Do nothing as RTP sender is not interested in generic events for RTCP. } void SenderRtcpEventSubscriber::GetRtcpEventsAndReset( RtcpEventMap* rtcp_events) { - thread_checker_.CalledOnValidThread(); + DCHECK(thread_checker_.CalledOnValidThread()); rtcp_events->swap(rtcp_events_); rtcp_events_.clear(); } diff --git a/media/cast/rtcp/sender_rtcp_event_subscriber.h b/media/cast/rtcp/sender_rtcp_event_subscriber.h index fc57cbf..fdd36e3 100644 --- a/media/cast/rtcp/sender_rtcp_event_subscriber.h +++ b/media/cast/rtcp/sender_rtcp_event_subscriber.h @@ -7,17 +7,11 @@ #include -#include "base/memory/ref_counted.h" #include "base/threading/thread_checker.h" #include "media/cast/logging/logging_defines.h" #include "media/cast/logging/raw_event_subscriber.h" #include "media/cast/rtcp/rtcp_defines.h" -namespace base { - -class SingleThreadTaskRunner; -} - namespace media { namespace cast { @@ -37,15 +31,12 @@ typedef std::map RtcpEventMap; // timestamp) up to the size limit. class SenderRtcpEventSubscriber : public RawEventSubscriber { public: - // |main_thread_proxy|: Check that the object is created in main thread. - // This object does not hold a reference on it. // |max_size_to_retain|: The object will keep up to |max_size_to_retain| // events // in the map. Once threshold has been reached, an event with the smallest // RTP timestamp will be removed. - SenderRtcpEventSubscriber( - const scoped_refptr& main_thread_proxy, - const size_t max_size_to_retain); + SenderRtcpEventSubscriber(const size_t max_size_to_retain); + virtual ~SenderRtcpEventSubscriber(); // RawEventSubscriber implementation. diff --git a/media/cast/rtcp/sender_rtcp_event_subscriber_unittest.cc b/media/cast/rtcp/sender_rtcp_event_subscriber_unittest.cc index a9a24a1..56897c2 100644 --- a/media/cast/rtcp/sender_rtcp_event_subscriber_unittest.cc +++ b/media/cast/rtcp/sender_rtcp_event_subscriber_unittest.cc @@ -17,7 +17,7 @@ namespace cast { namespace { -const size_t kSizeThreshold = 10u; +const size_t kMaxEventEntries = 10u; } // namespace @@ -30,21 +30,18 @@ class SenderRtcpEventSubscriberTest : public ::testing::Test { scoped_ptr(testing_clock_).Pass(), task_runner_, task_runner_, task_runner_, task_runner_, task_runner_, task_runner_, GetLoggingConfigWithRawEventsAndStatsEnabled())), - event_subscriber_( - new SenderRtcpEventSubscriber(task_runner_, kSizeThreshold)) { - cast_environment_->Logging()->AddRawEventSubscriber( - event_subscriber_.get()); + event_subscriber_(kMaxEventEntries) { + cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber_); } virtual ~SenderRtcpEventSubscriberTest() { - cast_environment_->Logging()->RemoveRawEventSubscriber( - event_subscriber_.get()); + cast_environment_->Logging()->RemoveRawEventSubscriber(&event_subscriber_); } base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. scoped_refptr task_runner_; scoped_refptr cast_environment_; - scoped_ptr event_subscriber_; + SenderRtcpEventSubscriber event_subscriber_; }; TEST_F(SenderRtcpEventSubscriberTest, InsertEntry) { @@ -62,7 +59,7 @@ TEST_F(SenderRtcpEventSubscriberTest, InsertEntry) { testing_clock_->NowTicks(), kVideoFrameSentToEncoder, 300u, 3u); RtcpEventMap events; - event_subscriber_->GetRtcpEventsAndReset(&events); + event_subscriber_.GetRtcpEventsAndReset(&events); ASSERT_EQ(3u, events.size()); @@ -84,11 +81,11 @@ TEST_F(SenderRtcpEventSubscriberTest, MapReset) { kVideoFrameCaptured, 100u, 1u); RtcpEventMap events; - event_subscriber_->GetRtcpEventsAndReset(&events); + event_subscriber_.GetRtcpEventsAndReset(&events); EXPECT_EQ(1u, events.size()); // Call again without any logging in between, should return empty map. - event_subscriber_->GetRtcpEventsAndReset(&events); + event_subscriber_.GetRtcpEventsAndReset(&events); EXPECT_TRUE(events.empty()); } @@ -99,7 +96,7 @@ TEST_F(SenderRtcpEventSubscriberTest, DropEventsWhenSizeExceeded) { } RtcpEventMap events; - event_subscriber_->GetRtcpEventsAndReset(&events); + event_subscriber_.GetRtcpEventsAndReset(&events); ASSERT_EQ(10u, events.size()); EXPECT_EQ(10u, events.begin()->first); @@ -110,7 +107,7 @@ TEST_F(SenderRtcpEventSubscriberTest, DropEventsWhenSizeExceeded) { testing_clock_->NowTicks(), kVideoFrameCaptured, i * 10, i); } - event_subscriber_->GetRtcpEventsAndReset(&events); + event_subscriber_.GetRtcpEventsAndReset(&events); // Event with RTP timestamp 10 should have been dropped when 110 is inserted. ASSERT_EQ(10u, events.size()); diff --git a/media/cast/test/end2end_unittest.cc b/media/cast/test/end2end_unittest.cc index f42c4c5..656df64 100644 --- a/media/cast/test/end2end_unittest.cc +++ b/media/cast/test/end2end_unittest.cc @@ -393,8 +393,7 @@ class End2EndTest : public ::testing::Test { receiver_to_sender_(cast_environment_), sender_to_receiver_(cast_environment_), test_receiver_audio_callback_(new TestReceiverAudioCallback()), - test_receiver_video_callback_(new TestReceiverVideoCallback()), - event_subscriber_(task_runner_) { + test_receiver_video_callback_(new TestReceiverVideoCallback()) { testing_clock_->Advance( base::TimeDelta::FromMilliseconds(kStartMillisecond)); cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber_); diff --git a/media/cast/video_receiver/video_receiver.cc b/media/cast/video_receiver/video_receiver.cc index 82a2c29..745dc4e 100644 --- a/media/cast/video_receiver/video_receiver.cc +++ b/media/cast/video_receiver/video_receiver.cc @@ -103,8 +103,6 @@ VideoReceiver::VideoReceiver(scoped_refptr cast_environment, transport::PacedPacketSender* const packet_sender) : cast_environment_(cast_environment), event_subscriber_( - cast_environment->GetMessageSingleThreadTaskRunnerForThread( - CastEnvironment::MAIN), kMaxEventSubscriberEntries, ReceiverRtcpEventSubscriber::kVideoEventSubscriber), codec_(video_config.codec), diff --git a/media/cast/video_sender/video_sender.cc b/media/cast/video_sender/video_sender.cc index bb1e2e9..7e873ff 100644 --- a/media/cast/video_sender/video_sender.cc +++ b/media/cast/video_sender/video_sender.cc @@ -94,10 +94,7 @@ VideoSender::VideoSender( max_frame_rate_(video_config.max_frame_rate), cast_environment_(cast_environment), transport_sender_(transport_sender), - event_subscriber_( - cast_environment_->GetMessageSingleThreadTaskRunnerForThread( - CastEnvironment::MAIN), - kMaxEventSubscriberEntries), + event_subscriber_(kMaxEventSubscriberEntries), rtcp_feedback_(new LocalRtcpVideoSenderFeedback(this)), last_acked_frame_id_(-1), last_sent_frame_id_(-1), -- cgit v1.1