FileWrapper[Impl] modifications and actually remove the "Impl" class.

webrtc/modules/audio_processing/audio_processing_impl.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 193 matching lines @@
 }
 
 AudioProcessingImpl::~AudioProcessingImpl() {
   // Depends on gain_control_ and
   // public_submodules_->gain_control_for_experimental_agc.
   private_submodules_->agc_manager.reset();
   // Depends on gain_control_.
   public_submodules_->gain_control_for_experimental_agc.reset();
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->Open()) {
-    debug_dump_.debug_file->CloseFile();
-  }
+  debug_dump_.debug_file->CloseFile();
 #endif
 }
 
 int AudioProcessingImpl::Initialize() {
   // Run in a single-threaded manner during initialization.
   rtc::CritScope cs_render(&crit_render_);
   rtc::CritScope cs_capture(&crit_capture_);
   return InitializeLocked();
 }
 
@@ skipping 92 matching lines @@
   InitializeExperimentalAgc();
   InitializeTransient();
   InitializeBeamformer();
   InitializeIntelligibility();
   InitializeHighPassFilter();
   InitializeNoiseSuppression();
   InitializeLevelEstimator();
   InitializeVoiceDetection();
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->Open()) {
+  if (debug_dump_.debug_file->is_open()) {
     int err = WriteInitMessage();
     if (err != kNoError) {
       return err;
     }
   }
 #endif
 
   return kNoError;
 }
 
@@ skipping 190 matching lines @@
   {
     // Do conditional reinitialization.
     rtc::CritScope cs_render(&crit_render_);
     RETURN_ON_ERR(MaybeInitializeCapture(processing_config));
   }
   rtc::CritScope cs_capture(&crit_capture_);
   assert(processing_config.input_stream().num_frames() ==
          formats_.api_format.input_stream().num_frames());
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->Open()) {
+  if (debug_dump_.debug_file->is_open()) {
     RETURN_ON_ERR(WriteConfigMessage(false));
 
     debug_dump_.capture.event_msg->set_type(audioproc::Event::STREAM);
     audioproc::Stream* msg = debug_dump_.capture.event_msg->mutable_stream();
     const size_t channel_size =
         sizeof(float) * formats_.api_format.input_stream().num_frames();
     for (size_t i = 0; i < formats_.api_format.input_stream().num_channels();
          ++i)
       msg->add_input_channel(src[i], channel_size);
   }
 #endif
 
   capture_.capture_audio->CopyFrom(src, formats_.api_format.input_stream());
   RETURN_ON_ERR(ProcessStreamLocked());
   capture_.capture_audio->CopyTo(formats_.api_format.output_stream(), dest);
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->Open()) {
+  if (debug_dump_.debug_file->is_open()) {
     audioproc::Stream* msg = debug_dump_.capture.event_msg->mutable_stream();
     const size_t channel_size =
         sizeof(float) * formats_.api_format.output_stream().num_frames();
     for (size_t i = 0; i < formats_.api_format.output_stream().num_channels();
          ++i)
       msg->add_output_channel(dest[i], channel_size);
     RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
                                           &debug_dump_.num_bytes_left_for_log_,
                                           &crit_debug_, &debug_dump_.capture));
   }
