Test submission of complete AEC-dump refactoring.

webrtc/modules/audio_processing/aec_dumper/aec_dumper.h

+/*
+ *  Copyright (c) 2017 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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_AEC_DUMPER_AEC_DUMPER_H_
+#define WEBRTC_MODULES_AUDIO_PROCESSING_AEC_DUMPER_AEC_DUMPER_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webrtc/base/array_view.h"
+#include "webrtc/modules/audio_processing/include/audio_processing.h"
+
+namespace audioproc {
+class Event;
+}  // namespace audioproc
+
+namespace rtc {
+class TaskQueue;
+}  // namespace rtc
+
+namespace webrtc {
+
+class AudioFrame;
+
+// Struct for passing current config from APM without having to
+// include protobuf headers.
+struct InternalAPMConfig {
+  InternalAPMConfig();
+
+  bool aec_enabled = false;
+  bool aec_delay_agnostic_enabled = false;
+  bool aec_drift_compensation_enabled = false;
+  bool aec_extended_filter_enabled = false;
+  int aec_suppression_level = 0;
+  bool aecm_enabled = false;
+  bool aecm_comfort_noise_enabled = false;
+  int aecm_routing_mode = 0;
+  bool agc_enabled = false;
+  int agc_mode = 0;
+  bool agc_limiter_enabled = false;
+  bool hpf_enabled = false;
+  bool ns_enabled = false;
+  int ns_level = 0;
+  bool transient_suppression_enabled = false;
+  bool intelligibility_enhancer_enabled = false;
+  bool noise_robust_agc_enabled = false;
+  std::string experiments_description = "";
+
+ private:
+  RTC_DISALLOW_COPY_AND_ASSIGN(InternalAPMConfig);

[kwiberg-webrtc, 2017/03/29 08:57:11]

You don't have to use this macro anymore. Just do

  InternalAPMConfig(const InternalAPMConfig&) = delete;
  InternalAPMConfig& operator=(const InternalAPMConfig&) = delete;

It's a bit wordier, but you get to not call a macro, and it's the same syntax
you would use to define copy construction and assignment, and you put it in the
same place as the other constructors and assignment operators.

By the way, did you intend to prohibit moves too?

+};
+
+class AecDumper {
+ public:
+  // A capture stream frame is logged before and after processing in
+  // the same protobuf message. To facilitate that, a
+  // CaptureStreamInfo instance is first filled with Input, then
+  // Output.
+  //
+  // To log an input/output pair, first call
+  // AecDumper::GetCaptureStreamInfo.  Add the input and output to
+  // it. Then call AecDumper::WriteCaptureStreamMessage.
+  class CaptureStreamInfo {
+   public:
+    virtual ~CaptureStreamInfo() = default;
+    virtual void AddInput(std::vector<rtc::ArrayView<const float>> src) = 0;
+    virtual void AddOutput(std::vector<rtc::ArrayView<const float>> src) = 0;
+
+    virtual void AddInput(const AudioFrame& frame) = 0;
+    virtual void AddOutput(const AudioFrame& frame) = 0;
+
+    virtual void set_delay(int delay) = 0;
+    virtual void set_drift(int drift) = 0;
+    virtual void set_level(int level) = 0;
+    virtual void set_keypress(bool keypress) = 0;
+  };
+
+  AecDumper() = default;

[kwiberg-webrtc, 2017/03/29 08:57:11]

You forgot to remove this one.

+
+  virtual ~AecDumper() = default;
+
+  // TODO(aleloi): update comments to new creation scheme.
+  // If called when a recording is active, that file is closed, and a
+  // new file is opened. Messages waiting to be written asynchronously
+  // to the old file may be lost. Returns true iff opening file for
+  // writing succeeded.
+
+  // Closes associated file. Messages waiting to be written to file
+  // asynchronously may be lost. This method is safe to call when no
+  // recording is active. A recording does not have to be closed
+  // manually with this method; instead the AecDumper instance may be
+  // destroyed.
+  static std::unique_ptr<AecDumper> Create(std::string file_name,
+                                           int64_t max_log_size_bytes,
+                                           rtc::TaskQueue* worker_queue);
+  static std::unique_ptr<AecDumper> Create(FILE* handle,
+                                           int64_t max_log_size_bytes,
+                                           rtc::TaskQueue* worker_queue);
+
+  static std::unique_ptr<AecDumper> CreateNullDumper();
+
+  virtual std::unique_ptr<CaptureStreamInfo> GetCaptureStreamInfo() = 0;
+
+  // The Write* methods are always safe to call. If no recording is in
+  // progress, calls will have no effect. Messages are written to file
+  // in a 'best effort' manner. If the AecDumper can't keep up with
+  // the flow of messages, some will be silently dropped.
+  virtual void WriteInitMessage(const ProcessingConfig& api_format) = 0;
+
+  virtual void WriteReverseStreamMessage(const AudioFrame& frame) = 0;
+
+  virtual void WriteReverseStreamMessage(
+      std::vector<rtc::ArrayView<const float>> src) = 0;
+
+  virtual void WriteCaptureStreamMessage(
+      std::unique_ptr<CaptureStreamInfo> stream_info) = 0;
+
+  // If not |forced|, only writes the current config if it is
+  // different from the last saved one; if |forced|, writes the config
+  // regardless of the last saved.
+  virtual void WriteConfig(const InternalAPMConfig& config, bool forced) = 0;
+};
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_AUDIO_PROCESSING_AEC_DUMPER_AEC_DUMPER_H_