Cast: Provide more meaningful stats.

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"
 #include "chrome/renderer/media/cast_transport_sender_ipc.h"
 #include "content/public/renderer/render_thread.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/cast_sender.h"
-#include "media/cast/logging/encoding_event_subscriber.h"
 #include "media/cast/logging/log_serializer.h"
 #include "media/cast/logging/logging_defines.h"
-#include "media/cast/logging/stats_event_subscriber.h"
-#include "media/cast/logging/stats_util.h"
+#include "media/cast/logging/receiver_time_offset_estimator_impl.h"
 #include "media/cast/transport/cast_transport_config.h"
 #include "media/cast/transport/cast_transport_sender.h"
 
 using media::cast::AudioSenderConfig;
 using media::cast::CastEnvironment;
 using media::cast::CastSender;
 using media::cast::VideoSenderConfig;
 
 static base::LazyInstance<CastThreads> g_cast_threads =
     LAZY_INSTANCE_INITIALIZER;
@@ skipping 13 matching lines @@
 
 CastSessionDelegate::CastSessionDelegate()
     : io_message_loop_proxy_(
           content::RenderThread::Get()->GetIOMessageLoopProxy()),
       weak_factory_(this) {
   DCHECK(io_message_loop_proxy_);
 }
 
 CastSessionDelegate::~CastSessionDelegate() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
-
-  if (cast_environment_.get()) {
-    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::StartAudio(
     const AudioSenderConfig& config,
     const AudioFrameInputAvailableCallback& callback,
     const ErrorCallback& error_callback) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (!cast_transport_ || !cast_sender_) {
     error_callback.Run("Destination not set.");
@@ skipping 47 matching lines @@
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   // CastSender uses the renderer's IO thread as the main thread. This reduces
   // thread hopping for incoming video frames and outgoing network packets.
   cast_environment_ = new CastEnvironment(
       scoped_ptr<base::TickClock>(new base::DefaultTickClock()).Pass(),
       base::MessageLoopProxy::current(),
       g_cast_threads.Get().GetAudioEncodeMessageLoopProxy(),
       g_cast_threads.Get().GetVideoEncodeMessageLoopProxy());
 
+  event_subscribers_.reset(new RawEventSubscriberBundle(cast_environment_));
+
   // 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(
       remote_endpoint,
       base::Bind(&CastSessionDelegate::StatusNotificationCB,
                  base::Unretained(this)),
       base::Bind(&CastSessionDelegate::LogRawEvents, base::Unretained(this))));
 
   cast_sender_ = CastSender::Create(cast_environment_, cast_transport_.get());
   cast_transport_->SetPacketReceiver(cast_sender_->packet_receiver());
 }
 
+RawEventSubscriberBundleForStream::RawEventSubscriberBundleForStream(
+    bool is_audio,
+    media::cast::ReceiverTimeOffsetEstimator* offset_estimator,
+    const scoped_refptr<media::cast::CastEnvironment>& cast_environment)
+    : cast_environment_(cast_environment),
+      event_subscriber_(
+          is_audio ? media::cast::AUDIO_EVENT : media::cast::VIDEO_EVENT,
+          is_audio ? kMaxAudioEventEntries : kMaxVideoEventEntries),
+      stats_subscriber_(
+          is_audio ? media::cast::AUDIO_EVENT : media::cast::VIDEO_EVENT,
+          cast_environment->Clock(), offset_estimator) {
+  cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber_);
+  cast_environment_->Logging()->AddRawEventSubscriber(&stats_subscriber_);
+}
+
+RawEventSubscriberBundleForStream::~RawEventSubscriberBundleForStream() {
+  cast_environment_->Logging()->RemoveRawEventSubscriber(&event_subscriber_);
+  cast_environment_->Logging()->RemoveRawEventSubscriber(&stats_subscriber_);
+}
+
+media::cast::EncodingEventSubscriber*
+RawEventSubscriberBundleForStream::GetEncodingEventSubscriber() {
+  return &event_subscriber_;
+}
+
+media::cast::StatsEventSubscriber*
+RawEventSubscriberBundleForStream::GetStatsEventSubscriber() {
+  return &stats_subscriber_;
+}
+
+RawEventSubscriberBundle::RawEventSubscriberBundle(
+    const scoped_refptr<media::cast::CastEnvironment>& cast_environment)
+    : cast_environment_(cast_environment) {}
+
+RawEventSubscriberBundle::~RawEventSubscriberBundle() {
+  if (receiver_offset_estimator_.get()) {
+    cast_environment_->Logging()->RemoveRawEventSubscriber(
+        receiver_offset_estimator_.get());
+  }
+}
+
+void RawEventSubscriberBundle::AddEventSubscribers(bool is_audio) {
+  if (!receiver_offset_estimator_.get()) {
+    receiver_offset_estimator_.reset(
+        new media::cast::ReceiverTimeOffsetEstimatorImpl);
+    cast_environment_->Logging()->AddRawEventSubscriber(
+        receiver_offset_estimator_.get());
+  }
+  SubscribersMapByStream::iterator it = subscribers_.find(is_audio);
+  if (it != subscribers_.end())
+    return;
+
+  subscribers_.insert(std::make_pair(
+      is_audio,
+      new RawEventSubscriberBundleForStream(
+          is_audio, receiver_offset_estimator_.get(), cast_environment_)));
+}
+
+void RawEventSubscriberBundle::RemoveEventSubscribers(bool is_audio) {
+  SubscribersMapByStream::iterator it = subscribers_.find(is_audio);
+  if (it == subscribers_.end())
+    return;
+
+  subscribers_.erase(it);
+  if (subscribers_.empty()) {
+    cast_environment_->Logging()->RemoveRawEventSubscriber(
+        receiver_offset_estimator_.get());
+    receiver_offset_estimator_.reset();
+  }
+}
+
+media::cast::EncodingEventSubscriber*
+RawEventSubscriberBundle::GetEncodingEventSubscriber(bool is_audio) {
+  SubscribersMapByStream::iterator it = subscribers_.find(is_audio);
+  return it == subscribers_.end() ?
+      NULL : it->second->GetEncodingEventSubscriber();
+}
+
+media::cast::StatsEventSubscriber*
+RawEventSubscriberBundle::GetStatsEventSubscriber(bool is_audio) {
+  SubscribersMapByStream::iterator it = subscribers_.find(is_audio);
+  return it == subscribers_.end() ?
+      NULL : it->second->GetStatsEventSubscriber();
+}
+
 void CastSessionDelegate::ToggleLogging(bool is_audio, bool enable) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
