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 22 matching lines @@
 using ::testing::DoAll;
 using ::testing::NotNull;
 
 namespace content {
 
 namespace {
 const int kRenderProcessId = 1;
 const int kRenderFrameId = 5;
 const int kStreamId = 50;
 const char kSecurityOrigin[] = "http://localhost";
+const char kBadSecurityOrigin[] = "about:about";
 const char kDefaultDeviceId[] = "";
+const char kNondefaultDeviceId[] =
+    "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef";
 const char kBadDeviceId[] =
     "badbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbadbad1";
 const char kInvalidDeviceId[] = "invalid-device-id";
 
 void ValidateRenderFrameId(int render_process_id,
                            int render_frame_id,
                            const base::Callback<void(bool)>& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   const bool frame_exists = (render_process_id == kRenderProcessId &&
                              render_frame_id == kRenderFrameId);
@@ skipping 31 matching lines @@
                           mirroring_manager,
                           media_internals,
                           media_stream_manager,
                           salt),
         shared_memory_length_(0),
         auth_run_loop_(auth_run_loop) {
     set_render_frame_id_validate_function_for_testing(&ValidateRenderFrameId);
   }
 
   // A list of mock methods.
+  MOCK_METHOD0(ShutdownForBadMessage, void());
   MOCK_METHOD4(OnDeviceAuthorized,
                void(int stream_id,
                     media::OutputDeviceStatus device_status,
                     const media::AudioParameters& output_params,
                     const std::string& matched_device_id));
   MOCK_METHOD2(OnStreamCreated, void(int stream_id, int length));
   MOCK_METHOD1(OnStreamPlaying, void(int stream_id));
   MOCK_METHOD1(OnStreamPaused, void(int stream_id));
   MOCK_METHOD1(OnStreamError, void(int stream_id));
 
@@ skipping 91 matching lines @@
     audio_manager_ = media::AudioManager::CreateForTesting(
         base::ThreadTaskRunnerHandle::Get());
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kUseFakeDeviceForMediaStream);
     media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
     host_ = new MockAudioRendererHost(
         &auth_run_loop_, audio_manager_.get(), &mirroring_manager_,
         MediaInternals::GetInstance(), media_stream_manager_.get(),
         std::string());
 
+    EXPECT_CALL(*host_, ShutdownForBadMessage()).Times(0);
+
     // Simulate IPC channel connected.
     host_->set_peer_process_for_testing(base::Process::Current());
   }
 
   ~AudioRendererHostTest() override {
     // Simulate closing the IPC channel and give the audio thread time to close
     // the underlying streams.
     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 RequestDeviceAuthorizationWithBadOrigin(
+      const std::string& device_id,
+      const url::Origin& security_origin) {
+    media::AudioParameters params(

[chcunningham, 2016/10/04 15:39:30]

I don't think you're using params here.

[Max Morin, 2016/10/05 08:58:36]

Done.

+        media::AudioParameters::AUDIO_FAKE, media::CHANNEL_LAYOUT_STEREO,
+        media::AudioParameters::kAudioCDSampleRate, 16,
+        media::AudioParameters::kAudioCDSampleRate / 10);
+    int session_id = 0;
+    host_->OnRequestDeviceAuthorization(kStreamId, kRenderFrameId, session_id,
+                                        device_id, security_origin);
+    SyncWithAudioThread();
+  }
+
+  void CreateWithoutWaitingForAuth(const std::string& device_id) {
+    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 54 matching lines @@
   // closing an audio stream.
   void SyncWithAudioThread() {
     base::RunLoop().RunUntilIdle();
 
     base::RunLoop run_loop;
     audio_manager_->GetTaskRunner()->PostTask(
         FROM_HERE, media::BindToCurrentLoop(run_loop.QuitClosure()));
     run_loop.Run();
   }
 
+  void ExpectShutdown() {
+    EXPECT_CALL(*host_, ShutdownForBadMessage()).Times(1);
+  }
+
  private:
   // MediaStreamManager uses a DestructionObserver, so it must outlive the
   // TestBrowserThreadBundle.
   std::unique_ptr<MediaStreamManager> media_stream_manager_;
   TestBrowserThreadBundle thread_bundle_;
   media::ScopedAudioManagerPtr audio_manager_;
   MockAudioMirroringManager mirroring_manager_;
   scoped_refptr<MockAudioRendererHost> host_;
   base::RunLoop auth_run_loop_;
 
@@ skipping 54 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) {
+  ExpectShutdown();
+  CreateWithoutWaitingForAuth(kBadDeviceId);
+  Close();
+}
+
+TEST_F(AudioRendererHostTest, CreateDeviceWithBadSecurityOrigin) {
+  ExpectShutdown();
+  RequestDeviceAuthorizationWithBadOrigin(
+      kNondefaultDeviceId, url::Origin(GURL(kBadSecurityOrigin)));

[chcunningham, 2016/10/04 15:39:30]

Do you mean to pass in the bad origin? The method name makes me think the bad
origin is decided by the method. 

[Max Morin, 2016/10/05 08:58:35]

Done.

   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