Removing singelton property of MediaStreamManager.

content/browser/renderer_host/media/media_stream_manager.cc

 // 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.
 
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 
 #include <list>
 
-#include "base/lazy_instance.h"
+#include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/media/media_stream_device_settings.h"
 #include "content/browser/renderer_host/media/media_stream_requester.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_stream_options.h"
 
 namespace media_stream {
 
-// TODO(mflodman) Find out who should own MediaStreamManager.
-base::LazyInstance<MediaStreamManager> g_media_stream_manager(
-    base::LINKER_INITIALIZED);
-
 // Creates a random label used to identify requests.
 static std::string RandomLabel() {
-  // Alphbet according to WhatWG standard, i.e. containing 36 characters from
+  // Alphabet according to WhatWG standard, i.e. containing 36 characters from
   // range: U+0021, U+0023 to U+0027, U+002A to U+002B, U+002D to U+002E,
   // U+0030 to U+0039, U+0041 to U+005A, U+005E to U+007E.
   static const char alphabet[] = "!#$%&\'*+-.0123456789"
       "abcdefghijklmnopqrstuvwxyz^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~";
 
   std::string label(36, ' ');
   for (size_t i = 0; i < label.size(); ++i) {
     int random_char = base::RandGenerator(sizeof(alphabet) - 1);
     label[i] = alphabet[random_char];
   }
   return label;
 }
 
 // Helper to verify if a media stream type is part of options or not.
 static bool Requested(const StreamOptions& options,
                       MediaStreamType stream_type) {
   if (stream_type == kVideoCapture &&
       (options.video_option != StreamOptions::kNoCamera)) {
     return true;
   } else if (stream_type == kAudioCapture && options.audio == true) {
     return true;
   }
   return false;
 }
 
-MediaStreamManager* MediaStreamManager::Get() {
-  return g_media_stream_manager.Pointer();
+MediaStreamManager::MediaStreamManager()
+    : ALLOW_THIS_IN_INITIALIZER_LIST(
+          device_settings_(new MediaStreamDeviceSettings(this))),
+      enumeration_in_progress_(kNumMediaStreamTypes, false) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 MediaStreamManager::~MediaStreamManager() {
-  delete device_settings_;
-  delete video_capture_manager_;
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 VideoCaptureManager* MediaStreamManager::video_capture_manager() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  return video_capture_manager_;
+  if (!video_capture_manager_.get()) {
+    video_capture_manager_.reset(new VideoCaptureManager());
+    video_capture_manager_->Register(this);
+  }
+  return video_capture_manager_.get();
 }
 
 void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
                                         int render_process_id,
                                         int render_view_id,
                                         const StreamOptions& options,
                                         const std::string& security_origin,
                                         std::string* label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
@@ skipping 39 matching lines @@
           if (it->in_use == true) {
             // TODO(mflodman) Add when audio input device manager is available.
           }
         }
       }
       if (request->state[kVideoCapture] == DeviceRequest::kOpening) {
         for (StreamDeviceInfoArray::iterator it =
              request->video_devices.begin(); it != request->video_devices.end();
              ++it) {
           if (it->in_use == true) {
-            video_capture_manager_->Close(it->session_id);
+            video_capture_manager()->Close(it->session_id);
           }
         }
       }
       requests_.erase(it++);
     } else {
       ++it;
     }
   }
 }
 
 void MediaStreamManager::StopGeneratedStream(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Find the request and close all open devices for the request.
   DeviceRequests::iterator it = requests_.find(label);
   if (it != requests_.end()) {
     for (StreamDeviceInfoArray::iterator audio_it =
          it->second.audio_devices.begin();
          audio_it != it->second.audio_devices.end(); ++audio_it) {
       // TODO(mflodman) Add code when audio input manager exists.
       NOTREACHED();
     }
     for (StreamDeviceInfoArray::iterator video_it =
          it->second.video_devices.begin();
          video_it != it->second.video_devices.end(); ++video_it) {
-      video_capture_manager_->Close(video_it->session_id);
+      video_capture_manager()->Close(video_it->session_id);
     }
     requests_.erase(it);
     return;
   }
 }
 
 void MediaStreamManager::Opened(MediaStreamType stream_type,
                                 int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
@@ skipping 188 matching lines @@
   DeviceRequests::iterator it = requests_.find(label);
   if (it != requests_.end()) {
     it->second.requester->StreamGenerationFailed(label);
     requests_.erase(it);
     return;
   }
 }
 
 void MediaStreamManager::UseFakeDevice() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  video_capture_manager_->UseFakeDevice();
+  video_capture_manager()->UseFakeDevice();
   device_settings_->UseFakeUI();
   // TODO(mflodman) Add audio manager when available.
 }
 
 bool MediaStreamManager::RequestDone(const DeviceRequest& request) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Check if all devices are opened.
   if (Requested(request.options, kAudioCapture)) {
     for (StreamDeviceInfoArray::const_iterator it =
          request.audio_devices.begin(); it != request.audio_devices.end();
@@ skipping 10 matching lines @@
       if (it->in_use == false) {
         return false;
       }
     }
   }
   return true;
 }
 
 // Called to get media capture device manager of specified type.
 MediaStreamProvider* MediaStreamManager::GetDeviceManager(
-    MediaStreamType stream_type) const {
+    MediaStreamType stream_type) {
   if (stream_type == kVideoCapture) {
-    return video_capture_manager_;
+    return video_capture_manager();
   } else if (stream_type == kAudioCapture) {
     // TODO(mflodman) Add support when audio input manager is available.
     NOTREACHED();
     return NULL;
   }
   NOTREACHED();
   return NULL;
 }
 
-MediaStreamManager::MediaStreamManager()
-    : video_capture_manager_(new VideoCaptureManager()),
-      enumeration_in_progress_(kNumMediaStreamTypes, false),
-      requests_(),
-      device_settings_(NULL) {
-  device_settings_ = new MediaStreamDeviceSettings(this);
-  video_capture_manager_->Register(this);
-  // TODO(mflodman) Add when audio input manager is available.
-}
-
 MediaStreamManager::DeviceRequest::DeviceRequest()
     : requester(NULL),
       state(kNumMediaStreamTypes, kNotRequested) {
   options.audio = false;
   options.video_option = StreamOptions::kNoCamera;
 }
 
 MediaStreamManager::DeviceRequest::DeviceRequest(
     MediaStreamRequester* requester, const StreamOptions& request_options)
     : requester(requester),
       options(request_options),
       state(kNumMediaStreamTypes, kNotRequested) {
   DCHECK(requester);
 }
 
 MediaStreamManager::DeviceRequest::~DeviceRequest() {}
 
 }  // namespace media_stream