Adding some audio debugging flags

components/copresence/mediums/audio/audio_manager_impl.h

 // Copyright 2014 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.
 
 #ifndef COMPONENTS_COPRESENCE_MEDIUMS_AUDIO_AUDIO_MANAGER_IMPL_H_
 #define COMPONENTS_COPRESENCE_MEDIUMS_AUDIO_AUDIO_MANAGER_IMPL_H_
 
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/cancelable_callback.h"
+#include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "components/copresence/mediums/audio/audio_manager.h"
 #include "components/copresence/public/copresence_constants.h"
 #include "components/copresence/timed_map.h"
 
 namespace base {
 class Time;
 }
 
+namespace media {
+class AudioBus;
+}
+
 namespace copresence {
 
 class AudioPlayer;
 class AudioRecorder;
 class WhispernetClient;
 
 // The AudioManagerImpl class manages the playback and recording of tokens. Once
 // playback or recording is started, it is up to the audio manager to handle
 // the specifics of how this is done. In the future, for example, this class
 // may pause recording and playback to implement carrier sense.
@@ skipping 35 matching lines @@
 
   // Update our currently playing token with the new token. Change the playing
   // samples if needed. Prerequisite: Samples corresponding to this token
   // should already be in the samples cache.
   void UpdateToken(AudioType type, const std::string& token);
 
   void RestartPlaying(AudioType type);
 
   void DecodeSamplesConnector(const std::string& samples);
 
+  void DumpToken(AudioType audio_type,
+                 const std::string& token,
+                 const media::AudioBus* samples);
+
   WhispernetClient* whispernet_client_;
 
   // Callbacks to send tokens back to the CopresenceManager.
   TokensCallback tokens_cb_;
 
   // This cancelable callback is passed to the recorder. The recorder's
   // destruction will happen on the audio thread, so it can outlive us.
   base::CancelableCallback<void(const std::string&)> decode_cancelable_cb_;
 
   // We use the AudioType enum to index into all our data structures that work
   // on values for both audible and inaudible.
   static_assert(AUDIBLE == 0, "AudioType::AUDIBLE should be 0.");
   static_assert(INAUDIBLE == 1, "AudioType::INAUDIBLE should be 1.");
 
   // Indexed using enum AudioType.
+  bool player_enabled_[2];
   bool should_be_playing_[2];
   bool should_be_recording_[2];
 
   // AudioPlayer and AudioRecorder objects are self-deleting. When we call
   // Finalize on them, they clean themselves up on the Audio thread.
   // Indexed using enum AudioType.
   AudioPlayer* player_[2];
   AudioRecorder* recorder_;
 
   // Indexed using enum AudioType.
   std::string playing_token_[2];
+  size_t token_length_[2];
   base::Time started_playing_[2];
   base::Time heard_own_token_[2];
 
   // Cache that holds the encoded samples. After reaching its limit, the cache
   // expires the oldest samples first.
   // Indexed using enum AudioType.
   ScopedVector<SamplesMap> samples_cache_;
 
-  size_t token_length_[2];
+  base::FilePath dump_tokens_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioManagerImpl);
 };
 
 }  // namespace copresence
 
 #endif  // COMPONENTS_COPRESENCE_MEDIUMS_AUDIO_AUDIO_MANAGER_IMPL_H_