FileRecorder + FilePlayer: Let Create functions return unique_ptr

webrtc/voice_engine/channel.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 659 matching lines @@
           _channelId, kPlaybackPerChannel, (int16_t*)audioFrame->data_,
           audioFrame->samples_per_channel_, audioFrame->sample_rate_hz_,
           isStereo);
     }
   }
 
   // Record playout if enabled
   {
     rtc::CritScope cs(&_fileCritSect);
 
-    if (_outputFileRecording && _outputFileRecorderPtr) {
-      _outputFileRecorderPtr->RecordAudioToFile(*audioFrame);
+    if (_outputFileRecording && output_file_recorder_) {
+      output_file_recorder_->RecordAudioToFile(*audioFrame);
     }
   }
 
   // Measure audio level (0-9)
   // TODO(henrik.lundin) Use the |muted| information here too.
   _outputAudioLevel.ComputeLevel(*audioFrame);
 
   if (capture_start_rtp_time_stamp_ < 0 && audioFrame->timestamp_ != 0) {
     // The first frame with a valid rtp timestamp.
     capture_start_rtp_time_stamp_ = audioFrame->timestamp_;
@@ skipping 43 matching lines @@
   } else {
     highestNeeded = receiveFrequency;
   }
 
   // Special case, if we're playing a file on the playout side
   // we take that frequency into consideration as well
   // This is not needed on sending side, since the codec will
   // limit the spectrum anyway.
   if (channel_state_.Get().output_file_playing) {
     rtc::CritScope cs(&_fileCritSect);
-    if (_outputFilePlayerPtr) {
-      if (_outputFilePlayerPtr->Frequency() > highestNeeded) {
-        highestNeeded = _outputFilePlayerPtr->Frequency();
+    if (output_file_player_) {
+      if (output_file_player_->Frequency() > highestNeeded) {
+        highestNeeded = output_file_player_->Frequency();
       }
     }
   }
 
   return (highestNeeded);
 }
 
 int32_t Channel::CreateChannel(Channel*& channel,
                                int32_t channelId,
                                uint32_t instanceId,
@@ skipping 82 matching lines @@
       rtp_receive_statistics_(
           ReceiveStatistics::Create(Clock::GetRealTimeClock())),
       rtp_receiver_(
           RtpReceiver::CreateAudioReceiver(Clock::GetRealTimeClock(),
                                            this,
                                            this,
                                            rtp_payload_registry_.get())),
       telephone_event_handler_(rtp_receiver_->GetTelephoneEventHandler()),
       _outputAudioLevel(),
       _externalTransport(false),
-      _inputFilePlayerPtr(NULL),
-      _outputFilePlayerPtr(NULL),
-      _outputFileRecorderPtr(NULL),
       // Avoid conflict with other channels by adding 1024 - 1026,
       // won't use as much as 1024 channels.
       _inputFilePlayerId(VoEModuleId(instanceId, channelId) + 1024),
       _outputFilePlayerId(VoEModuleId(instanceId, channelId) + 1025),
       _outputFileRecorderId(VoEModuleId(instanceId, channelId) + 1026),
       _outputFileRecording(false),
       _outputExternalMedia(false),
       _inputExternalMediaCallbackPtr(NULL),
       _outputExternalMediaCallbackPtr(NULL),
       _timeStamp(0),  // This is just an offset, RTP module will add it's own
@@ skipping 100 matching lines @@
     DeRegisterExternalMediaProcessing(kPlaybackPerChannel);
   }
   if (channel_state_.Get().input_external_media) {
     DeRegisterExternalMediaProcessing(kRecordingPerChannel);
   }
   StopSend();
   StopPlayout();
 
   {
     rtc::CritScope cs(&_fileCritSect);
-    if (_inputFilePlayerPtr) {
-      _inputFilePlayerPtr->RegisterModuleFileCallback(NULL);
-      _inputFilePlayerPtr->StopPlayingFile();
-      FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
-      _inputFilePlayerPtr = NULL;
+    if (input_file_player_) {
+      input_file_player_->RegisterModuleFileCallback(NULL);
+      input_file_player_->StopPlayingFile();
     }
-    if (_outputFilePlayerPtr) {
-      _outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
-      _outputFilePlayerPtr->StopPlayingFile();
-      FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
-      _outputFilePlayerPtr = NULL;
+    if (output_file_player_) {
+      output_file_player_->RegisterModuleFileCallback(NULL);
+      output_file_player_->StopPlayingFile();
     }
-    if (_outputFileRecorderPtr) {
-      _outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
-      _outputFileRecorderPtr->StopRecording();
-      FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
-      _outputFileRecorderPtr = NULL;
+    if (output_file_recorder_) {
+      output_file_recorder_->RegisterModuleFileCallback(NULL);
+      output_file_recorder_->StopRecording();
     }
   }
 
   // The order to safely shutdown modules in a channel is:
   // 1. De-register callbacks in modules
   // 2. De-register modules in process thread
   // 3. Destroy modules
   if (audio_coding_->RegisterTransportCallback(NULL) == -1) {
     WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                  "~Channel() failed to de-register transport callback"
@@ skipping 762 matching lines @@
   if (channel_state_.Get().output_file_playing) {
     _engineStatisticsPtr->SetLastError(
         VE_ALREADY_PLAYING, kTraceError,
         "StartPlayingFileLocally() is already playing");
     return -1;
   }
 
   {
     rtc::CritScope cs(&_fileCritSect);
 
-    if (_outputFilePlayerPtr) {
-      _outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
-      FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
-      _outputFilePlayerPtr = NULL;
+    if (output_file_player_) {
+      output_file_player_->RegisterModuleFileCallback(NULL);
+      output_file_player_.reset();
     }
 
-    _outputFilePlayerPtr = FilePlayer::CreateFilePlayer(
+    output_file_player_ = FilePlayer::NewFilePlayer(
         _outputFilePlayerId, (const FileFormats)format);
 
-    if (_outputFilePlayerPtr == NULL) {
+    if (!output_file_player_) {
       _engineStatisticsPtr->SetLastError(
           VE_INVALID_ARGUMENT, kTraceError,
           "StartPlayingFileLocally() filePlayer format is not correct");
       return -1;
     }
 
     const uint32_t notificationTime(0);
 
-    if (_outputFilePlayerPtr->StartPlayingFile(
+    if (output_file_player_->StartPlayingFile(
             fileName, loop, startPosition, volumeScaling, notificationTime,
             stopPosition, (const CodecInst*)codecInst) != 0) {
       _engineStatisticsPtr->SetLastError(
           VE_BAD_FILE, kTraceError,
           "StartPlayingFile() failed to start file playout");
-      _outputFilePlayerPtr->StopPlayingFile();
-      FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
-      _outputFilePlayerPtr = NULL;
+      output_file_player_->StopPlayingFile();
+      output_file_player_.reset();
       return -1;
     }
-    _outputFilePlayerPtr->RegisterModuleFileCallback(this);
+    output_file_player_->RegisterModuleFileCallback(this);
     channel_state_.SetOutputFilePlaying(true);
   }
 
   if (RegisterFilePlayingToMixer() != 0)
     return -1;
 
   return 0;
 }
 
 int Channel::StartPlayingFileLocally(InStream* stream,
@@ skipping 18 matching lines @@
     _engineStatisticsPtr->SetLastError(
         VE_ALREADY_PLAYING, kTraceError,
         "StartPlayingFileLocally() is already playing");
     return -1;
   }
 
   {
     rtc::CritScope cs(&_fileCritSect);
 
     // Destroy the old instance
-    if (_outputFilePlayerPtr) {
-      _outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
-      FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
-      _outputFilePlayerPtr = NULL;
+    if (output_file_player_) {
+      output_file_player_->RegisterModuleFileCallback(NULL);
+      output_file_player_.reset();
     }
 
     // Create the instance
-    _outputFilePlayerPtr = FilePlayer::CreateFilePlayer(
+    output_file_player_ = FilePlayer::NewFilePlayer(
         _outputFilePlayerId, (const FileFormats)format);
 
-    if (_outputFilePlayerPtr == NULL) {
+    if (!output_file_player_) {
       _engineStatisticsPtr->SetLastError(
           VE_INVALID_ARGUMENT, kTraceError,
           "StartPlayingFileLocally() filePlayer format isnot correct");
       return -1;
     }
 
     const uint32_t notificationTime(0);
 
-    if (_outputFilePlayerPtr->StartPlayingFile(*stream, startPosition,
-                                               volumeScaling, notificationTime,
-                                               stopPosition, codecInst) != 0) {
+    if (output_file_player_->StartPlayingFile(*stream, startPosition,
+                                              volumeScaling, notificationTime,
+                                              stopPosition, codecInst) != 0) {
       _engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError,
                                          "StartPlayingFile() failed to "
                                          "start file playout");
-      _outputFilePlayerPtr->StopPlayingFile();
-      FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
-      _outputFilePlayerPtr = NULL;
+      output_file_player_->StopPlayingFile();
+      output_file_player_.reset();
       return -1;
     }
-    _outputFilePlayerPtr->RegisterModuleFileCallback(this);
+    output_file_player_->RegisterModuleFileCallback(this);
     channel_state_.SetOutputFilePlaying(true);
   }
 
   if (RegisterFilePlayingToMixer() != 0)
     return -1;
 
   return 0;
 }
 
 int Channel::StopPlayingFileLocally() {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::StopPlayingFileLocally()");
 
   if (!channel_state_.Get().output_file_playing) {
     return 0;
   }
 
   {
     rtc::CritScope cs(&_fileCritSect);
 
-    if (_outputFilePlayerPtr->StopPlayingFile() != 0) {
+    if (output_file_player_->StopPlayingFile() != 0) {
       _engineStatisticsPtr->SetLastError(
           VE_STOP_RECORDING_FAILED, kTraceError,
           "StopPlayingFile() could not stop playing");
       return -1;
     }
-    _outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
-    FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
-    _outputFilePlayerPtr = NULL;
+    output_file_player_->RegisterModuleFileCallback(NULL);
+    output_file_player_.reset();
     channel_state_.SetOutputFilePlaying(false);
   }
   // _fileCritSect cannot be taken while calling
   // SetAnonymousMixibilityStatus. Refer to comments in
   // StartPlayingFileLocally(const char* ...) for more details.
   if (_outputMixerPtr->SetAnonymousMixabilityStatus(*this, false) != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_AUDIO_CONF_MIX_MODULE_ERROR, kTraceError,
         "StopPlayingFile() failed to stop participant from playing as"
         "file in the mixer");
@@ skipping 19 matching lines @@
   // |_fileCritSect| cannot be taken while calling
   // SetAnonymousMixabilityStatus() since as soon as the participant is added
   // frames can be pulled by the mixer. Since the frames are generated from
   // the file, _fileCritSect will be taken. This would result in a deadlock.
   if (_outputMixerPtr->SetAnonymousMixabilityStatus(*this, true) != 0) {
     channel_state_.SetOutputFilePlaying(false);
     rtc::CritScope cs(&_fileCritSect);
     _engineStatisticsPtr->SetLastError(
         VE_AUDIO_CONF_MIX_MODULE_ERROR, kTraceError,
         "StartPlayingFile() failed to add participant as file to mixer");
-    _outputFilePlayerPtr->StopPlayingFile();
-    FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
-    _outputFilePlayerPtr = NULL;
+    output_file_player_->StopPlayingFile();
+    output_file_player_.reset();
     return -1;
   }
 
   return 0;
 }
 
 int Channel::StartPlayingFileAsMicrophone(const char* fileName,
                                           bool loop,
                                           FileFormats format,
                                           int startPosition,
@@ skipping 10 matching lines @@
   rtc::CritScope cs(&_fileCritSect);
 
   if (channel_state_.Get().input_file_playing) {
     _engineStatisticsPtr->SetLastError(
         VE_ALREADY_PLAYING, kTraceWarning,
         "StartPlayingFileAsMicrophone() filePlayer is playing");
     return 0;
   }
 
   // Destroy the old instance
-  if (_inputFilePlayerPtr) {
-    _inputFilePlayerPtr->RegisterModuleFileCallback(NULL);
-    FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
-    _inputFilePlayerPtr = NULL;
+  if (input_file_player_) {
+    input_file_player_->RegisterModuleFileCallback(NULL);
+    input_file_player_.reset();
   }
 
   // Create the instance
-  _inputFilePlayerPtr = FilePlayer::CreateFilePlayer(_inputFilePlayerId,
-                                                     (const FileFormats)format);
+  input_file_player_ = FilePlayer::NewFilePlayer(_inputFilePlayerId,
+                                                    (const FileFormats)format);
 
-  if (_inputFilePlayerPtr == NULL) {
+  if (!input_file_player_) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_ARGUMENT, kTraceError,
         "StartPlayingFileAsMicrophone() filePlayer format isnot correct");
     return -1;
   }
 
   const uint32_t notificationTime(0);
 
-  if (_inputFilePlayerPtr->StartPlayingFile(
+  if (input_file_player_->StartPlayingFile(
           fileName, loop, startPosition, volumeScaling, notificationTime,
           stopPosition, (const CodecInst*)codecInst) != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_BAD_FILE, kTraceError,
         "StartPlayingFile() failed to start file playout");
-    _inputFilePlayerPtr->StopPlayingFile();
-    FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
-    _inputFilePlayerPtr = NULL;
+    input_file_player_->StopPlayingFile();
+    input_file_player_.reset();
     return -1;
   }
-  _inputFilePlayerPtr->RegisterModuleFileCallback(this);
+  input_file_player_->RegisterModuleFileCallback(this);
   channel_state_.SetInputFilePlaying(true);
 
   return 0;
 }
 
 int Channel::StartPlayingFileAsMicrophone(InStream* stream,
                                           FileFormats format,
                                           int startPosition,
                                           float volumeScaling,
                                           int stopPosition,
@@ skipping 13 matching lines @@
   rtc::CritScope cs(&_fileCritSect);
 
   if (channel_state_.Get().input_file_playing) {
     _engineStatisticsPtr->SetLastError(
         VE_ALREADY_PLAYING, kTraceWarning,
         "StartPlayingFileAsMicrophone() is playing");
     return 0;
   }
 
   // Destroy the old instance
-  if (_inputFilePlayerPtr) {
-    _inputFilePlayerPtr->RegisterModuleFileCallback(NULL);
-    FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
-    _inputFilePlayerPtr = NULL;
+  if (input_file_player_) {
+    input_file_player_->RegisterModuleFileCallback(NULL);
+    input_file_player_.reset();
   }
 
   // Create the instance
-  _inputFilePlayerPtr = FilePlayer::CreateFilePlayer(_inputFilePlayerId,
-                                                     (const FileFormats)format);
+  input_file_player_ = FilePlayer::NewFilePlayer(_inputFilePlayerId,
+                                                    (const FileFormats)format);
 
-  if (_inputFilePlayerPtr == NULL) {
+  if (!input_file_player_) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_ARGUMENT, kTraceError,
         "StartPlayingInputFile() filePlayer format isnot correct");
     return -1;
   }
 
   const uint32_t notificationTime(0);
 
-  if (_inputFilePlayerPtr->StartPlayingFile(*stream, startPosition,
-                                            volumeScaling, notificationTime,
-                                            stopPosition, codecInst) != 0) {
+  if (input_file_player_->StartPlayingFile(*stream, startPosition,
+                                           volumeScaling, notificationTime,
+                                           stopPosition, codecInst) != 0) {
     _engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError,
                                        "StartPlayingFile() failed to start "
                                        "file playout");
-    _inputFilePlayerPtr->StopPlayingFile();
-    FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
-    _inputFilePlayerPtr = NULL;
+    input_file_player_->StopPlayingFile();
+    input_file_player_.reset();
     return -1;
   }
 
-  _inputFilePlayerPtr->RegisterModuleFileCallback(this);
+  input_file_player_->RegisterModuleFileCallback(this);
   channel_state_.SetInputFilePlaying(true);
 
   return 0;
 }
 
 int Channel::StopPlayingFileAsMicrophone() {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::StopPlayingFileAsMicrophone()");
 
   rtc::CritScope cs(&_fileCritSect);
 
   if (!channel_state_.Get().input_file_playing) {
     return 0;
   }
 
-  if (_inputFilePlayerPtr->StopPlayingFile() != 0) {
+  if (input_file_player_->StopPlayingFile() != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_STOP_RECORDING_FAILED, kTraceError,
         "StopPlayingFile() could not stop playing");
     return -1;
   }
-  _inputFilePlayerPtr->RegisterModuleFileCallback(NULL);
-  FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
-  _inputFilePlayerPtr = NULL;
+  input_file_player_->RegisterModuleFileCallback(NULL);
+  input_file_player_.reset();
   channel_state_.SetInputFilePlaying(false);
 
   return 0;
 }
 
 int Channel::IsPlayingFileAsMicrophone() const {
   return channel_state_.Get().input_file_playing;
 }
 
 int Channel::StartRecordingPlayout(const char* fileName,
@@ skipping 25 matching lines @@
              (STR_CASE_CMP(codecInst->plname, "PCMU") == 0) ||
              (STR_CASE_CMP(codecInst->plname, "PCMA") == 0)) {
     format = kFileFormatWavFile;
   } else {
     format = kFileFormatCompressedFile;
   }
 
   rtc::CritScope cs(&_fileCritSect);
 
   // Destroy the old instance
-  if (_outputFileRecorderPtr) {
-    _outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
-    FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
-    _outputFileRecorderPtr = NULL;
+  if (output_file_recorder_) {
+    output_file_recorder_->RegisterModuleFileCallback(NULL);
+    output_file_recorder_.reset();
   }
 
-  _outputFileRecorderPtr = FileRecorder::CreateFileRecorder(
+  output_file_recorder_ = FileRecorder::CreateFileRecorder(
       _outputFileRecorderId, (const FileFormats)format);
-  if (_outputFileRecorderPtr == NULL) {
+  if (!output_file_recorder_) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_ARGUMENT, kTraceError,
         "StartRecordingPlayout() fileRecorder format isnot correct");
     return -1;
   }
 
-  if (_outputFileRecorderPtr->StartRecordingAudioFile(
+  if (output_file_recorder_->StartRecordingAudioFile(
           fileName, (const CodecInst&)*codecInst, notificationTime) != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_BAD_FILE, kTraceError,
         "StartRecordingAudioFile() failed to start file recording");
-    _outputFileRecorderPtr->StopRecording();
-    FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
-    _outputFileRecorderPtr = NULL;
+    output_file_recorder_->StopRecording();
+    output_file_recorder_.reset();
     return -1;
   }
-  _outputFileRecorderPtr->RegisterModuleFileCallback(this);
+  output_file_recorder_->RegisterModuleFileCallback(this);
   _outputFileRecording = true;
 
   return 0;
 }
 
 int Channel::StartRecordingPlayout(OutStream* stream,
                                    const CodecInst* codecInst) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::StartRecordingPlayout()");
 
@@ skipping 20 matching lines @@
              (STR_CASE_CMP(codecInst->plname, "PCMU") == 0) ||
              (STR_CASE_CMP(codecInst->plname, "PCMA") == 0)) {
     format = kFileFormatWavFile;
   } else {
     format = kFileFormatCompressedFile;
   }
 
   rtc::CritScope cs(&_fileCritSect);
 
   // Destroy the old instance
-  if (_outputFileRecorderPtr) {
-    _outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
-    FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
-    _outputFileRecorderPtr = NULL;
+  if (output_file_recorder_) {
+    output_file_recorder_->RegisterModuleFileCallback(NULL);
+    output_file_recorder_.reset();
   }
 
-  _outputFileRecorderPtr = FileRecorder::CreateFileRecorder(
+  output_file_recorder_ = FileRecorder::CreateFileRecorder(
       _outputFileRecorderId, (const FileFormats)format);
-  if (_outputFileRecorderPtr == NULL) {
+  if (!output_file_recorder_) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_ARGUMENT, kTraceError,
         "StartRecordingPlayout() fileRecorder format isnot correct");
     return -1;
   }
 
-  if (_outputFileRecorderPtr->StartRecordingAudioFile(*stream, *codecInst,
-                                                      notificationTime) != 0) {
+  if (output_file_recorder_->StartRecordingAudioFile(*stream, *codecInst,
+                                                     notificationTime) != 0) {
     _engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError,
                                        "StartRecordingPlayout() failed to "
                                        "start file recording");
-    _outputFileRecorderPtr->StopRecording();
-    FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
-    _outputFileRecorderPtr = NULL;
+    output_file_recorder_->StopRecording();
+    output_file_recorder_.reset();
     return -1;
   }
 
-  _outputFileRecorderPtr->RegisterModuleFileCallback(this);
+  output_file_recorder_->RegisterModuleFileCallback(this);
   _outputFileRecording = true;
 
   return 0;
 }
 
 int Channel::StopRecordingPlayout() {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                "Channel::StopRecordingPlayout()");
 
   if (!_outputFileRecording) {
     WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, -1),
                  "StopRecordingPlayout() isnot recording");
     return -1;
   }
 
   rtc::CritScope cs(&_fileCritSect);
 
-  if (_outputFileRecorderPtr->StopRecording() != 0) {
+  if (output_file_recorder_->StopRecording() != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_STOP_RECORDING_FAILED, kTraceError,
         "StopRecording() could not stop recording");
     return (-1);
   }
-  _outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
-  FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
-  _outputFileRecorderPtr = NULL;
+  output_file_recorder_->RegisterModuleFileCallback(NULL);
+  output_file_recorder_.reset();
   _outputFileRecording = false;
 
   return 0;
 }
 
 void Channel::SetMixWithMicStatus(bool mix) {
   rtc::CritScope cs(&_fileCritSect);
   _mixFileWithMicrophone = mix;
 }
 
@@ skipping 1029 matching lines @@
 
 // TODO(andrew): refactor Mix functions here and in transmit_mixer.cc to use
 // a shared helper.
 int32_t Channel::MixOrReplaceAudioWithFile(int mixingFrequency) {
   std::unique_ptr<int16_t[]> fileBuffer(new int16_t[640]);
   size_t fileSamples(0);
 
   {
     rtc::CritScope cs(&_fileCritSect);
 
-    if (_inputFilePlayerPtr == NULL) {
+    if (!input_file_player_) {
       WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                    "Channel::MixOrReplaceAudioWithFile() fileplayer"
                    " doesnt exist");
       return -1;
     }
 
-    if (_inputFilePlayerPtr->Get10msAudioFromFile(fileBuffer.get(), fileSamples,
-                                                  mixingFrequency) == -1) {
+    if (input_file_player_->Get10msAudioFromFile(fileBuffer.get(), fileSamples,
+                                                 mixingFrequency) == -1) {
       WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                    "Channel::MixOrReplaceAudioWithFile() file mixing "
                    "failed");
       return -1;
     }
     if (fileSamples == 0) {
       WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                    "Channel::MixOrReplaceAudioWithFile() file is ended");
       return 0;
     }
@@ skipping 19 matching lines @@
 
 int32_t Channel::MixAudioWithFile(AudioFrame& audioFrame, int mixingFrequency) {
   assert(mixingFrequency <= 48000);
 
   std::unique_ptr<int16_t[]> fileBuffer(new int16_t[960]);
   size_t fileSamples(0);
 
   {
     rtc::CritScope cs(&_fileCritSect);
 
-    if (_outputFilePlayerPtr == NULL) {
+    if (!output_file_player_) {
       WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                    "Channel::MixAudioWithFile() file mixing failed");
       return -1;
     }
 
     // We should get the frequency we ask for.
-    if (_outputFilePlayerPtr->Get10msAudioFromFile(
-            fileBuffer.get(), fileSamples, mixingFrequency) == -1) {
+    if (output_file_player_->Get10msAudioFromFile(fileBuffer.get(), fileSamples,
+                                                  mixingFrequency) == -1) {
       WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                    "Channel::MixAudioWithFile() file mixing failed");
       return -1;
     }
   }
 
   if (audioFrame.samples_per_channel_ == fileSamples) {
     // Currently file stream is always mono.
     // TODO(xians): Change the code when FilePlayer supports real stereo.
     MixWithSat(audioFrame.data_, audioFrame.num_channels_, fileBuffer.get(), 1,
@@ skipping 219 matching lines @@
   int64_t min_rtt = 0;
   if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt) !=
       0) {
     return 0;
   }
   return rtt;
 }
 
 }  // namespace voe
 }  // namespace webrtc