Stop media stream source when audio capture error occurs.

content/renderer/media/media_stream_audio_source.h

 // 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_MEDIA_STREAM_AUDIO_SOURCE_H_
 #define CONTENT_RENDERER_MEDIA_MEDIA_STREAM_AUDIO_SOURCE_H_
 
 #include <memory>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "content/common/content_export.h"
 #include "content/renderer/media/media_stream_audio_deliverer.h"
 #include "content/renderer/media/media_stream_source.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 
+namespace base {
+class SingleThreadTaskRunner;
+}
+
 namespace content {
 
 class MediaStreamAudioTrack;
 
 // Represents a source of audio, and manages the delivery of audio data between
 // the source implementation and one or more MediaStreamAudioTracks. This is a
 // base class providing all the necessary functionality to connect tracks and
 // have audio data delivered to them. Subclasses provide the actual audio source
 // implementation (e.g., media::AudioCapturerSource), and should implement the
 // EnsureSourceIsStarted() and EnsureSourceIsStopped() methods, and call
@@ skipping 86 matching lines @@
   // source to the sinks. This may be called at any time, before or after
   // tracks have been connected; but must be called at least once before
   // DeliverDataToTracks(). This method is thread-safe.
   void SetFormat(const media::AudioParameters& params);
 
   // Called by subclasses to deliver audio data to the currently-connected
   // tracks. This method is thread-safe.
   void DeliverDataToTracks(const media::AudioBus& audio_bus,
                            base::TimeTicks reference_time);
 
+  // Called by subclasses when capture error occurs.
+  // Note: This can be called on any thread, and will post a task to the main
+  // thread to stop the source soon.
+  void StopSourceOnError(const std::string& why);
+
  private:
   // MediaStreamSource override.
   void DoStopSource() final;
 
   // Removes |track| from the list of instances that get a copy of the source
   // audio data. The "stop callback" that was provided to the track calls
   // this.
   void StopAudioDeliveryTo(MediaStreamAudioTrack* track);
 
   // True if the source of audio is a local device. False if the source is
   // remote (e.g., streamed-in from a server).
   const bool is_local_source_;
 
-  // In debug builds, check that all methods that could cause object graph
-  // or data flow changes are being called on the main thread.
-  base::ThreadChecker thread_checker_;
-
   // Set to true once this source has been permanently stopped.
   bool is_stopped_;
 
   // Manages tracks connected to this source and the audio format and data flow.
   MediaStreamAudioDeliverer<MediaStreamAudioTrack> deliverer_;
 
+  // The task runner for main thread. Also used to check that all methods that
+  // could cause object graph or data flow changes are being called on the main
+  // thread.
+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+
   // Provides weak pointers so that MediaStreamAudioTracks won't call
   // StopAudioDeliveryTo() if this instance dies first.
   base::WeakPtrFactory<MediaStreamAudioSource> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaStreamAudioSource);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_MEDIA_STREAM_AUDIO_SOURCE_H_