Adding MediaStreamManager.

content/browser/renderer_host/media/video_capture_controller.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/video_capture_controller.h"
 
 #include "base/stl_util-inl.h"
 #include "content/browser/browser_thread.h"
+#include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "media/base/yuv_convert.h"
 
 // The number of TransportDIBs VideoCaptureController allocate.
 static const size_t kNoOfDIBS = 3;
 
 VideoCaptureController::VideoCaptureController(
     const VideoCaptureControllerID& id,
     base::ProcessHandle render_process,
     VideoCaptureControllerEventHandler* event_handler)
     : render_handle_(render_process),
       report_ready_to_delete_(false),
       event_handler_(event_handler),
       id_(id) {
   memset(&params_, 0, sizeof(params_));
 }
 
 VideoCaptureController::~VideoCaptureController() {
   // Delete all TransportDIBs.
   STLDeleteContainerPairSecondPointers(owned_dibs_.begin(),
                                        owned_dibs_.end());
 }
 
 void VideoCaptureController::StartCapture(
     const media::VideoCaptureParams& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   params_ = params;
-  media_stream::VideoCaptureManager* manager =
-      media_stream::VideoCaptureManager::Get();
+    media_stream::VideoCaptureManager* manager =
+        media_stream::MediaStreamManager::Get()->GetVideoCaptureManager();
   // Order the manager to start the actual capture.
   manager->Start(params, this);
 }
 
 void VideoCaptureController::StopCapture(Task* stopped_task) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   media_stream::VideoCaptureManager* manager =
-      media_stream::VideoCaptureManager::Get();
+      media_stream::MediaStreamManager::Get()->GetVideoCaptureManager();
   manager->Stop(params_.session_id,
                 NewRunnableMethod(this,
                                   &VideoCaptureController::OnDeviceStopped,
                                   stopped_task));
 }
 
 void VideoCaptureController::ReturnBuffer(int buffer_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   bool ready_to_delete;
@@ skipping 91 matching lines @@
     }
     default:
       NOTREACHED();
   }
 
   event_handler_->OnBufferReady(id_, buffer_id, timestamp);
 }
 
 void VideoCaptureController::OnError() {
   event_handler_->OnError(id_);
-  media_stream::VideoCaptureManager::Get()->Error(params_.session_id);
+  media_stream::MediaStreamManager::Get()->GetVideoCaptureManager()->
+      Error(params_.session_id);
 }
 
 void VideoCaptureController::OnFrameInfo(
     const media::VideoCaptureDevice::Capability& info) {
   DCHECK(owned_dibs_.empty());
   bool frames_created = true;
   const size_t needed_size = (info.width * info.height * 3) / 2;

[Leandro Graciá Gil, 2011/07/01 11:31:35]

Just as a sidenote, I guess you know this better than me but make sure you don't
have any horizontal line alignment for whatever you're doing, or you will have
problems with some width values and alignment gaps.

[mflodman1, 2011/07/01 14:07:23]

As it is now, this is an I420 frame without any alignment gaps, so it should be
fine here.

   for (size_t i = 1; i <= kNoOfDIBS; ++i) {
     base::SharedMemory* shared_memory = new base::SharedMemory();
     if (!shared_memory->CreateAndMapAnonymous(needed_size)) {
       frames_created = false;
       break;
     }
     base::SharedMemoryHandle remote_handle;
     shared_memory->ShareToProcess(render_handle_, &remote_handle);
 
     base::AutoLock lock(lock_);
@@ skipping 27 matching lines @@
   }
 
   if (ready_to_delete_now) {
     event_handler_->OnReadyToDelete(id_);
   }
   if (stopped_task) {
     stopped_task->Run();
     delete stopped_task;
   }
 }