Making AudioThread::Thread restartable *** DRAFT ***

media/audio/audio_device_thread.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_AUDIO_AUDIO_DEVICE_THREAD_H_
 #define MEDIA_AUDIO_AUDIO_DEVICE_THREAD_H_
 
 #include <stdint.h>
 
 #include "base/macros.h"
@@ skipping 58 matching lines @@
     const int total_segments_;
     int segment_length_;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Callback);
   };
 
   AudioDeviceThread();
   ~AudioDeviceThread();
 
-  // Starts the audio thread. The thread must not already be running.  If
-  // |sychronized_buffers| is set, the browser expects to be notified via the
-  // |socket| every time AudioDeviceThread::Process() completes.
-  void Start(AudioDeviceThread::Callback* callback,
-             base::SyncSocket::Handle socket,
-             const char* thread_name,
-             bool synchronized_buffers);
+  // Starts the audio thread and puts into wait mode. Play() must
+  // be called to release it and actually start running. The thread must not
+  // already be started.  If |sychronized_buffers| is set, the browser expects
+  // to be notified via the |socket| every time AudioDeviceThread::Process()
+  // completes.
+  void Start(const char* thread_name, bool synchronized_buffers);
 
   // This tells the audio thread to stop and clean up the data.
   // The method can stop the thread synchronously or asynchronously.
   // In the latter case, the thread will still be running after Stop()
   // returns, but the callback pointer is cleared so no further callbacks will
   // be made (IOW after Stop() returns, it is safe to delete the callback).
   // The |loop_for_join| parameter is required for asynchronous operation
   // in order to join the worker thread and close the thread handle later via a
   // posted task.
   // If set to NULL, function will wait for the thread to exit before returning.
   void Stop(base::MessageLoop* loop_for_join);
 
+  // Releases the thread from wait mode so that it starts running with the given

[Guido Urdaneta, 2016/04/01 10:17:01]

Nit: Release is perhaps not the most familiar term for this.
What about something like "Puts the thread in running mode" or something like
that. Note that you use this wording in the documentation of Pause().

[Henrik Grunell, 2016/05/09 12:13:37]

Done in other CL.

+  // |callback| and |socket|. This will also reset the index used for
+  // sychronized buffers.
+  void Play(AudioDeviceThread::Callback* callback,
+            base::SyncSocket::Handle socket);
+
+  // Puts the thread in the wait mode and shuts down the socket.
+  // It can be resumed again with Play().
+  void Pause();
+
   // Returns true if the thread is stopped or stopping.
   bool IsStopped();
 
  private:
+  // Not sure if we need this extra class and extra lock?

[Henrik Grunell, 2016/03/25 09:24:01]

Yeah, does the below motivation hold? It seems pretty old, it refers to
SimpleThread, but we use PlatformThread, so maybe the need for wrapping is
obsolete.

[Henrik Grunell, 2016/05/09 12:13:37]

Changed to TODO in other CL.

   // Our own private SimpleThread override.  We implement this in a
   // private class so that we get the following benefits:
   // 1) AudioDeviceThread doesn't expose SimpleThread methods.
   //    I.e. the caller can't call Start()/Stop() - which would be bad.
   // 2) We override ThreadMain to add additional on-thread initialization
   //    while still synchronized with SimpleThread::Start() to provide
   //    reliable initialization.
   class Thread;
 
   base::Lock thread_lock_;
   scoped_refptr<AudioDeviceThread::Thread> thread_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioDeviceThread);
 };
 
 }  // namespace media.
 
 #endif  // MEDIA_AUDIO_AUDIO_DEVICE_THREAD_H_