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

chrome/renderer/media/cast_session_delegate.cc

 // Copyright 2013 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 "chrome/renderer/media/cast_session_delegate.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "chrome/renderer/media/cast_threads.h"
@@ skipping 41 matching lines @@
   if (audio_event_subscriber_.get()) {
     cast_environment_->Logging()->RemoveRawEventSubscriber(
         audio_event_subscriber_.get());
   }
   if (video_event_subscriber_.get()) {
     cast_environment_->Logging()->RemoveRawEventSubscriber(
         video_event_subscriber_.get());
   }
 }
 
-void CastSessionDelegate::Initialize() {
+void CastSessionDelegate::Initialize(
+    const media::cast::CastLoggingConfig& logging_config) {
   if (cast_environment_)
     return;  // Already initialized.
 
   // CastSender uses the renderer's IO thread as the main thread. This reduces
   // thread hopping for incoming video frames and outgoing network packets.
   // There's no need to decode so no thread assigned for decoding.
   // Get default logging: All disabled.
   cast_environment_ = new CastEnvironment(
       scoped_ptr<base::TickClock>(new base::DefaultTickClock()).Pass(),
       base::MessageLoopProxy::current(),
       g_cast_threads.Get().GetAudioEncodeMessageLoopProxy(),
       NULL,
       g_cast_threads.Get().GetVideoEncodeMessageLoopProxy(),
       NULL,
       base::MessageLoopProxy::current(),
-      media::cast::GetDefaultCastSenderLoggingConfig());
+      logging_config);
 }
 
 void CastSessionDelegate::StartAudio(
     const AudioSenderConfig& config,
     const FrameInputAvailableCallback& callback) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   audio_config_.reset(new AudioSenderConfig(config));
   video_frame_input_available_callback_ = callback;
   StartSendingInternal();
@@ skipping 39 matching lines @@
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   // No transport, wait.
   if (!transport_configured_)
     return;
 
   // No audio or video, wait.
   if (!audio_config_ && !video_config_)
     return;
 
-  Initialize();
+  // TODO(imcheng): Enable raw event and stats collection.
+  media::cast::CastLoggingConfig logging_config =
+      media::cast::GetDefaultCastSenderLoggingConfig();
 
-  media::cast::transport::CastTransportConfig config;
+  Initialize(logging_config);
 
-  // TODO(hubbe): set config.aes_key and config.aes_iv_mask.
-  config.local_endpoint = local_endpoint_;
-  config.receiver_endpoint = remote_endpoint_;
+  media::cast::transport::CastTransportConfig transport_config;
+  transport_config.enable_raw_event_logging =
+      logging_config.enable_raw_data_collection;
+
+  // TODO(hubbe): set transport_config.aes_key and transport_config.aes_iv_mask.
+  transport_config.local_endpoint = local_endpoint_;
+  transport_config.receiver_endpoint = remote_endpoint_;
   if (audio_config_) {
-    config.audio_ssrc = audio_config_->sender_ssrc;
-    config.audio_codec = audio_config_->codec;
-    config.audio_rtp_config = audio_config_->rtp_config;
-    config.audio_frequency = audio_config_->frequency;
-    config.audio_channels = audio_config_->channels;
+    transport_config.audio_ssrc = audio_config_->sender_ssrc;
+    transport_config.audio_codec = audio_config_->codec;
+    transport_config.audio_rtp_config = audio_config_->rtp_config;
+    transport_config.audio_frequency = audio_config_->frequency;
+    transport_config.audio_channels = audio_config_->channels;
 
     if (!audio_event_subscriber_.get()) {
       audio_event_subscriber_.reset(new media::cast::EncodingEventSubscriber(
           media::cast::AUDIO_EVENT, kMaxAudioEventEntries));
       cast_environment_->Logging()->AddRawEventSubscriber(
           audio_event_subscriber_.get());
     }
   }
   if (video_config_) {
-    config.video_ssrc = video_config_->sender_ssrc;
-    config.video_codec = video_config_->codec;
-    config.video_rtp_config = video_config_->rtp_config;
+    transport_config.video_ssrc = video_config_->sender_ssrc;
+    transport_config.video_codec = video_config_->codec;
+    transport_config.video_rtp_config = video_config_->rtp_config;
 
     if (!video_event_subscriber_.get()) {
       video_event_subscriber_.reset(new media::cast::EncodingEventSubscriber(
           media::cast::VIDEO_EVENT, kMaxVideoEventEntries));
       cast_environment_->Logging()->AddRawEventSubscriber(
           video_event_subscriber_.get());
     }
   }
 
   cast_transport_.reset(new CastTransportSenderIPC(
-      config,
+      transport_config,
       base::Bind(&CastSessionDelegate::StatusNotificationCB,
-                 base::Unretained(this))));
+                 base::Unretained(this)),
+      base::Bind(&CastSessionDelegate::LogRawEvents, base::Unretained(this))));
 
   cast_sender_.reset(CastSender::CreateCastSender(
       cast_environment_,
       audio_config_.get(),
       video_config_.get(),
       NULL,  // GPU.
       base::Bind(&CastSessionDelegate::InitializationResult,
                  base::Unretained(this)),
       cast_transport_.get()));
   cast_transport_->SetPacketReceiver(cast_sender_->packet_receiver());
 }
 
 void CastSessionDelegate::InitializationResult(
     media::cast::CastInitializationStatus result) const {
   DCHECK(cast_sender_);
 
   // TODO(pwestin): handle the error codes.
   if (result == media::cast::STATUS_INITIALIZED) {
     if (!audio_frame_input_available_callback_.is_null()) {
       audio_frame_input_available_callback_.Run(cast_sender_->frame_input());
     }
     if (!video_frame_input_available_callback_.is_null()) {
       video_frame_input_available_callback_.Run(cast_sender_->frame_input());
     }
   }
 }
+
+void CastSessionDelegate::LogRawEvents(
+    const std::vector<media::cast::PacketEvent>& packet_events) {
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+
+  for (std::vector<media::cast::PacketEvent>::const_iterator it =
+           packet_events.begin();
+       it != packet_events.end();
+       ++it) {
+    cast_environment_->Logging()->InsertPacketEvent(it->timestamp,
+                                                    it->type,
+                                                    it->rtp_timestamp,
+                                                    it->frame_id,
+                                                    it->packet_id,
+                                                    it->max_packet_id,
+                                                    it->size);
+  }
+}