Fix shutdown crash in AudioOutputAuthorizationHandler.

content/browser/renderer_host/media/audio_renderer_host.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 <utility>
 
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 
 namespace content {
 
 namespace {
 
 // Tracks the maximum number of simultaneous output streams browser-wide.
 // Accessed on IO thread.
 base::LazyInstance<media::AudioStreamsTracker> g_audio_streams_tracker =
     LAZY_INSTANCE_INITIALIZER;
 
-std::pair<int, std::pair<bool, std::string>> MakeAuthorizationData(
-    int stream_id,
-    bool authorized,
-    const std::string& device_unique_id) {
-  return std::make_pair(stream_id,
-                        std::make_pair(authorized, device_unique_id));
-}
-
-
 void NotifyRenderProcessHostThatAudioStateChanged(int render_process_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   RenderProcessHost* render_process_host =
       RenderProcessHost::FromID(render_process_id);
 
   if (render_process_host)
     render_process_host->AudioStateChanged();
 }
 
@@ skipping 126 matching lines @@
     : BrowserMessageFilter(AudioMsgStart),
       render_process_id_(render_process_id),
       audio_manager_(audio_manager),
       mirroring_manager_(mirroring_manager),
       audio_log_(media_internals->CreateAudioLog(
           media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER)),
       num_playing_streams_(0),
       salt_(salt),
       validate_render_frame_id_function_(&ValidateRenderFrameId),
       max_simultaneous_streams_(0),
-      authorization_handler_(media_stream_manager, render_process_id_, salt) {
+      authorization_handler_(audio_manager_,
+                             media_stream_manager,
+                             render_process_id_,
+                             salt) {
   DCHECK(audio_manager_);
 }
 
 AudioRendererHost::~AudioRendererHost() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   CHECK(audio_entries_.empty());
 
   // If we had any streams, report UMA stats for the maximum number of
   // simultaneous streams for this render process and for the whole browser
   // process since last reported.
@@ skipping 167 matching lines @@
     const url::Origin& security_origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const base::TimeTicks auth_start_time = base::TimeTicks::Now();
   DVLOG(1) << "AudioRendererHost@" << this << "::OnRequestDeviceAuthorization"
            << "(stream_id=" << stream_id
            << ", render_frame_id=" << render_frame_id
            << ", session_id=" << session_id << ", device_id=" << device_id
            << ", security_origin=" << security_origin << ")";
   if (LookupById(stream_id) || IsAuthorizationStarted(stream_id))
     return;
-  authorizations_.insert(MakeAuthorizationData(stream_id, false, device_id));
+
+  authorizations_.insert(
+      std::make_pair(stream_id, std::make_pair(false, std::string())));
+
   // Unretained is ok here since |this| owns |authorization_handler_| and
   // |authorization_handler_| owns the callback.
   authorization_handler_.RequestDeviceAuthorization(
       render_frame_id, session_id, device_id, security_origin,
       base::Bind(&AudioRendererHost::AuthorizationCompleted,
                  base::Unretained(this), stream_id, security_origin,
                  auth_start_time));
 }
 
 void AudioRendererHost::AuthorizationCompleted(
@@ skipping 249 matching lines @@
 }
 
 bool AudioRendererHost::HasActiveAudio() {
   return !base::AtomicRefCountIsZero(&num_playing_streams_);
 }
 
 void AudioRendererHost::OverrideDevicePermissionsForTesting(bool has_access) {
   authorization_handler_.OverridePermissionsForTesting(has_access);
 }
 }  // namespace content