@@ skipping 48 matching lines @@
     rtc::CritScope cs_render(&crit_render_);
     RETURN_ON_ERR(MaybeInitializeCapture(processing_config));
   }
   rtc::CritScope cs_capture(&crit_capture_);
   if (frame->samples_per_channel_ !=
       formats_.api_format.input_stream().num_frames()) {
     return kBadDataLengthError;
   }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->Open()) {
+  if (debug_dump_.debug_file->is_open()) {
     debug_dump_.capture.event_msg->set_type(audioproc::Event::STREAM);
     audioproc::Stream* msg = debug_dump_.capture.event_msg->mutable_stream();
     const size_t data_size =
         sizeof(int16_t) * frame->samples_per_channel_ * frame->num_channels_;
     msg->set_input_data(frame->data_, data_size);
   }
 #endif
 
   capture_.capture_audio->DeinterleaveFrom(frame);
   RETURN_ON_ERR(ProcessStreamLocked());
   capture_.capture_audio->InterleaveTo(frame, output_copy_needed());
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->Open()) {
+  if (debug_dump_.debug_file->is_open()) {
     audioproc::Stream* msg = debug_dump_.capture.event_msg->mutable_stream();
     const size_t data_size =
         sizeof(int16_t) * frame->samples_per_channel_ * frame->num_channels_;
     msg->set_output_data(frame->data_, data_size);
     RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
                                           &debug_dump_.num_bytes_left_for_log_,
                                           &crit_debug_, &debug_dump_.capture));
   }
 #endif
 
   return kNoError;
 }
 
 int AudioProcessingImpl::ProcessStreamLocked() {
   // Ensure that not both the AEC and AECM are active at the same time.
   // TODO(peah): Simplify once the public API Enable functions for these
   // are moved to APM.
   RTC_DCHECK(!(public_submodules_->echo_cancellation->is_enabled() &&
                public_submodules_->echo_control_mobile->is_enabled()));
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->Open()) {
+  if (debug_dump_.debug_file->is_open()) {
     audioproc::Stream* msg = debug_dump_.capture.event_msg->mutable_stream();
     msg->set_delay(capture_nonlocked_.stream_delay_ms);
     msg->set_drift(
         public_submodules_->echo_cancellation->stream_drift_samples());
     msg->set_level(gain_control()->stream_analog_level());
     msg->set_keypress(capture_.key_pressed);
   }
 #endif
 
   MaybeUpdateHistograms();
@@ skipping 147 matching lines @@
 
   ProcessingConfig processing_config = formats_.api_format;
   processing_config.reverse_input_stream() = reverse_input_config;
   processing_config.reverse_output_stream() = reverse_output_config;
 
   RETURN_ON_ERR(MaybeInitializeRender(processing_config));
   assert(reverse_input_config.num_frames() ==
          formats_.api_format.reverse_input_stream().num_frames());
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->Open()) {
+  if (debug_dump_.debug_file->is_open()) {
     debug_dump_.render.event_msg->set_type(audioproc::Event::REVERSE_STREAM);
     audioproc::ReverseStream* msg =
         debug_dump_.render.event_msg->mutable_reverse_stream();
     const size_t channel_size =
         sizeof(float) * formats_.api_format.reverse_input_stream().num_frames();
     for (size_t i = 0;
          i < formats_.api_format.reverse_input_stream().num_channels(); ++i)
       msg->add_channel(src[i], channel_size);
     RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
                                           &debug_dump_.num_bytes_left_for_log_,
@@ skipping 34 matching lines @@
   processing_config.reverse_output_stream().set_num_channels(
       frame->num_channels_);
 
   RETURN_ON_ERR(MaybeInitializeRender(processing_config));
   if (frame->samples_per_channel_ !=
       formats_.api_format.reverse_input_stream().num_frames()) {
     return kBadDataLengthError;
   }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
-  if (debug_dump_.debug_file->Open()) {
+  if (debug_dump_.debug_file->is_open()) {
     debug_dump_.render.event_msg->set_type(audioproc::Event::REVERSE_STREAM);
     audioproc::ReverseStream* msg =
         debug_dump_.render.event_msg->mutable_reverse_stream();
     const size_t data_size =
         sizeof(int16_t) * frame->samples_per_channel_ * frame->num_channels_;
     msg->set_data(frame->data_, data_size);
     RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
                                           &debug_dump_.num_bytes_left_for_log_,
                                           &crit_debug_, &debug_dump_.render));
   }
@@ skipping 86 matching lines @@
   rtc::CritScope cs_capture(&crit_capture_);
   static_assert(kMaxFilenameSize == FileWrapper::kMaxFileNameSize, "");
 
   if (filename == nullptr) {
     return kNullPointerError;
   }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   debug_dump_.num_bytes_left_for_log_ = max_log_size_bytes;
   // Stop any ongoing recording.
-  if (debug_dump_.debug_file->Open()) {
-    if (debug_dump_.debug_file->CloseFile() == -1) {
-      return kFileError;
-    }
-  }
+  debug_dump_.debug_file->CloseFile();
 
   if (debug_dump_.debug_file->OpenFile(filename, false) == -1) {
-    debug_dump_.debug_file->CloseFile();
     return kFileError;
   }
 
   RETURN_ON_ERR(WriteConfigMessage(true));
   RETURN_ON_ERR(WriteInitMessage());
   return kNoError;
 #else
   return kUnsupportedFunctionError;
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
 int AudioProcessingImpl::StartDebugRecording(FILE* handle,
                                              int64_t max_log_size_bytes) {
   // Run in a single-threaded manner.
   rtc::CritScope cs_render(&crit_render_);
   rtc::CritScope cs_capture(&crit_capture_);
 
   if (handle == nullptr) {
     return kNullPointerError;
   }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   debug_dump_.num_bytes_left_for_log_ = max_log_size_bytes;
 
   // Stop any ongoing recording.
-  if (debug_dump_.debug_file->Open()) {
-    if (debug_dump_.debug_file->CloseFile() == -1) {
-      return kFileError;
-    }
-  }
+  debug_dump_.debug_file->CloseFile();
 
-  if (debug_dump_.debug_file->OpenFromFileHandle(handle, true, false) == -1) {
+  if (debug_dump_.debug_file->OpenFromFileHandle(handle) == -1) {
     return kFileError;
   }
 
   RETURN_ON_ERR(WriteConfigMessage(true));
   RETURN_ON_ERR(WriteInitMessage());
   return kNoError;
 #else
   return kUnsupportedFunctionError;
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
 int AudioProcessingImpl::StartDebugRecordingForPlatformFile(
     rtc::PlatformFile handle) {
   // Run in a single-threaded manner.
   rtc::CritScope cs_render(&crit_render_);
   rtc::CritScope cs_capture(&crit_capture_);
   FILE* stream = rtc::FdopenPlatformFileForWriting(handle);
   return StartDebugRecording(stream, -1);
 }
 
 int AudioProcessingImpl::StopDebugRecording() {
   // Run in a single-threaded manner.
   rtc::CritScope cs_render(&crit_render_);
   rtc::CritScope cs_capture(&crit_capture_);
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // We just return if recording hasn't started.
-  if (debug_dump_.debug_file->Open()) {
-    if (debug_dump_.debug_file->CloseFile() == -1) {
-      return kFileError;
-    }
-  }
+  debug_dump_.debug_file->CloseFile();
   return kNoError;
 #else
   return kUnsupportedFunctionError;
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
 EchoCancellation* AudioProcessingImpl::echo_cancellation() const {
   // Adding a lock here has no effect as it allows any access to the submodule
   // from the returned pointer.
   return public_submodules_->echo_cancellation.get();
@@ skipping 280 matching lines @@
 #endif
 
   if (!debug_state->event_msg->SerializeToString(&debug_state->event_str)) {
     return kUnspecifiedError;
   }
 
   {
     // Ensure atomic writes of the message.
     rtc::CritScope cs_debug(crit_debug);
 
-    RTC_DCHECK(debug_file->Open());
+    RTC_DCHECK(debug_file->is_open());
     // Update the byte counter.
     if (*filesize_limit_bytes >= 0) {
       *filesize_limit_bytes -=
           (sizeof(int32_t) + debug_state->event_str.length());
       if (*filesize_limit_bytes < 0) {
         // Not enough bytes are left to write this message, so stop logging.
         debug_file->CloseFile();
         return kNoError;
       }
     }
@@ skipping 94 matching lines @@
   debug_dump_.capture.event_msg->mutable_config()->CopyFrom(config);
 
   RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
                                         &debug_dump_.num_bytes_left_for_log_,
                                         &crit_debug_, &debug_dump_.capture));
   return kNoError;
 }
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 
 }  // namespace webrtc