AudioRendererSinKCache: Do not use unhealthy sinks

content/renderer/media/audio_renderer_sink_cache_unittest.cc

 // Copyright 2016 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 <array>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
 #include "content/renderer/media/audio_renderer_sink_cache_impl.h"
 #include "media/audio/audio_device_description.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/mock_audio_renderer_sink.h"
 #include "media/base/test_helpers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace content {
 
 namespace {
 const char* const kDefaultDeviceId =
     media::AudioDeviceDescription::kDefaultDeviceId;
 const char kAnotherDeviceId[] = "another-device-id";
+const char kUnhealthyDeviceId[] = "i-am-sick";
 const int kRenderFrameId = 124;
 const int kDeleteTimeoutMs = 500;
 }  // namespace
 
 class AudioRendererSinkCacheTest : public testing::Test {
  public:
   AudioRendererSinkCacheTest()
       : cache_(new AudioRendererSinkCacheImpl(
             message_loop_.task_runner(),
             base::Bind(&AudioRendererSinkCacheTest::CreateSink,
@@ skipping 27 matching lines @@
   int sink_count() {
     DCHECK(message_loop_.task_runner()->BelongsToCurrentThread());
     return cache_->GetCacheSizeForTesting();
   }
 
   scoped_refptr<media::AudioRendererSink> CreateSink(
       int render_frame_id,
       int session_id,
       const std::string& device_id,
       const url::Origin& security_origin) {
-    return new media::MockAudioRendererSink(device_id,
-                                            media::OUTPUT_DEVICE_STATUS_OK);
+    return new media::MockAudioRendererSink(
+        device_id, (device_id == kUnhealthyDeviceId)
+                       ? media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL
+                       : media::OUTPUT_DEVICE_STATUS_OK);
   }
 
   void ExpectToStop(media::AudioRendererSink* sink) {
     // Sink must be stoped before deletion.
     EXPECT_CALL(*static_cast<media::MockAudioRendererSink*>(sink), Stop())
         .Times(1);
   }
 
   void ExpectNotToStop(media::AudioRendererSink* sink) {
     // The sink must be stoped before deletion.
@@ skipping 156 matching lines @@
   EXPECT_EQ(kDefaultDeviceId, sink->GetOutputDeviceInfo().device_id());
   EXPECT_EQ(1, sink_count());
 
   // Wait more to hit garbage collection timeout.
   WaitOnAnotherThread(thread, kDeleteTimeoutMs);
 
   // The sink is still in place.
   EXPECT_EQ(1, sink_count());
 }
 
+// Verify that the sink created with GetSinkInfo() is not cached if it is
+// unhealthy.
+TEST_F(AudioRendererSinkCacheTest, UnhealthySinkIsNotCached) {
+  EXPECT_EQ(0, sink_count());
+  media::OutputDeviceInfo device_info =
+      cache_->GetSinkInfo(kRenderFrameId, 0, kUnhealthyDeviceId, url::Origin());
+  EXPECT_EQ(0, sink_count());
+  scoped_refptr<media::AudioRendererSink> sink =
+      cache_->GetSink(kRenderFrameId, kUnhealthyDeviceId, url::Origin()).get();
+  EXPECT_EQ(0, sink_count());
+}
+
 // Verify that cache works fine if a sink scheduled for delettion is aquired and
 // released before deletion timeout elapses.
 // The test produces one "Uninteresting mock" warning for
 // MockAudioRendererSink::Stop().
 TEST_F(AudioRendererSinkCacheTest, ReleaseSinkBeforeScheduledDeletion) {
   EXPECT_EQ(0, sink_count());
 
   media::OutputDeviceInfo device_info =
       cache_->GetSinkInfo(kRenderFrameId, 0, kDefaultDeviceId, url::Origin());
   EXPECT_EQ(1, sink_count());  // This sink is scheduled for deletion now.
@@ skipping 103 matching lines @@
   // Wait for completion of all the tasks posted to at least one thread.
   media::WaitableMessageLoopEvent loop_event(
       TestTimeouts::action_max_timeout());
   threads[kThreadCount - 1]->task_runner()->PostTaskAndReply(
       FROM_HERE, base::Bind(&base::DoNothing), loop_event.GetClosure());
   // Runs the loop and waits for the thread to call event's closure.
   loop_event.RunAndWait();
 }
 
 }  // namespace content