Cast: IPC from browser to renderer to send packet events from transport to cast library.

media/cast/transport/cast_transport_sender_impl.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 "media/cast/transport/cast_transport_sender_impl.h"
 
 #include "base/single_thread_task_runner.h"
 #include "media/cast/transport/cast_transport_config.h"
 #include "media/cast/transport/cast_transport_defines.h"
 
 namespace media {
 namespace cast {
 namespace transport {
 
 CastTransportSender* CastTransportSender::CreateCastTransportSender(
     base::TickClock* clock,
     const CastTransportConfig& config,
     const CastTransportStatusCallback& status_callback,
+    const BulkRawEventsCallback& raw_events_callback,
     const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) {
-  return new CastTransportSenderImpl(
-      clock, config, status_callback, transport_task_runner.get(), NULL);
+  return new CastTransportSenderImpl(clock,
+                                     config,
+                                     status_callback,
+                                     raw_events_callback,
+                                     transport_task_runner.get(),
+                                     NULL);
 }
 
 CastTransportSenderImpl::CastTransportSenderImpl(
     base::TickClock* clock,
     const CastTransportConfig& config,
     const CastTransportStatusCallback& status_callback,
+    const BulkRawEventsCallback& raw_events_callback,
     const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner,
     PacketSender* external_transport)
     : transport_(external_transport ? NULL
                                     : new UdpTransport(transport_task_runner,
                                                        config.local_endpoint,
                                                        config.receiver_endpoint,
                                                        status_callback)),
       pacer_(clock,
              external_transport ? external_transport : transport_.get(),
              transport_task_runner),
       rtcp_builder_(&pacer_),
       audio_sender_(config, clock, transport_task_runner, &pacer_),
-      video_sender_(config, clock, transport_task_runner, &pacer_) {
+      video_sender_(config, clock, transport_task_runner, &pacer_),
+      logging_(transport_task_runner,
+               CastLoggingConfig(config.enable_raw_event_logging,
+                                 false, false)),
+      raw_events_callback_(raw_events_callback) {
   if (audio_sender_.initialized() && video_sender_.initialized()) {
     status_callback.Run(TRANSPORT_INITIALIZED);
   } else {
     status_callback.Run(TRANSPORT_UNINITIALIZED);
   }
+
+  if (config.enable_raw_event_logging) {
+    event_subscriber_.reset(new SimpleEventSubscriber);
+    logging_.AddRawEventSubscriber(event_subscriber_.get());
+    raw_events_timer_.Start(
+        FROM_HERE,
+        base::TimeDelta::FromSeconds(kSendRawEventsIntervalSecs),
+        this,
+        &CastTransportSenderImpl::SendRawEvents);
+  }
 }
 
-CastTransportSenderImpl::~CastTransportSenderImpl() {}
+CastTransportSenderImpl::~CastTransportSenderImpl() {
+  if (event_subscriber_.get())
+    logging_.RemoveRawEventSubscriber(event_subscriber_.get());
+}
 
 void CastTransportSenderImpl::SetPacketReceiver(
     const PacketReceiverCallback& packet_receiver) {
   transport_->StartReceiving(packet_receiver);
 }
 
 void CastTransportSenderImpl::InsertCodedAudioFrame(
     const EncodedAudioFrame* audio_frame,
     const base::TimeTicks& recorded_time) {
   audio_sender_.InsertCodedAudioFrame(audio_frame, recorded_time);
@@ skipping 29 matching lines @@
 void CastTransportSenderImpl::SubscribeAudioRtpStatsCallback(
     const CastTransportRtpStatistics& callback) {
   audio_sender_.SubscribeAudioRtpStatsCallback(callback);
 }
 
 void CastTransportSenderImpl::SubscribeVideoRtpStatsCallback(
     const CastTransportRtpStatistics& callback) {
   video_sender_.SubscribeVideoRtpStatsCallback(callback);
 }
 
+void CastTransportSenderImpl::SendRawEvents() {
+  DCHECK(event_subscriber_.get());
+  std::vector<PacketEvent> packet_events;
+  event_subscriber_->GetPacketEventsAndReset(&packet_events);
+  raw_events_callback_.Run(packet_events);
+}
+
 }  // namespace transport
 }  // namespace cast
 }  // namespace media