Move VideoCapture::VideoCaptureCapability to video_capture_types.h

content/renderer/media/video_capture_impl.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/renderer/media/video_capture_impl.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "content/common/child_process.h"
 #include "content/common/media/video_capture_messages.h"
@@ skipping 76 matching lines @@
   if (state_ == video_capture::kStarted)
     Send(new VideoCaptureHostMsg_Stop(device_id_));
 
   io_message_loop_proxy_->PostTask(FROM_HERE,
       base::Bind(&VideoCaptureImpl::RemoveDelegateOnIOThread,
                  base::Unretained(this), task));
 }
 
 void VideoCaptureImpl::StartCapture(
     media::VideoCapture::EventHandler* handler,
-    const VideoCaptureCapability& capability) {
-  DCHECK_EQ(capability.raw_type, media::VideoFrame::I420);
+    const media::VideoCaptureCapability& capability) {
+  DCHECK_EQ(capability.color, media::VideoFrame::I420);
 
   capture_message_loop_proxy_->PostTask(FROM_HERE,
       base::Bind(&VideoCaptureImpl::DoStartCapture,
                  base::Unretained(this), handler, capability));
 }
 
 void VideoCaptureImpl::StopCapture(media::VideoCapture::EventHandler* handler) {
   capture_message_loop_proxy_->PostTask(FROM_HERE,
       base::Bind(&VideoCaptureImpl::DoStopCapture,
                  base::Unretained(this), handler));
@@ skipping 33 matching lines @@
 }
 
 void VideoCaptureImpl::OnDelegateAdded(int32 device_id) {
   capture_message_loop_proxy_->PostTask(FROM_HERE,
       base::Bind(&VideoCaptureImpl::DoDelegateAdded,
                  base::Unretained(this), device_id));
 }
 
 void VideoCaptureImpl::DoStartCapture(
     media::VideoCapture::EventHandler* handler,
-    const VideoCaptureCapability& capability) {
+    const media::VideoCaptureCapability& capability) {
   DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
 
   if (state_ == video_capture::kError) {
     handler->OnError(this, 1);
     handler->OnRemoved(this);
     return;
   }
 
   ClientInfo::iterator it1 = clients_pending_on_filter_.find(handler);
   ClientInfo::iterator it2 = clients_pending_on_restart_.find(handler);
@@ skipping 32 matching lines @@
   if (state_ == video_capture::kStopping) {
     clients_pending_on_restart_[handler] = capability;
     DVLOG(1) << "StartCapture: Got new resolution ("
              << capability.width << ", " << capability.height << ") "
              << ", during stopping.";
     return;
   }
 
   clients_[handler] = capability;
   DCHECK_EQ(clients_.size(), 1ul);
-  video_type_ = capability.raw_type;
+  video_type_ = capability.color;
   current_params_.width = capability.width;
   current_params_.height = capability.height;
-  current_params_.frame_per_second = capability.max_fps;
+  current_params_.frame_per_second = capability.frame_rate;
   DVLOG(1) << "StartCapture: starting with first resolution ("
            << current_params_.width << ", " << current_params_.height << ")";
 
   StartCaptureInternal();
 }
 
 void VideoCaptureImpl::DoStopCapture(
     media::VideoCapture::EventHandler* handler) {
   DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
 
@@ skipping 133 matching lines @@
 }
 
 void VideoCaptureImpl::DoDelegateAdded(int32 device_id) {
   DVLOG(1) << "DoDelegateAdded: device_id " << device_id;
   DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
 
   device_id_ = device_id;
   for (ClientInfo::iterator it = clients_pending_on_filter_.begin();
        it != clients_pending_on_filter_.end(); ) {
     media::VideoCapture::EventHandler* handler = it->first;
-    const VideoCaptureCapability capability = it->second;
+    const media::VideoCaptureCapability capability = it->second;
     clients_pending_on_filter_.erase(it++);
     StartCapture(handler, capability);
   }
 }
 
 void VideoCaptureImpl::StopDevice() {
   DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
 
   device_info_available_ = false;
   if (state_ == video_capture::kStarted) {
@@ skipping 58 matching lines @@
 }
 
 bool VideoCaptureImpl::ClientHasDIB() {
   CachedDIB::iterator it;
   for (it = cached_dibs_.begin(); it != cached_dibs_.end(); it++) {
     if (it->second->references > 0)
       return true;
   }
   return false;
 }