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 45 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.
-  // Logging: enable raw events and stats collection.
   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::GetLoggingConfigWithRawEventsAndStatsEnabled());
+      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 98 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();
+  // Logging: enable raw events and stats collection.
+  media::cast::CastLoggingConfig logging_config =
+      media::cast::GetLoggingConfigWithRawEventsAndStatsEnabled();
+  Initialize(logging_config);
 
   // Rationale for using unretained: The callback cannot be called after the
   // destruction of CastTransportSenderIPC, and they both share the same thread.
   cast_transport_.reset(new CastTransportSenderIPC(
       local_endpoint_,
       remote_endpoint_,
       base::Bind(&CastSessionDelegate::StatusNotificationCB,
-                 base::Unretained(this))));
+                 base::Unretained(this)),
+      logging_config,
+      base::Bind(&CastSessionDelegate::LogRawEvents, base::Unretained(this))));
 
   // TODO(hubbe): set config.aes_key and config.aes_iv_mask.
   if (audio_config_) {
     media::cast::transport::CastTransportAudioConfig config;
     config.base.ssrc = audio_config_->sender_ssrc;
     config.codec = audio_config_->codec;
     config.base.rtp_config = audio_config_->rtp_config;
     config.frequency = audio_config_->frequency;
     config.channels = audio_config_->channels;
     cast_transport_->InitializeAudio(config);
@@ skipping 25 matching lines @@
   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);
+  }
+}