cast: Wire upp logging to be sent over RTCP between receiver and sender.

media/cast/test/receiver.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 <algorithm>
 #include <climits>
 #include <cstdarg>
 #include <cstdio>
 #include <string>
 
@@ skipping 148 matching lines @@
 
  private:
   friend class base::RefCountedThreadSafe<ReceiveProcess>;
 
   void DisplayFrame(const scoped_refptr<media::VideoFrame>& video_frame,
       const base::TimeTicks& render_time) {
 #ifdef OS_LINUX
     render_.RenderFrame(video_frame);
 #endif // OS_LINUX
     // Print out the delta between frames.
-    if (!last_render_time_.is_null()){
+    if (!last_render_time_.is_null()) {
         base::TimeDelta time_diff = render_time - last_render_time_;
         VLOG(0) << " RenderDelay[mS] =  " << time_diff.InMilliseconds();
     }
     last_render_time_ = render_time;
     GetVideoFrame();
   }
 
   void ReceiveAudioFrame(scoped_ptr<PcmAudioFrame> audio_frame,
                          const base::TimeTicks& playout_time) {
     // For audio just print the playout delta between audio frames.
     // Default diff time is kFrameTimerMs.
     base::TimeDelta time_diff =
         base::TimeDelta::FromMilliseconds(kFrameTimerMs);
-    if (!last_playout_time_.is_null()){
+    if (!last_playout_time_.is_null()) {
         time_diff = playout_time - last_playout_time_;
         VLOG(0) << " ***PlayoutDelay[mS] =  " << time_diff.InMilliseconds();
     }
     last_playout_time_ = playout_time;
     GetAudioFrame(time_diff);
   }
 
   void GetAudioFrame(base::TimeDelta playout_diff) {
     int num_10ms_blocks = playout_diff.InMilliseconds() / 10;
     frame_receiver_->GetRawAudioFrame(num_10ms_blocks, kAudioSamplingFrequency,
@@ skipping 24 matching lines @@
 
   VLOG(1) << "Cast Receiver";
   base::Thread audio_thread("Cast audio decoder thread");
   base::Thread video_thread("Cast video decoder thread");
   audio_thread.Start();
   video_thread.Start();
 
   base::DefaultTickClock clock;
   // Enable receiver side threads, and disable logging.
   scoped_refptr<media::cast::CastEnvironment> cast_environment(new
-      media::cast::CastEnvironment(&clock,
-                                   main_message_loop.message_loop_proxy(),
-                                   NULL,
-                                   audio_thread.message_loop_proxy(),
-                                   NULL,
-                                   video_thread.message_loop_proxy(),
-                                   main_message_loop.message_loop_proxy(),
-                                   media::cast::GetDefaultCastLoggingConfig()));
+      media::cast::CastEnvironment(
+          &clock,
+          main_message_loop.message_loop_proxy(),
+          NULL,
+          audio_thread.message_loop_proxy(),
+          NULL,
+          video_thread.message_loop_proxy(),
+          main_message_loop.message_loop_proxy(),
+          media::cast::GetDefaultCastReceiverLoggingConfig()));
 
   media::cast::AudioReceiverConfig audio_config =
       media::cast::GetAudioReceiverConfig();
   media::cast::VideoReceiverConfig video_config =
       media::cast::GetVideoReceiverConfig();
 
   int remote_port, local_port;
   media::cast::GetPorts(&remote_port, &local_port);
   if (!local_port) {
     LOG(ERROR) << "Invalid local port.";
@@ skipping 34 matching lines @@
       cast_receiver->packet_receiver();
 
   transport->StartReceiving(packet_receiver);
 
   scoped_refptr<media::cast::ReceiveProcess> receive_process(
       new media::cast::ReceiveProcess(cast_receiver->frame_receiver()));
   receive_process->Start();
   main_message_loop.Run();
   return 0;
 }