Remove dangerous CHECK. Add unit test.

content/browser/renderer_host/media/audio_renderer_host_unittest.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/media/audio_renderer_host.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 202 matching lines @@
     host_->OnChannelClosing();
     SyncWithAudioThread();
 
     // Release the reference to the mock object.  The object will be destructed
     // on message_loop_.
     host_ = NULL;
   }
 
  protected:
   void Create() {
-    Create(false, kDefaultDeviceId, url::Origin(GURL(kSecurityOrigin)));
+    Create(false, kDefaultDeviceId, url::Origin(GURL(kSecurityOrigin)), true);
   }
 
   void Create(bool unified_stream,
               const std::string& device_id,
-              const url::Origin& security_origin) {
+              const url::Origin& security_origin,
+              bool wait_for_auth) {
     media::OutputDeviceStatus expected_device_status =
         device_id == kDefaultDeviceId
             ? media::OUTPUT_DEVICE_STATUS_OK
             : device_id == kBadDeviceId
                   ? media::OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED
                   : media::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND;
 
     EXPECT_CALL(*host_.get(),
                 OnDeviceAuthorized(kStreamId, expected_device_status, _, _));
 
@@ skipping 11 matching lines @@
         media::AudioParameters::kAudioCDSampleRate, 16,
         media::AudioParameters::kAudioCDSampleRate / 10);
     int session_id = 0;
     if (unified_stream) {
       // Use AudioInputDeviceManager::kFakeOpenSessionId as the session id to
       // pass the permission check.
       session_id = AudioInputDeviceManager::kFakeOpenSessionId;
     }
     host_->OnRequestDeviceAuthorization(kStreamId, kRenderFrameId, session_id,
                                         device_id, security_origin);
-    auth_run_loop_.Run();
-    if (expected_device_status == media::OUTPUT_DEVICE_STATUS_OK) {
+    if (wait_for_auth)
+      auth_run_loop_.Run();
+
+    if (!wait_for_auth ||
+        expected_device_status == media::OUTPUT_DEVICE_STATUS_OK)
       host_->OnCreateStream(kStreamId, kRenderFrameId, params);
 
+    if (expected_device_status == media::OUTPUT_DEVICE_STATUS_OK)
       // At some point in the future, a corresponding RemoveDiverter() call must
       // be made.
       EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull()))
           .RetiresOnSaturation();
-    }
     SyncWithAudioThread();
   }
 
+  void CreateWithoutWaitingForAuth(const std::string& device_id) {
+    EXPECT_CALL(*host_, OnStreamError(kStreamId));
+    Create(false, device_id, url::Origin(GURL(kSecurityOrigin)), false);
+  }
+
   void CreateWithInvalidRenderFrameId() {
     // When creating a stream with an invalid render frame ID, the host will
     // reply with a stream error message.
     EXPECT_CALL(*host_, OnStreamError(kStreamId));
 
     // However, validation does not block stream creation, so these method calls
     // might be made:
     EXPECT_CALL(*host_, OnStreamCreated(kStreamId, _)).Times(AtLeast(0));
     EXPECT_CALL(mirroring_manager_, AddDiverter(_, _, _)).Times(AtLeast(0));
     EXPECT_CALL(mirroring_manager_, RemoveDiverter(_)).Times(AtLeast(0));
@@ skipping 128 matching lines @@
 // the audio device is closed but the render process try to close the
 // audio stream again.
 TEST_F(AudioRendererHostTest, SimulateErrorAndClose) {
   Create();
   Play();
   SimulateError();
   Close();
 }
 
 TEST_F(AudioRendererHostTest, CreateUnifiedStreamAndClose) {
-  Create(true, kDefaultDeviceId, url::Origin(GURL(kSecurityOrigin)));
+  Create(true, kDefaultDeviceId, url::Origin(GURL(kSecurityOrigin)), true);
   Close();
 }
 
 TEST_F(AudioRendererHostTest, CreateUnauthorizedDevice) {
-  Create(false, kBadDeviceId, url::Origin(GURL(kSecurityOrigin)));
+  Create(false, kBadDeviceId, url::Origin(GURL(kSecurityOrigin)), true);
+  Close();
+}
+
+TEST_F(AudioRendererHostTest, CreateDeviceWithAuthorizationPendingIsError) {
+  CreateWithoutWaitingForAuth(kBadDeviceId);
   Close();
 }
 
 TEST_F(AudioRendererHostTest, CreateInvalidDevice) {
-  Create(false, kInvalidDeviceId, url::Origin(GURL(kSecurityOrigin)));
+  Create(false, kInvalidDeviceId, url::Origin(GURL(kSecurityOrigin)), true);
   Close();
 }
 
 TEST_F(AudioRendererHostTest, CreateFailsForInvalidRenderFrame) {
   CreateWithInvalidRenderFrameId();
   Close();
 }
 
 // TODO(hclam): Add tests for data conversation in low latency mode.
 
 }  // namespace content