Reland: Reorganize media::VideoCapture* types

content/browser/renderer_host/media/video_capture_manager.cc

 // 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.
 
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 115 matching lines @@
                  capture_session_id));
   sessions_.erase(session_it);
 }
 
 void VideoCaptureManager::UseFakeDevice() {
   use_fake_device_ = true;
 }
 
 void VideoCaptureManager::DoStartDeviceOnDeviceThread(
     DeviceEntry* entry,
-    const media::VideoCaptureCapability& capture_params,
+    const media::VideoCaptureParams& params,
     scoped_ptr<media::VideoCaptureDevice::Client> device_client) {
   SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StartDeviceTime");
   DCHECK(IsOnDeviceThread());
 
   scoped_ptr<media::VideoCaptureDevice> video_capture_device;
   switch (entry->stream_type) {
     case MEDIA_DEVICE_VIDEO_CAPTURE: {
       // We look up the device id from the renderer in our local enumeration
       // since the renderer does not have all the information that might be
       // held in the browser-side VideoCaptureDevice::Name structure.
@@ skipping 24 matching lines @@
       NOTIMPLEMENTED();
       break;
     }
   }
 
   if (!video_capture_device) {
     device_client->OnError();
     return;
   }
 
-  video_capture_device->AllocateAndStart(capture_params, device_client.Pass());
+  video_capture_device->AllocateAndStart(params, device_client.Pass());
   entry->video_capture_device = video_capture_device.Pass();
 }
 
 void VideoCaptureManager::StartCaptureForClient(
+    media::VideoCaptureSessionId session_id,
     const media::VideoCaptureParams& params,
     base::ProcessHandle client_render_process,
     VideoCaptureControllerID client_id,
     VideoCaptureControllerEventHandler* client_handler,
     const DoneCB& done_cb) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DVLOG(1) << "VideoCaptureManager::StartCaptureForClient, ("
-         << params.requested_format.width
-         << ", " << params.requested_format.height
-         << ", " << params.requested_format.frame_rate
-         << ", #" << params.session_id
-         << ")";
+  DVLOG(1) << "VideoCaptureManager::StartCaptureForClient, "
+           << params.requested_format.frame_size.ToString() << ", "
+           << params.requested_format.frame_rate << ", #" << session_id << ")";
 
-  DeviceEntry* entry = GetOrCreateDeviceEntry(params.session_id);
+  DeviceEntry* entry = GetOrCreateDeviceEntry(session_id);
   if (!entry) {
     done_cb.Run(base::WeakPtr<VideoCaptureController>());
     return;
   }
 
   DCHECK(entry->video_capture_controller);
 
   // First client starts the device.
   if (entry->video_capture_controller->GetClientCount() == 0) {
     DVLOG(1) << "VideoCaptureManager starting device (type = "
              << entry->stream_type << ", id = " << entry->id << ")";
 
-    media::VideoCaptureCapability params_as_capability;
-    params_as_capability.width = params.requested_format.width;
-    params_as_capability.height = params.requested_format.height;
-    params_as_capability.frame_rate = params.requested_format.frame_rate;
-    params_as_capability.frame_size_type =
-        params.requested_format.frame_size_type;
-
-    device_loop_->PostTask(FROM_HERE, base::Bind(
-        &VideoCaptureManager::DoStartDeviceOnDeviceThread, this,
-        entry, params_as_capability,
-        base::Passed(entry->video_capture_controller->NewDeviceClient())));
+    device_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &VideoCaptureManager::DoStartDeviceOnDeviceThread,
+            this,
+            entry,
+            params,
+            base::Passed(entry->video_capture_controller->NewDeviceClient())));
   }
   // Run the callback first, as AddClient() may trigger OnFrameInfo().
   done_cb.Run(entry->video_capture_controller->GetWeakPtr());
-  entry->video_capture_controller->AddClient(client_id,
-                                             client_handler,
-                                             client_render_process,
-                                             params);
+  entry->video_capture_controller->AddClient(
+      client_id, client_handler, client_render_process, session_id, params);
 }
 
 void VideoCaptureManager::StopCaptureForClient(
     VideoCaptureController* controller,
     VideoCaptureControllerID client_id,
     VideoCaptureControllerEventHandler* client_handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(controller);
   DCHECK(client_handler);
 
@@ skipping 174 matching lines @@
   scoped_ptr<VideoCaptureController> video_capture_controller(
       new VideoCaptureController());
   DeviceEntry* new_device = new DeviceEntry(device_info.type,
                                             device_info.id,
                                             video_capture_controller.Pass());
   devices_.insert(new_device);
   return new_device;
 }
 
 }  // namespace content