AudioMirroringManager becomes a global LazyInstance.

content/browser/media/capture/audio_mirroring_manager.h

 // Copyright (c) 2013 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.
 //
 // AudioMirroringManager is a singleton object that maintains a set of active
 // audio mirroring destinations and auto-connects/disconnects audio streams
 // to/from those destinations.  It is meant to be used exclusively on the IO
-// BrowserThread.
+// thread.
 //
 // How it works:
 //
 //   1. AudioRendererHost gets a CreateStream message from the render process
 //      and, among other things, creates an AudioOutputController to control the
 //      audio data flow between the render and browser processes.
 //   2. At some point, AudioRendererHost receives an "associate with render
 //      view" message.  Among other actions, it registers the
 //      AudioOutputController with AudioMirroringManager (as a Diverter).
 //   3. A user request to mirror all the audio for a single RenderView is made.
 //      A MirroringDestination is created, and StartMirroring() is called to
 //      begin the mirroring session.  This causes AudioMirroringManager to
 //      instruct any matching Diverters to divert their audio data to the
 //      MirroringDestination.
 //
 // #2 and #3 above may occur in any order, as it is the job of
 // AudioMirroringManager to realize when the players can be "matched up."
 
 #ifndef CONTENT_BROWSER_MEDIA_CAPTURE_AUDIO_MIRRORING_MANAGER_H_
 #define CONTENT_BROWSER_MEDIA_CAPTURE_AUDIO_MIRRORING_MANAGER_H_
 
 #include <map>
 #include <utility>
 
 #include "base/basictypes.h"
+#include "base/threading/thread_checker.h"
 #include "content/common/content_export.h"
 #include "media/audio/audio_source_diverter.h"
 
 namespace media {
 class AudioOutputStream;
 }
 
 namespace content {
 
 class CONTENT_EXPORT AudioMirroringManager {
  public:
   // Interface for diverting audio data to an alternative AudioOutputStream.
   typedef media::AudioSourceDiverter Diverter;
 
   // Interface to be implemented by audio mirroring destinations.  See comments
   // for StartMirroring() and StopMirroring() below.
   class MirroringDestination {
    public:
     // Create a consumer of audio data in the format specified by |params|, and
     // connect it as an input to mirroring.  When Close() is called on the
     // returned AudioOutputStream, the input is disconnected and the object
     // becomes invalid.
     virtual media::AudioOutputStream* AddInput(
         const media::AudioParameters& params) = 0;
 
    protected:
     virtual ~MirroringDestination() {}
   };
 
+  // Note: Use GetInstance() for non-test code.
   AudioMirroringManager();
+  virtual ~AudioMirroringManager();
 
-  virtual ~AudioMirroringManager();
+  // Returns the global instance.
+  static AudioMirroringManager* GetInstance();
 
   // Add/Remove a diverter for an audio stream with a known RenderView target
   // (represented by |render_process_id| + |render_view_id|).  Multiple
   // diverters may be added for the same target.  |diverter| must live until
   // after RemoveDiverter() is called.
   //
   // Re-entrancy warning: These methods should not be called by a Diverter
   // during a Start/StopDiverting() invocation.
   virtual void AddDiverter(int render_process_id, int render_view_id,
                            Diverter* diverter);
@@ skipping 17 matching lines @@
   // Note: Objects in these maps are not owned.
   typedef std::multimap<Target, Diverter*> DiverterMap;
   typedef std::map<Target, MirroringDestination*> SessionMap;
 
   // Currently-active divertable audio streams.
   DiverterMap diverters_;
 
   // Currently-active mirroring sessions.
   SessionMap sessions_;
 
+  // Used to check that all AudioMirroringManager code runs on the same thread.
+  base::ThreadChecker thread_checker_;
+
   DISALLOW_COPY_AND_ASSIGN(AudioMirroringManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_MEDIA_CAPTURE_AUDIO_MIRRORING_MANAGER_H_