Remove AudioDeviceObserver and make ADM not inherit from the Module interface.

pc/test/fakeaudiocapturemodule.cc

 /*
  *  Copyright 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.
  */
 
 #include "pc/test/fakeaudiocapturemodule.h"
 
 #include "rtc_base/checks.h"
 #include "rtc_base/refcount.h"
 #include "rtc_base/thread.h"
 #include "rtc_base/timeutils.h"
 
 // Audio sample value that is high enough that it doesn't occur naturally when
 // frames are being faked. E.g. NetEq will not generate this large sample value
 // unless it has received an audio frame containing a sample of this value.
 // Even simpler buffers would likely just contain audio sample values of 0.
 static const int kHighSampleValue = 10000;
 
-// Same value as src/modules/audio_device/main/source/audio_device_config.h in
-// https://code.google.com/p/webrtc/
-static const int kAdmMaxIdleTimeProcess = 1000;
-
 // Constants here are derived by running VoE using a real ADM.
 // The constants correspond to 10ms of mono audio at 44kHz.
 static const int kTimePerFrameMs = 10;
 static const uint8_t kNumberOfChannels = 1;
 static const int kSamplesPerSecond = 44000;
 static const int kTotalDelayMs = 0;
 static const int kClockDriftMs = 0;
 static const uint32_t kMaxVolume = 14392;
 
 enum {
   MSG_START_PROCESS,
   MSG_RUN_PROCESS,
 };
 
 FakeAudioCaptureModule::FakeAudioCaptureModule()
-    : last_process_time_ms_(0),
-      audio_callback_(nullptr),
+    : audio_callback_(nullptr),
       recording_(false),
       playing_(false),
       play_is_initialized_(false),
       rec_is_initialized_(false),
       current_mic_level_(kMaxVolume),
       started_(false),
       next_frame_time_(0),
       frames_received_(0) {
 }
 
@@ skipping 10 matching lines @@
     return nullptr;
   }
   return capture_module;
 }
 
 int FakeAudioCaptureModule::frames_received() const {
   rtc::CritScope cs(&crit_);
   return frames_received_;
 }
 
-int64_t FakeAudioCaptureModule::TimeUntilNextProcess() {
-  const int64_t current_time = rtc::TimeMillis();
-  if (current_time < last_process_time_ms_) {
-    // TODO: wraparound could be handled more gracefully.
-    return 0;
-  }
-  const int64_t elapsed_time = current_time - last_process_time_ms_;
-  if (kAdmMaxIdleTimeProcess < elapsed_time) {
-    return 0;
-  }
-  return kAdmMaxIdleTimeProcess - elapsed_time;
-}
-
-void FakeAudioCaptureModule::Process() {
-  last_process_time_ms_ = rtc::TimeMillis();
-}
-
 int32_t FakeAudioCaptureModule::ActiveAudioLayer(
     AudioLayer* /*audio_layer*/) const {
   RTC_NOTREACHED();
   return 0;
 }
 
 webrtc::AudioDeviceModule::ErrorCode FakeAudioCaptureModule::LastError() const {
   RTC_NOTREACHED();
   return webrtc::AudioDeviceModule::kAdmErrNone;
 }
 
-int32_t FakeAudioCaptureModule::RegisterEventObserver(
-    webrtc::AudioDeviceObserver* /*event_callback*/) {
-  // Only used to report warnings and errors. This fake implementation won't
-  // generate any so discard this callback.
-  return 0;
-}
-
 int32_t FakeAudioCaptureModule::RegisterAudioCallback(
     webrtc::AudioTransport* audio_callback) {
   rtc::CritScope cs(&crit_callback_);
   audio_callback_ = audio_callback;
   return 0;
 }
 
 int32_t FakeAudioCaptureModule::Init() {
   // Initialize is called by the factory method. Safe to ignore this Init call.
   return 0;
@@ skipping 378 matching lines @@
       RTC_NOTREACHED();
   }
 }
 
 bool FakeAudioCaptureModule::Initialize() {
   // Set the send buffer samples high enough that it would not occur on the
   // remote side unless a packet containing a sample of that magnitude has been
   // sent to it. Note that the audio processing pipeline will likely distort the
   // original signal.
   SetSendBuffer(kHighSampleValue);
-  last_process_time_ms_ = rtc::TimeMillis();
   return true;
 }
 
 void FakeAudioCaptureModule::SetSendBuffer(int value) {
   Sample* buffer_ptr = reinterpret_cast<Sample*>(send_buffer_);
   const size_t buffer_size_in_samples =
       sizeof(send_buffer_) / kNumberBytesPerSample;
   for (size_t i = 0; i < buffer_size_in_samples; ++i) {
     buffer_ptr[i] = value;
   }
@@ skipping 111 matching lines @@
                                               kNumberBytesPerSample,
                                               kNumberOfChannels,
                                               kSamplesPerSecond, kTotalDelayMs,
                                               kClockDriftMs, current_mic_level,
                                               key_pressed,
                                               current_mic_level) != 0) {
     RTC_NOTREACHED();
   }
   SetMicrophoneVolume(current_mic_level);
 }