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

media/audio/audio_output_device.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 "media/audio/audio_output_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cmath>
@@ skipping 21 matching lines @@
                       base::SharedMemoryHandle memory,
                       int memory_length,
                       AudioRendererSink::RenderCallback* render_callback);
   ~AudioThreadCallback() override;
 
   void MapSharedMemory() override;
 
   // Called whenever we receive notifications about pending data.
   void Process(uint32_t pending_data) override;
 
+  // Returns whether the current thread is the audio device thread or not.
+  // Will always return true if DCHECKs are not enabled.
+  bool CurrentThreadIsAudioDeviceThread();
+
  private:
   AudioRendererSink::RenderCallback* render_callback_;
   std::unique_ptr<AudioBus> output_bus_;
   uint64_t callback_num_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioThreadCallback);
 };
 
 AudioOutputDevice::AudioOutputDevice(
     std::unique_ptr<AudioOutputIPC> ipc,
@@ skipping 91 matching lines @@
 OutputDeviceInfo AudioOutputDevice::GetOutputDeviceInfo() {
   CHECK(!task_runner()->BelongsToCurrentThread());
   did_receive_auth_.Wait();
   return OutputDeviceInfo(AudioDeviceDescription::UseSessionIdToSelectDevice(
                               session_id_, device_id_)
                               ? matched_device_id_
                               : device_id_,
                           device_status_, output_params_);
 }
 
+bool AudioOutputDevice::CurrentThreadIsRenderingThread() {
+  // Since this function is supposed to be called on the rendering thread,

[DaleCurtis, 2016/06/14 17:07:49]

Hmm, seems like this should have a DCHECK(CurrentThreadIsAUdioDeviceThread()) :)
Note: calling this will actually bind the thread checker to the calling
thread... so failures will be confusing if the caller binds to a non-render
thread and then the render thread dcheck fails on the first render() call.

[Henrik Grunell, 2016/06/14 19:33:41]

Yes, a failure could be confusing if that happens. You mean a DCHECK would avoid
that? How? Or why have a DCHECK?

[DaleCurtis, 2016/06/14 20:07:16]

I'd just add some text to the DCHECK() on the audio thread that says this will
only fail if the thread checker was attached on the wrong thread.

[Henrik Grunell, 2016/06/15 07:17:54]

Done.

+  // it's safe to access |audio_callback_| here. It will always be valid when
+  // the rendering thread is running.
+  return audio_callback_->CurrentThreadIsAudioDeviceThread();
+}
+
 void AudioOutputDevice::RequestDeviceAuthorizationOnIOThread() {
   DCHECK(task_runner()->BelongsToCurrentThread());
   DCHECK_EQ(state_, IDLE);
   state_ = AUTHORIZING;
   ipc_->RequestDeviceAuthorization(this, session_id_, device_id_,
                                    security_origin_);
 }
 
 void AudioOutputDevice::CreateStreamOnIOThread(const AudioParameters& params) {
   DCHECK(task_runner()->BelongsToCurrentThread());
@@ skipping 280 matching lines @@
            << " frames_skipped:" << frames_skipped;
 
   // Update the audio-delay measurement, inform about the number of skipped
   // frames, and ask client to render audio.  Since |output_bus_| is wrapping
   // the shared memory the Render() call is writing directly into the shared
   // memory.
   render_callback_->Render(output_bus_.get(), std::round(frames_delayed),
                            frames_skipped);
 }
 
+bool AudioOutputDevice::AudioThreadCallback::
+    CurrentThreadIsAudioDeviceThread() {
+  return thread_checker_.CalledOnValidThread();
+}
+
 }  // namespace media