Add an initial revision of an audio server.

services/media/audio/audio_output_manager.cc

Index: services/media/audio/audio_output_manager.cc
diff --git a/services/media/audio/audio_output_manager.cc b/services/media/audio/audio_output_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..59e4ff38a2052c2a748e307355851b6f87412eb3
--- /dev/null
+++ b/services/media/audio/audio_output_manager.cc
@@ -0,0 +1,150 @@
+// 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.
+
+#include <string>
+
+#include "services/media/audio/audio_output.h"
+#include "services/media/audio/audio_output_manager.h"
+#include "services/media/audio/audio_server_impl.h"
+#include "services/media/audio/audio_track_to_output_link.h"
+#include "services/media/audio/platform/generic/throttle_output.h"
+
+namespace mojo {
+namespace media {
+namespace audio {
+
+static constexpr size_t  THREAD_POOL_SZ = 2;
+static const std::string THREAD_PREFIX("AudioMixer");
+
+AudioOutputManager::AudioOutputManager(AudioServerImpl* server)
+  : server_(server) {
+}
+
+AudioOutputManager::~AudioOutputManager() {
+  Shutdown();
+  DCHECK_EQ(outputs_.size(), 0u);
+  DCHECK(!thread_pool_);
+}
+
+MediaResult AudioOutputManager::Init() {
+  // Step #1: Initialize the mixing thread pool.
+  //
+  // TODO(johngro): make the thread pool size proportional to the maximum
+  // number of cores available in the system.
+  //
+  // TODO(johngro): make sure that the threads are executed at an elevated
+  // priority, not the default priority.
+  thread_pool_ = new base::SequencedWorkerPool(THREAD_POOL_SZ, THREAD_PREFIX);
+
+  // Step #2: Instantiate all of the built-in audio output devices.
+  //
+  // TODO(johngro): Come up with a better way of doing this based on our
+  // platform.  Right now, we just create some hardcoded default outputs and
+  // leave it at that.
+  outputs_.emplace(audio::ThrottleOutput::New(this));
+
+  // Step #3: Being monitoring for plug/unplug events for pluggable audio
+  // output devices.
+  //
+  // TODO(johngro): Implement step #3.  Right now, the details are behind
+  // hot-plug monitoring are TBD, so the feature is not implemented.
+
+  // Step #4: Attempt to initialize each of the audio outputs we have created,
+  // then kick off the callback engine for each of them.
+  for (auto iter = outputs_.begin(); iter != outputs_.end(); ) {
+    const AudioOutputPtr& output = *iter;
+    auto tmp = iter++;
+    DCHECK(output);
+
+    // Create a sequenced task runner for this output.  It will be used by the
+    // output to schedule jobs (such as mixing) on the thread pool.
+    scoped_refptr<base::SequencedTaskRunner> task_runner =
+      thread_pool_->GetSequencedTaskRunnerWithShutdownBehavior(
+        thread_pool_->GetSequenceToken(),
+        base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+
+    MediaResult res = output->Init(output, task_runner);
+    if (res != MediaResult::OK) {
+      // TODO(johngro): Probably should log something about this, assuming that

[jeffbrown, 2015/11/04 23:43:33]

Another approach would be to handle this symmetrically with other kinds of
asynchronous self-shutdown of the output.  We could assume Init always succeeds
here and wait for a callback to tell us otherwise.

Bonus of that is that the output could actually do its real hardcore
initialization in the background on some other thread.  Useful in case it's got
to open up and configure audio devices which could take a *very* long time. 
(USB Audio anyone?)

[johngro, 2015/11/06 02:20:24]

Perhaps, but I do not feel that there is ever a good solution to badly behaved
device drivers.  Currently, pushing this task into the scope of an "output
thread context" (loosely defined term here) it not a solution to the problem as
the output threading context is done withing the context of a thread pool, and
badly behaved drivers will just end up pissing the the thread pool and
potentially damaging other outputs because of their bad behavior.

A thread-per-output is not a universal solution to this problem either.  At some
point, the main system needs to synchronize with the state of the output,
whether the output owns a dedicated thread or not.

The dependencies mentioned above can be broken down to the point where we
require a thread per output, or dedicated init/shutdown threads, and impose an
architecture where all interactions with the driver/os happen on the dedicated
thread.  We are almost already there with this design, but badly behaved drivers
can still DoS our service or the whole system even in this hypothetical design
(examples available upon request).

Fundamentally, hardware and drivers are highly privileged.  I feel that our
first line of defense should be a solid OS (see reasons for FNL), high levels of
compliance testing (see Android CTS, Apple's monopoly on
hardware/kernel/drivers, Microsoft's WHQL compliance testing), and draconian
consequences in the driver model for breaking the rules (see WDM/BSoD, and...
well... I guess Linux and therefor Android has no such thing... but hopefully
FNL will be better).

DIRQ_LEVEL_NOT_LESS_THAN_OR_EQUAL anyone?

Seriously though, this is just a start.  We will refine as time goes on and we
all have a better idea of what guarantees the HAL/OSAL can provide, and what
practical mitigations we can implement of the underlying OS is less than we had
hoped for.  At the end of the day, the OS/Drivers must be solid.  If they cannot
be, then it really does not matter what we do here.  Windows will BSoD if a
driver shuts off interrupts and deadlocks (or makes any attempt to acquire any
lock for that matter).  Linux will not, and Android will always be vulnerable to
this as a result.  It is upon us to ensure that FNL is built to a higher
standard than what Linux currently offers.

+      // the output has not already.
+      outputs_.erase(tmp);
+    }
+  }
+
+  return MediaResult::OK;
+}
+
+void AudioOutputManager::Shutdown() {
+  // Are we already shutdown (or were we never successfully initialized?)
+  if (thread_pool_ == nullptr) {
+    DCHECK_EQ(outputs_.size(), 0u);
+    return;
+  }
+
+  // Step #1: Stop monitoringing plug/unplug events.  We are shutting down and
+  // no longer care about outputs coming and going.
+  //
+  // TODO(johngro): Implement step #1.  Right now, the details are behind
+  // hot-plug monitoring are TBD, so the feature is not implemented.
+
+  // Step #2: Shut down each currently active output in the system.  It is
+  // possible for this to take a bit of time as outputs release their hardware,
+  // but it should not take long.

[jeffbrown, 2015/11/04 23:43:33]

Famous last words.  :)

[johngro, 2015/11/06 02:20:24]

See above.  Hopefully not, but we will adapt if they prove to be incorrect.  I
have already been instructed not to concern myself too much with bad linux
behavior, but to focus instead on making sure that FNL does its job correctly
(which is to say it does provide guarantees, instead of shirking those
responsibilities and make them the responsibilities of higher levels).

+  for (const auto& output_ptr : outputs_) {
+    output_ptr->Shutdown();
+  }
+  outputs_.clear();
+
+  // Step #3: Shutdown and release our thread pool.  Since we have shut down all
+  // of our outputs, any pending tasks left in the task runner are now no-ops,
+  // so it does not matter that the task runner is going to cancel them all
+  // (instead of blocking) when we shut it down.
+  thread_pool_->Shutdown();
+  thread_pool_ = nullptr;
+}
+
+void AudioOutputManager::ShutdownOutput(AudioOutputPtr output) {
+  // No one should be calling this method if we have been shut down (or never
+  // successfully started).
+  DCHECK(thread_pool_);
+
+  auto iter = outputs_.find(output);
+  if (iter != outputs_.end()) {
+    output->Shutdown();
+    outputs_.erase(iter);
+  }
+}
+
+void AudioOutputManager::SelectOutputsForTrack(AudioTrackImplPtr track) {
+  // TODO(johngro): Someday, base this on policy.  For now, every track gets
+  // assigned to every output in the system.
+  DCHECK(track);
+
+  // TODO(johngro): Add some way to assert that we are executing on the main
+  // message loop thread.
+
+  for (auto output : outputs_) {
+    auto link = AudioTrackToOutputLink::New(track, output);
+    DCHECK(output);
+    DCHECK(link);
+
+    // If we cannot add this link to the output, it's because the output is in
+    // the process of shutting down (we didn't want to hang out with that guy
+    // anyway)
+    if (output->AddTrackLink(link) == MediaResult::OK) {
+      track->AddOutput(link);
+    }
+  }
+}
+
+void AudioOutputManager::ScheduleMessageLoopTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& task) {
+  DCHECK(server_);
+  server_->ScheduleMessageLoopTask(from_here, task);
+}
+
+}  // namespace audio
+}  // namespace media
+}  // namespace mojo