-  if (!cast_environment_.get())
+  if (!event_subscribers_.get())
     return;
-  if (enable) {
-    if (is_audio) {
-      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 (!audio_stats_subscriber_.get()) {
-        audio_stats_subscriber_.reset(
-            new media::cast::StatsEventSubscriber(media::cast::AUDIO_EVENT));
-        cast_environment_->Logging()->AddRawEventSubscriber(
-            audio_stats_subscriber_.get());
-      }
-    } else {
-      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());
-      }
-      if (!video_stats_subscriber_.get()) {
-        video_stats_subscriber_.reset(
-            new media::cast::StatsEventSubscriber(media::cast::VIDEO_EVENT));
-        cast_environment_->Logging()->AddRawEventSubscriber(
-            video_stats_subscriber_.get());
-      }
-    }
-  } else {
-    if (is_audio) {
-      if (audio_event_subscriber_.get()) {
-        cast_environment_->Logging()->RemoveRawEventSubscriber(
-            audio_event_subscriber_.get());
-        audio_event_subscriber_.reset();
-      }
-      if (audio_stats_subscriber_.get()) {
-        cast_environment_->Logging()->RemoveRawEventSubscriber(
-            audio_stats_subscriber_.get());
-        audio_stats_subscriber_.reset();
-      }
-    } else {
-      if (video_event_subscriber_.get()) {
-        cast_environment_->Logging()->RemoveRawEventSubscriber(
-            video_event_subscriber_.get());
-        video_event_subscriber_.reset();
-      }
-      if (video_stats_subscriber_.get()) {
-        cast_environment_->Logging()->RemoveRawEventSubscriber(
-            video_stats_subscriber_.get());
-        video_stats_subscriber_.reset();
-      }
-    }
-  }
+
+  if (enable)
+    event_subscribers_->AddEventSubscribers(is_audio);
+  else
+    event_subscribers_->RemoveEventSubscribers(is_audio);
 }
 
 void CastSessionDelegate::GetEventLogsAndReset(
     bool is_audio,
     const EventLogsCallback& callback) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
+  if (!event_subscribers_.get()) {
+    callback.Run(make_scoped_ptr(new base::BinaryValue).Pass());
+    return;
+  }
+
   media::cast::EncodingEventSubscriber* subscriber =
-      is_audio ? audio_event_subscriber_.get() : video_event_subscriber_.get();
+      event_subscribers_->GetEncodingEventSubscriber(is_audio);
   if (!subscriber) {
     callback.Run(make_scoped_ptr(new base::BinaryValue).Pass());
     return;
   }
 
   media::cast::proto::LogMetadata metadata;
   media::cast::FrameEventMap frame_events;
   media::cast::PacketEventMap packet_events;
 
   subscriber->GetEventsAndReset(&metadata, &frame_events, &packet_events);
@@ skipping 16 matching lines @@
 
   DVLOG(2) << "Serialized log length: " << output_bytes;
 
   scoped_ptr<base::BinaryValue> blob(
       new base::BinaryValue(serialized_log.Pass(), output_bytes));
   callback.Run(blob.Pass());
 }
 
 void CastSessionDelegate::GetStatsAndReset(bool is_audio,
                                            const StatsCallback& callback) {
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+
+  if (!event_subscribers_.get()) {
+    callback.Run(make_scoped_ptr(new base::DictionaryValue).Pass());
+    return;
+  }
+
   media::cast::StatsEventSubscriber* subscriber =
-      is_audio ? audio_stats_subscriber_.get() : video_stats_subscriber_.get();
+      event_subscribers_->GetStatsEventSubscriber(is_audio);
   if (!subscriber) {
     callback.Run(make_scoped_ptr(new base::DictionaryValue).Pass());
     return;
   }
 
-  media::cast::FrameStatsMap frame_stats;
-  subscriber->GetFrameStats(&frame_stats);
-  media::cast::PacketStatsMap packet_stats;
-  subscriber->GetPacketStats(&packet_stats);
+  scoped_ptr<base::DictionaryValue> stats = subscriber->GetStats();
   subscriber->Reset();
 
-  scoped_ptr<base::DictionaryValue> stats = media::cast::ConvertStats(
-      frame_stats, packet_stats);
-
   callback.Run(stats.Pass());
 }
 
 void CastSessionDelegate::StatusNotificationCB(
     media::cast::transport::CastTransportStatus unused_status) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   // TODO(hubbe): Call javascript UDPTransport error function.
 }
 
 void CastSessionDelegate::InitializationResultCB(
@@ skipping 20 matching lines @@
        ++it) {
     cast_environment_->Logging()->InsertPacketEvent(it->timestamp,
                                                     it->type,
                                                     it->rtp_timestamp,
                                                     it->frame_id,
                                                     it->packet_id,
                                                     it->max_packet_id,
                                                     it->size);
   }
 }