Adds method to provide custom AudioManager at runtime.

media/audio/audio_manager_factory_unittest.cc

Index: media/audio/audio_manager_factory_unittest.cc
diff --git a/media/audio/audio_manager_factory_unittest.cc b/media/audio/audio_manager_factory_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..51e998c3231750fe1affb55227b892b2ed6ba953
--- /dev/null
+++ b/media/audio/audio_manager_factory_unittest.cc
@@ -0,0 +1,62 @@
+// 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 "base/memory/scoped_ptr.h"
+#include "media/audio/audio_manager.h"
+#include "media/audio/audio_manager_factory.h"
+#include "media/audio/fake_audio_log_factory.h"
+#include "media/audio/fake_audio_manager.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+namespace {
+
+// Static instance for comparison
+FakeAudioLogFactory* g_fake_audio_log_factory = nullptr;
+AudioManager* g_fake_audio_manager = nullptr;
+
+class FakeAudioManagerFactory : public AudioManagerFactory {
+ public:
+  FakeAudioManagerFactory() {
+    if (!g_fake_audio_manager) {
+      g_fake_audio_log_factory = new FakeAudioLogFactory;
+      g_fake_audio_manager = new FakeAudioManager(g_fake_audio_log_factory);
+    }
+  }
+
+  ~FakeAudioManagerFactory() override {}
+
+  AudioManager* CreateInstance(AudioLogFactory* audio_log_factory) override {
+    return g_fake_audio_manager;
+  }
+};
+
+}  // namespace
+
+// Verifies that SetFactory has the intended effect. Note that the current
+// structure supports exactly one test case (SetFactory may only be called
+// once per process by design).
+TEST(AudioManagerFactoryTest, CreateInstance) {
+  // Create an audio manager and verify that it is not null.
+  scoped_ptr<AudioManager> manager(AudioManager::CreateForTesting());
+  ASSERT_NE(nullptr, manager.get());
+  manager.reset();
+
+  // Set the factory, after which the static AudioManager should be
+  // instantiated.
+  AudioManager::SetFactory(new FakeAudioManagerFactory);

[DaleCurtis, 2015/04/23 16:18:26]

()

[slan, 2015/04/23 18:11:33]

Done. Here and above.

+  ASSERT_NE(nullptr, g_fake_audio_manager);
+
+  // Get the instance and verify that it matches the instance provided by the
+  // factory.
+  manager.reset(AudioManager::CreateForTesting());
+  ASSERT_EQ(g_fake_audio_manager, manager.get());
+
+  // Reset the AudioManager and AudioManagerFactory to prevent persisting state

[DaleCurtis, 2015/04/23 16:18:25]

I don't think this is an issue. Or we'd have tripped the g_last_created CHECK()
in the existing tests, no?

[slan, 2015/04/23 18:11:33]

Any existing unittest using AudioManager wraps the created instance in a
scoped_ptr, such that it is destroyed when the scope of the test exits. That is
what we are doing here (I have removed the redundant call to reset() and added a
comment for clarity :) ). I believe that gtest guarantees serial execution of
all test cases within a process, so that should be sufficient to avoid the CHECK
you mentioned.

The call to AudioManager::ResetFactory() is also important, but for a different
reason. If it is not called, the static instance of the factory will continue to
serve whatever AudioManager it wants (in this case |g_fake_audio_manager|, which
is deleted when this scope exits.... yikes!) when Create is called, for the life
of the process. This puts all tests run after this one on the same process at
the mercy of this factory, which is not good.

I'm glad you pointed this out though, because returning |g_fake_audio_manager|
violates the assumption that applies everywhere else... that the instance can be
deleted in testing without issue. I have fixed that, so the assumption applies. 

But in any case, the factory still needs to be reset when all the tests in the
file are through.

+  // to other tests on the same process.
+  manager.reset();
+  AudioManager::ResetFactory();
+}
+
+}  // namespace media