Removing singleton property of MediaStreamManager and creating thread first when needed.

content/browser/renderer_host/media/media_stream_manager.h

 // Copyright (c) 2011 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.
 
 // MediaStreamManager is used to open media capture devices (video supported
 // now). Call flow:
 // 1. GenerateStream is called when a render process wants to use a capture
 //    device.
 // 2. MediaStreamManager will ask MediaStreamDeviceSettings for permission to
 //    use devices and for which device to use.
 // 3. MediaStreamDeviceSettings will request list(s) of available devices, the
 //    requests will be relayed to the corresponding media device manager and the
 //    result will be given to MediaStreamDeviceSettings.
 // 4. MediaStreamDeviceSettings will, by using user settings, pick devices which
 //    devices to use and let MediaStreamManager know the result.
 // 5. MediaStreamManager will call the proper media device manager to open the
 //    device and let the MediaStreamRequester know it has been done.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_
 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
-#include "base/lazy_instance.h"
+#include "base/basictypes.h"
+#include "base/memory/ref_counted.h"
 #include "content/browser/renderer_host/media/media_stream_provider.h"
 #include "content/browser/renderer_host/media/media_stream_settings_requester.h"
 #include "content/common/media/media_stream_options.h"
 
 namespace media_stream {
 
 class MediaStreamDeviceSettings;
 class MediaStreamRequester;
 class VideoCaptureManager;
 
 // MediaStreamManager is used to generate and close new media devices, not to
 // start the media flow.
 // The classes requesting new media streams are answered using
 // MediaStreamManager::Listener.
 class MediaStreamManager
-    : public MediaStreamProviderListener,
+    : public base::RefCounted<media_stream::MediaStreamManager>,

[willchan no longer on Chromium, 2011/08/17 19:55:19]

Why is this refcounted? Who owns this object? It's in the ProfileIOData which
suggests that ProfileIOData owns it. If so, please remove the refcounting. If it
truly has shared ownership, please document the ownership here.

Note that if you're using refcounting due to NewRunnableMethod() needing it to
be refcounted, then you should either use ScopedRunnableMethodFactory,
base::WeakPtrFactory, or base::Bind()+base::Unretained() to eliminate the need
for the refcounting.

My inkling is that the ownership of this object is well-defined. It should die
when the ProfileIOData dies (which is right after the Profile dies). And nothing
should be posting to it afterwards, and if anything is doing so, it's a bug. If
this is correct, then please don't use refcounting. Use the solutions I
recommended.

[mflodman_chromium_OOO, 2011/08/19 11:07:09]

Done, removed ref counted and replaced scoped_refptr with scoped_ptr in
ProfileIOData.

+      public MediaStreamProviderListener,
       public SettingsRequester {
  public:
   typedef MediaStreamManager* (AccessorMethod)();

[wjia(left Chromium), 2011/08/17 21:13:54]

is this still in use?

[mflodman_chromium_OOO, 2011/08/19 11:07:09]

Removed, done.

-  static MediaStreamManager* Get();
-  virtual ~MediaStreamManager();
 
-  // Used to access VideoCaptuerManager.
+  MediaStreamManager();
+
+  // Used to access VideoCaptureManager.
   VideoCaptureManager* video_capture_manager();
 
   // GenerateStream opens new media devices according to |components|. The
   // request is identified using |label|, which is pointing to an already
   // created std::string.
   void GenerateStream(MediaStreamRequester* requester, int render_process_id,
                       int render_view_id, const StreamOptions& options,
                       const std::string& security_origin, std::string* label);
 
   // Cancels all non-finished GenerateStream request, i.e. request for which
@@ skipping 16 matching lines @@
                           MediaStreamType stream_type);
   virtual void DevicesAccepted(const std::string& label,
                                const StreamDeviceInfoArray& devices);
   virtual void SettingsError(const std::string& label);
 
   // Used by unit test to make sure fake devices are used instead of a real
   // devices, which is needed for server based testing.
   void UseFakeDevice();
 
  private:
+  friend class base::RefCounted<MediaStreamManager>;
+  virtual ~MediaStreamManager();
+
   // Contains all data needed to keep track of requests.
   struct DeviceRequest {
     DeviceRequest();
     DeviceRequest(MediaStreamRequester* requester,
                   const StreamOptions& request_options);
     ~DeviceRequest();
     enum RequestState {
       kNotRequested = 0,
       kRequested,
       kOpening,
       kDone,
       kError
     };
 
     MediaStreamRequester* requester;
     StreamOptions options;
     std::vector<RequestState> state;
     StreamDeviceInfoArray audio_devices;
     StreamDeviceInfoArray video_devices;
   };
 
   // Helpers.
   bool RequestDone(const MediaStreamManager::DeviceRequest& request) const;
-  MediaStreamProvider* GetDeviceManager(MediaStreamType stream_type) const;
-
-  // Private constructor to enforce singleton.
-  friend struct base::DefaultLazyInstanceTraits<MediaStreamManager>;
-  MediaStreamManager();
-
+  MediaStreamProvider* GetDeviceManager(MediaStreamType stream_type);
   VideoCaptureManager* video_capture_manager_;
   // TODO(mflodman) Add AudioInputManager.
 
   // Keeps track of device types currently being enumerated to not enumerate
   // when not necessary.
   std::vector<bool> enumeration_in_progress_;
 
   // All non-closed request.
   typedef std::map<std::string, DeviceRequest> DeviceRequests;
   DeviceRequests requests_;
 
   MediaStreamDeviceSettings* device_settings_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaStreamManager);
 };
 
 }  // namespace media_stream
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_