Redesign the copresence audio handlers.

components/copresence/mediums/audio/audio_manager.cc

Index: components/copresence/mediums/audio/audio_manager.cc
diff --git a/components/copresence/mediums/audio/audio_manager.cc b/components/copresence/mediums/audio/audio_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..620bb7ba10a297a0fdc7db3dcca5f248444383a1
--- /dev/null
+++ b/components/copresence/mediums/audio/audio_manager.cc
@@ -0,0 +1,173 @@
+// 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.
+
+#include "components/copresence/mediums/audio/audio_manager.h"
+
+#include <algorithm>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/logging.h"
+#include "base/run_loop.h"
+#include "base/strings/string_util.h"
+#include "base/synchronization/waitable_event.h"
+#include "components/copresence/mediums/audio/audio_player.h"
+#include "components/copresence/mediums/audio/audio_recorder.h"
+#include "components/copresence/public/copresence_constants.h"
+#include "content/public/browser/browser_thread.h"
+#include "media/audio/audio_manager.h"
+#include "media/audio/audio_manager_base.h"
+#include "media/base/audio_bus.h"
+
+namespace copresence {
+
+namespace {
+
+// UrlSafe is defined as:
+// '/' represented by a '_' and '+' represented by a '-'
+// TODO(rkc): Move this processing to the whispernet wrapper.
+std::string FromUrlSafe(std::string token) {
+  base::ReplaceChars(token, "-", "+", &token);
+  base::ReplaceChars(token, "_", "/", &token);
+  return token;
+}
+
+const int kSampleExpiryTimeMs = 60 * 60 * 1000;  // 60 minutes.
+const int kMaxSamples = 10000;
+
+}  // namespace
+
+// Public methods.
+
+AudioManager::AudioManager()
+    : playing_{false, false},
+      recording_{false, false},
+      player_{NULL, NULL},
+      recorder_(NULL) {
+  samples_cache_.resize(2);
+  samples_cache_[AUDIBLE] = new SamplesMap(
+      base::TimeDelta::FromMilliseconds(kSampleExpiryTimeMs), kMaxSamples);
+  samples_cache_[INAUDIBLE] = new SamplesMap(
+      base::TimeDelta::FromMilliseconds(kSampleExpiryTimeMs), kMaxSamples);
+}
+
+void AudioManager::Initialize(const DecodeSamplesCallback& decode_cb,
+                              const EncodeTokenCallback& encode_cb) {
+  decode_cb_ = decode_cb;
+  encode_cb_ = encode_cb;
+
+  if (!player_[AUDIBLE])
+    player_[AUDIBLE] = new AudioPlayerImpl();
+  player_[AUDIBLE]->Initialize();
+
+  if (!player_[INAUDIBLE])
+    player_[INAUDIBLE] = new AudioPlayerImpl();
+  player_[INAUDIBLE]->Initialize();
+
+  decode_cancelable_cb_.Reset(base::Bind(&AudioManager::DecodeSamplesConnector,
+                                         base::Unretained(this)));
+  if (!recorder_)
+    recorder_ = new AudioRecorderImpl();
+  recorder_->Initialize(decode_cancelable_cb_.callback());
+}
+
+AudioManager::~AudioManager() {
+  if (player_[AUDIBLE])
+    player_[AUDIBLE]->Finalize();
+  if (player_[INAUDIBLE])
+    player_[INAUDIBLE]->Finalize();
+  if (recorder_)
+    recorder_->Finalize();
+}
+
+void AudioManager::StartPlaying(AudioType type) {
+  DCHECK(type == AUDIBLE || type == INAUDIBLE);
+  playing_[type] = true;
+  // If we don't have our token encoded yet, this check will be false, for now.
+  // Once our token is encoded, OnTokenEncoded will call UpdateToken, which
+  // will call this code again (if we're still supposed to be playing).
+  if (samples_cache_[type]->HasKey(token_[type]) &&
+      !player_[type]->IsPlaying()) {
+    DCHECK_GT(token_[type].size(), 0u);
+    player_[type]->Play(samples_cache_[type]->GetValue(token_[type]));
+  }
+}
+
+void AudioManager::StopPlaying(AudioType type) {
+  DCHECK(type == AUDIBLE || type == INAUDIBLE);
+  playing_[type] = false;
+  if (player_[type]->IsPlaying())
+    player_[type]->Stop();
+}
+
+void AudioManager::StartRecording(AudioType type) {
+  DCHECK(type == AUDIBLE || type == INAUDIBLE);
+  recording_[type] = true;
+  if (!recorder_->IsRecording())
+    recorder_->Record();
+}
+
+void AudioManager::StopRecording(AudioType type) {
+  DCHECK(type == AUDIBLE || type == INAUDIBLE);
+  recording_[type] = false;
+  if (recorder_->IsRecording())
+    recorder_->Stop();
+}
+
+void AudioManager::SetToken(AudioType type,
+                            const std::string& url_unsafe_token) {
+  DCHECK(type == AUDIBLE || type == INAUDIBLE);
+  std::string token = FromUrlSafe(url_unsafe_token);
+  if (!samples_cache_[type]->HasKey(token)) {
+    encode_cb_.Run(
+        token,
+        type,
+        base::Bind(&AudioManager::OnTokenEncoded, base::Unretained(this)));

[xiyuan, 2014/10/20 19:26:46]

base::Unretained makes me nervous. Could we use WeakPtr or something?

[rkc, 2014/10/20 20:17:53]

This cancelable callback will get automatically canceled on destruction of this
object (which will invalidate the internal weak_ptr that the cancelable callback
uses), hence this callback will never be called after the destruction of this
object.

Since the cancelable callback already uses a weak_ptr internall, using a
weak_ptr here would make using the cancelable callback redundant :)

[xiyuan, 2014/10/20 21:29:29]

Sorry if it is a dumb question. Why base::Bind() here creates a cancelable
callback?

[rkc, 2014/10/21 01:25:04]

Really not my best day. This "should" be cancelable, I apparently forgot to put
the code in for it.

I thought more about this though and it seems that the correct solution is just
to ensure that when we're done with the WhispernetClient and destructing all our
managers/objects, we should simply null out any callbacks that we set. This will
ensure that no objects within our hierarchy can be called by Whispernet post
destruction. Added code to do that and added a comment here explaining why
unretained is (now) safe to use here.

Done.

+  } else {
+    UpdateToken(type, token);
+  }
+}
+
+// Private methods.
+
+void AudioManager::OnTokenEncoded(
+    const std::string& token,
+    AudioType type,
+    const scoped_refptr<media::AudioBusRefCounted>& samples) {
+  samples_cache_[type]->Add(token, samples);
+  UpdateToken(type, token);
+}
+
+void AudioManager::UpdateToken(AudioType type, const std::string& token) {
+  DCHECK(type == AUDIBLE || type == INAUDIBLE);
+  if (token_[type] == token)
+    return;
+
+  // Update token.
+  token_[type] = token;
+
+  // If we are supposed to be playing this token type at this moment, switch
+  // out playback with the new samples.
+  if (playing_[type]) {
+    if (player_[type]->IsPlaying())
+      player_[type]->Stop();
+    StartPlaying(type);
+  }
+}
+
+void AudioManager::DecodeSamplesConnector(const std::string& samples) {
+  AudioType decode_type = UNKNOWN;
+
+  if (recording_[AUDIBLE] && recording_[INAUDIBLE])
+    decode_type = BOTH;
+  else if (recording_[AUDIBLE])
+    decode_type = AUDIBLE;
+  else if (recording_[INAUDIBLE])
+    decode_type = INAUDIBLE;
+
+  decode_cb_.Run(decode_type, samples);
+}
+
+}  // namespace copresence