Creating the audio_modem component

components/audio_modem/modem_impl.h

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// Copyright 2015 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_
+#ifndef COMPONENTS_AUDIO_MODEM_MODEM_IMPL_H_
+#define COMPONENTS_AUDIO_MODEM_MODEM_IMPL_H_
 
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/cancelable_callback.h"
+#include "base/containers/mru_cache.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"
+#include "components/audio_modem/public/audio_modem_types.h"
+#include "components/audio_modem/public/modem.h"
+#include "media/base/audio_bus.h"
 
 namespace base {
 class Time;
 }
 
-namespace media {
-class AudioBus;
-}
-
-namespace copresence {
+namespace audio_modem {
 
 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.
-class AudioManagerImpl final : public AudioManager {
+// The ModemImpl class manages the playback and recording of tokens.
+// Clients should not necessary expect the modem to play or record continuously.
+// In the future, it may timeslice multiple tokens, or implement carrier sense.
+class ModemImpl final : public Modem {
  public:
-  AudioManagerImpl();
-  ~AudioManagerImpl() override;
+  ModemImpl();
+  ~ModemImpl() override;
 
-  // AudioManager overrides:
-  void Initialize(WhispernetClient* whispernet_client,
+  // Modem overrides:
+  void Initialize(WhispernetClient* client,
                   const TokensCallback& tokens_cb) override;
   void StartPlaying(AudioType type) override;
   void StopPlaying(AudioType type) override;
   void StartRecording(AudioType type) override;
   void StopRecording(AudioType type) override;
   void SetToken(AudioType type, const std::string& url_safe_token) override;
   const std::string GetToken(AudioType type) override;
   bool IsPlayingTokenHeard(AudioType type) override;
   void SetTokenLength(AudioType type, size_t token_length) override;
 
   void set_player_for_testing(AudioType type, AudioPlayer* player) {
     player_[type] = player;
   }
   void set_recorder_for_testing(AudioRecorder* recorder) {
     recorder_ = recorder;
   }
 
  private:
-  using SamplesMap = TimedMap<std::string,
-                              scoped_refptr<media::AudioBusRefCounted>>;
+  using SamplesMap = base::MRUCache<std::string,
+                                    scoped_refptr<media::AudioBusRefCounted>>;
 
   // Receives the audio samples from encoding a token.
   void OnTokenEncoded(AudioType type,
                       const std::string& token,
                       const scoped_refptr<media::AudioBusRefCounted>& samples);
 
   // Receives any tokens found by decoding audio samples.
   void OnTokensFound(const std::vector<AudioToken>& tokens);
 
   // 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_;
+  WhispernetClient* client_;
 
-  // Callbacks to send tokens back to the CopresenceManager.
+  // Callbacks to send tokens back to the client.
   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.");
@@ skipping 11 matching lines @@
 
   // 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_;
+  ScopedVector<SamplesMap> samples_caches_;
 
   base::FilePath dump_tokens_dir_;
 
-  DISALLOW_COPY_AND_ASSIGN(AudioManagerImpl);
+  DISALLOW_COPY_AND_ASSIGN(ModemImpl);
 };
 
-}  // namespace copresence
+}  // namespace audio_modem
 
-#endif  // COMPONENTS_COPRESENCE_MEDIUMS_AUDIO_AUDIO_MANAGER_IMPL_H_
+#endif  // COMPONENTS_AUDIO_MODEM_MODEM_IMPL_H_