Change audio render thread checking to use new AudioRendererSink::BelongsToRendererThread()

media/base/audio_renderer_sink.h

 // 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.
 
 #ifndef MEDIA_BASE_AUDIO_RENDERER_SINK_H_
 #define MEDIA_BASE_AUDIO_RENDERER_SINK_H_
 
 #include <stdint.h>
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/output_device_info.h"
 #include "url/origin.h"
 
 namespace media {
 
 // AudioRendererSink is an interface representing the end-point for
 // rendered audio.  An implementation is expected to
 // periodically call Render() on a callback object.
 
 class AudioRendererSink
     : public base::RefCountedThreadSafe<media::AudioRendererSink> {
  public:
   class RenderCallback {
    public:
+    // Informs that rendering has been initialized and will start soon. This
+    // means that a new rendering thread has been started.
+    virtual void OnInitialized() = 0;

[Henrik Grunell, 2016/06/03 13:53:42]

Only WebRTC will care about this function, and will make sure
MediaStreamAudioProcessor detaches from the thread it's currently bound to for
render calls.

[DaleCurtis, 2016/06/03 20:54:13]

Why not always detach until the first render call?

[Henrik Grunell, 2016/06/08 09:19:06]

The mixer in the upcoming mixing changes will restart the AOD (thus starting a
new thread) if needed when a new input is added. We need to be informed when
that happens and this is the means to do that. OnInitialized() is perhaps not an
accurate naming, but I'd like something somewhat generic.

+
     // Attempts to completely fill all channels of |dest|, returns actual
     // number of frames filled. |frames_skipped| contains the number of frames
     // the consumer has skipped, if any.
     virtual int Render(AudioBus* dest,
                        uint32_t frames_delayed,
                        uint32_t frames_skipped) = 0;
 
     // Signals an error has occurred.
     virtual void OnRenderError() = 0;
 
@@ skipping 23 matching lines @@
   // Returns |true| on success.
   virtual bool SetVolume(double volume) = 0;
 
   // Returns current output device information. If the information is not
   // available yet, this method may block until it becomes available.
   // If the sink is not associated with any output device, |device_status| of
   // OutputDeviceInfo should be set to OUTPUT_DEVICE_STATUS_ERROR_INTERNAL.
   // Must never be called on the IO thread.
   virtual OutputDeviceInfo GetOutputDeviceInfo() = 0;
 
+  // Returns true if called on rendering thread, otherwise false.
+  virtual bool BelongsToRenderingThread() = 0;

[Henrik Grunell, 2016/06/03 13:53:42]

If we go for the above OnInitialized(), we don't need this function.

If we keep this function instead, only WebRTC will use it. In that case we can't
detach in MSAP. We have two options: remove thread checks in MSAP or forward
thread checking to elsewhere (i.e. its owner).

[DaleCurtis, 2016/06/03 20:54:13]

What do you mean about detaching? This would replace any threading checks, no?

[Henrik Grunell, 2016/06/08 09:19:06]

In the case above, when the mixer restarts AOD, with this option we won't know
about that and not be able to detach. Yes, this would replace thread checks.

[DaleCurtis, 2016/06/08 18:10:13]

The corollary to my question is that if this replaces thread checks, why do you
even need to detach? Just always use this instead of a ThreadChecker.

+
  protected:
   friend class base::RefCountedThreadSafe<AudioRendererSink>;
   virtual ~AudioRendererSink() {}
 };
 
 // Same as AudioRendererSink except that Initialize() and Start() can be called
 // again after Stop().
 // TODO(sandersd): Fold back into AudioRendererSink once all subclasses support
 // this.
 
@@ skipping 13 matching lines @@
                                   const url::Origin& security_origin,
                                   const OutputDeviceStatusCB& callback) = 0;
 
  protected:
   ~SwitchableAudioRendererSink() override {}
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_AUDIO_RENDERER_SINK_H_