Strip out stream counting from AudioRendererHost.

content/browser/media/audio_stream_monitor.cc

 // Copyright 2014 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/media/audio_stream_monitor.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 69 matching lines @@
     int render_process_id,
     int render_frame_id,
     int stream_id,
     const ReadPowerAndClipCallback& read_power_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   AudioStreamMonitor* const monitor =
       AudioStreamMonitorFromRenderFrame(render_process_id, render_frame_id);
   if (!monitor)
     return;
 
+  RenderProcessHostImpl* render_process_host =

[DaleCurtis, 2017/01/30 21:12:19]

+ncarter for content/ review. Is it possible for this to ever return null if
l.85 returns a value?

[ncarter (slow), 2017/01/31 18:33:12]

This is safe, given the implementation of AudioStreamMonitorFromRenderFrame:

 WebContentsImpl* const web_contents =
      static_cast<WebContentsImpl*>(WebContents::FromRenderFrameHost(
          RenderFrameHost::FromID(render_process_id, render_frame_id)));

Since this does a lookup via RenderFrameHost::FromID(), we know there's a valid
RenderFrameHost* with this ID tuple, and a RenderFrameHost* keeps its
RenderProcessHost alive (via AddRoute/RemoveRoute).

However, this would be easier to see and verify if you just retained the
RenderFrameHost ptr used to lookup the WebContents, and called GetProcess() to
obtain the RPH. That would also be a touch faster.

[DaleCurtis, 2017/02/06 22:19:02]

Replaced all of this with a helper function. We can't use
RenderFrameHost::FromID here since we need to always send this even if the frame
host has gone away. The only way to do that seems to be using RPH::FromID().

+      static_cast<RenderProcessHostImpl*>(
+          RenderProcessHost::FromID(render_process_id));
+  if (!render_process_host)
+    return;
+  render_process_host->OnAudioStreamAdded();
   monitor->OnStreamAdded();
 
   if (!power_level_monitoring_available())
     return;
 
   monitor->StartMonitoringStreamOnUIThread(render_process_id, stream_id,
                                            read_power_callback);
 }
 
 // static
 void AudioStreamMonitor::StopMonitoringHelper(int render_process_id,
                                               int render_frame_id,
                                               int stream_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   AudioStreamMonitor* const monitor =
       AudioStreamMonitorFromRenderFrame(render_process_id, render_frame_id);
   if (!monitor)
     return;
 
+  RenderProcessHostImpl* render_process_host =
+      static_cast<RenderProcessHostImpl*>(
+          RenderProcessHost::FromID(render_process_id));
+  if (!render_process_host)
+    return;
+  render_process_host->OnAudioStreamRemoved();

[ncarter (slow), 2017/01/31 18:33:12]

How confident are you that this perfectly balances the Added operation?

Does this function get executed if the process is killed (e.g. if you kill it
via task manager)?

[DaleCurtis, 2017/02/06 22:19:02]

Test added; it was incorrect before, but is correct now. The ordering of process
checks was wrong.

   monitor->OnStreamRemoved();
 
   if (!power_level_monitoring_available())
     return;
 
   monitor->StopMonitoringStreamOnUIThread(render_process_id, stream_id);
 }
 
 void AudioStreamMonitor::StartMonitoringStreamOnUIThread(
     int render_process_id,
@@ skipping 88 matching lines @@
     return;
 
   if (active_streams_ == 0) {
     is_audible_ = false;
     web_contents_->OnAudioStateChanged(false);
     MaybeToggle();
   }
 }
 
 }  // namespace content