Follow up patch on issue 7192007, containing mainly style fixes.

content/browser/renderer_host/media/video_capture_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/video_capture_manager.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "content/browser/browser_thread.h"
 #include "media/video/capture/fake_video_capture_device.h"
 #include "media/video/capture/video_capture_device.h"
@@ skipping 44 matching lines @@
   vc_device_thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &VideoCaptureManager::OnEnumerateDevices));
 }
 
 int VideoCaptureManager::Open(const StreamDeviceInfo& device) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(listener_);
 
-  // Generate a new id for this device
+  // Generate a new id for this device.
   int video_capture_session_id = new_capture_session_id_++;
 
   vc_device_thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &VideoCaptureManager::OnOpen,
                         video_capture_session_id,
                         device));
 
   return video_capture_session_id;
@@ skipping 17 matching lines @@
 
   vc_device_thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &VideoCaptureManager::OnStart,
                         capture_params,
                         video_capture_receiver));
 }
 
 void VideoCaptureManager::Stop(
-    const media::VideoCaptureSessionId capture_session_id, Task* stopped_task) {
+    const media::VideoCaptureSessionId& capture_session_id,
+    Task* stopped_task) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   vc_device_thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &VideoCaptureManager::OnStop,
                         capture_session_id,
                         stopped_task));
 }
 
@@ skipping 32 matching lines @@
   DCHECK(IsOnCaptureDeviceThread());
   DCHECK(devices_.find(capture_session_id) == devices_.end());
 
   // Check if another session has already opened this device, only one user per
   // device is supported.
   if (DeviceOpened(device)) {
     PostOnError(capture_session_id, kDeviceAlreadyInUse);
     return;
   }
 
-  // Open the device
+  // Open the device.
   media::VideoCaptureDevice::Name vc_device_name;
   vc_device_name.device_name = device.name;
   vc_device_name.unique_id = device.device_id;
 
   media::VideoCaptureDevice* video_capture_device = NULL;
   if (!use_fake_device_) {
     video_capture_device = media::VideoCaptureDevice::Create(vc_device_name);
   } else {
     video_capture_device =
         media::FakeVideoCaptureDevice::Create(vc_device_name);
   }
-  if (video_capture_device == NULL) {
+  if (!video_capture_device) {
     PostOnError(capture_session_id, kDeviceNotAvailable);
     return;
   }
 
   devices_[capture_session_id] = video_capture_device;
   PostOnOpened(capture_session_id);
 }
 
 void VideoCaptureManager::OnClose(int capture_session_id) {
   DCHECK(IsOnCaptureDeviceThread());
 
   VideoCaptureDevices::iterator it = devices_.find(capture_session_id);
   if (it != devices_.end()) {
-    // Deallocate (if not done already) and delete the device
+    // Deallocate (if not done already) and delete the device.
     media::VideoCaptureDevice* video_capture_device = it->second;
     video_capture_device->DeAllocate();
     delete video_capture_device;
     devices_.erase(it);
   }
 
   PostOnClosed(capture_session_id);
 }
 
 void VideoCaptureManager::OnStart(
     const media::VideoCaptureParams capture_params,
     media::VideoCaptureDevice::EventHandler* video_capture_receiver) {
   DCHECK(IsOnCaptureDeviceThread());
   DCHECK(video_capture_receiver != NULL);
 
-  // Solution for not using MediaStreamManager
-  // This session id won't be returned by Open()
+  // Solution for not using MediaStreamManager.
+  // This session id won't be returned by Open().
   if (capture_params.session_id == kStartOpenSessionId) {
-    // Start() is called without using Open(), we need to open a device
+    // Start() is called without using Open(), we need to open a device.
     media::VideoCaptureDevice::Names device_names;
     GetAvailableDevices(&device_names);
     if (device_names.empty()) {
       // No devices available.
       video_capture_receiver->OnError();
       return;
     }
     StreamDeviceInfo device(kVideoCapture,
                             device_names.front().device_name,
                             device_names.front().unique_id, false);
 
-    // Call OnOpen to open using the first device in the list
+    // Call OnOpen to open using the first device in the list.
     OnOpen(capture_params.session_id, device);
   }
 
   VideoCaptureDevices::iterator it = devices_.find(capture_params.session_id);
   if (it == devices_.end()) {
-    // Invalid session id
+    // Invalid session id.
     video_capture_receiver->OnError();
     return;
   }
   media::VideoCaptureDevice* video_capture_device = it->second;
 
   // Possible errors are signaled to video_capture_receiver by
   // video_capture_device. video_capture_receiver to perform actions.
   video_capture_device->Allocate(capture_params.width, capture_params.height,
                                  capture_params.frame_per_second,
                                  video_capture_receiver);
@@ skipping 20 matching lines @@
   }
 
   if (capture_session_id == kStartOpenSessionId) {
     // This device was opened from Start(), not Open(). Close it!
     OnClose(capture_session_id);
   }
 }
 
 void VideoCaptureManager::OnOpened(int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (listener_ == NULL) {
-    // Listener has been removed
+  if (!listener_) {
+    // Listener has been removed.
     return;
   }
   listener_->Opened(kVideoCapture, capture_session_id);
 }
 
 void VideoCaptureManager::OnClosed(int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (listener_ == NULL) {
-    // Listener has been removed
+  if (!listener_) {
+    // Listener has been removed.
     return;
   }
   listener_->Closed(kVideoCapture, capture_session_id);
 }
 
 void VideoCaptureManager::OnDevicesEnumerated(
     const StreamDeviceInfoArray& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!listener_) {
-    // Listener has been removed
+    // Listener has been removed.
     return;
   }
   listener_->DevicesEnumerated(kVideoCapture, devices);
 }
 
 void VideoCaptureManager::OnError(int capture_session_id,
                                   MediaStreamProviderError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (listener_ == NULL) {
-    // Listener has been removed
+  if (!listener_) {
+    // Listener has been removed.
     return;
   }
   listener_->Error(kVideoCapture, capture_session_id, error);
 }
 
 void VideoCaptureManager::PostOnOpened(int capture_session_id) {
   DCHECK(IsOnCaptureDeviceThread());
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           NewRunnableMethod(this,
@@ skipping 69 matching lines @@
   for (VideoCaptureDevices::iterator it = devices_.begin();
       it != devices_.end();
       it++) {
     if (device_info.device_id == it->second->device_name().unique_id) {
       return true;
     }
   }
   return false;
 }
 
-}  // namespace media
+}  // namespace media_stream