VideoCaptureHost/VideoCaptureControllerEventHandler cleanup

content/browser/renderer_host/media/video_capture_controller.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_controller.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 59 matching lines @@
     gl_helper->WaitSyncPoint(sync_point);
     SyncPointClientImpl client(gl_helper);
     video_frame->UpdateReleaseSyncPoint(&client);
   }
 #endif
 }
 
 }  // anonymous namespace
 
 struct VideoCaptureController::ControllerClient {
-  ControllerClient(const VideoCaptureControllerID& id,
+  ControllerClient(VideoCaptureControllerID id,
                    VideoCaptureControllerEventHandler* handler,
                    base::ProcessHandle render_process,
                    media::VideoCaptureSessionId session_id,
                    const media::VideoCaptureParams& params)
       : controller_id(id),
         event_handler(handler),
         render_process_handle(render_process),
         session_id(session_id),
         parameters(params),
         session_closed(false),
@@ skipping 61 matching lines @@
         format));
     DVLOG(1) << "TextureWrapper, format " << format.ToString();
   }
 #endif
   return make_scoped_ptr(
       new VideoCaptureDeviceClient(this->GetWeakPtrForIOThread(),
                                    buffer_pool_));
 }
 
 void VideoCaptureController::AddClient(
-    const VideoCaptureControllerID& id,
+    VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* event_handler,
     base::ProcessHandle render_process,
     media::VideoCaptureSessionId session_id,
     const media::VideoCaptureParams& params) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DVLOG(1) << "VideoCaptureController::AddClient, id " << id.device_id
+  DVLOG(1) << "VideoCaptureController::AddClient, id " << id
            << ", " << params.requested_format.frame_size.ToString()
            << ", " << params.requested_format.frame_rate
            << ", " << session_id
            << ")";
 
   // If this is the first client added to the controller, cache the parameters.
   if (!controller_clients_.size())
     video_capture_format_ = params.requested_format;
 
   // Signal error in case device is already in error state.
@@ skipping 10 matching lines @@
       id, event_handler, render_process, session_id, params);
   // If we already have gotten frame_info from the device, repeat it to the new
   // client.
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     controller_clients_.push_back(client);
     return;
   }
 }
 
 int VideoCaptureController::RemoveClient(
-    const VideoCaptureControllerID& id,
+    VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* event_handler) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DVLOG(1) << "VideoCaptureController::RemoveClient, id " << id.device_id;
+  DVLOG(1) << "VideoCaptureController::RemoveClient, id " << id;
 
   ControllerClient* client = FindClient(id, event_handler, controller_clients_);
   if (!client)
     return kInvalidMediaCaptureSessionId;
 
   // Take back all buffers held by the |client|.
-  for (ControllerClient::ActiveBufferMap::iterator buffer_it =
-           client->active_buffers.begin();
-       buffer_it != client->active_buffers.end();
-       ++buffer_it) {
-    buffer_pool_->RelinquishConsumerHold(buffer_it->first, 1);
-  }
+  for (const auto& buffer : client->active_buffers)
+    buffer_pool_->RelinquishConsumerHold(buffer.first, 1);
   client->active_buffers.clear();
 
   int session_id = client->session_id;
   controller_clients_.remove(client);
   delete client;
 
   return session_id;
 }
 
 void VideoCaptureController::PauseOrResumeClient(
-    const VideoCaptureControllerID& id,
+    VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* event_handler,
     bool pause) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureController::PauseOrResumeClient, id "
-           << id.device_id << ", " << pause;
+           << id << ", " << pause;
 
   ControllerClient* client = FindClient(id, event_handler, controller_clients_);
   if (!client)
     return;
 
   DCHECK(client->paused != pause);
   client->paused = pause;
 }
 
 void VideoCaptureController::StopSession(int session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureController::StopSession, id " << session_id;
 
   ControllerClient* client = FindClient(session_id, controller_clients_);
 
   if (client) {
     client->session_closed = true;
     client->event_handler->OnEnded(client->controller_id);
   }
 }
 
 void VideoCaptureController::ReturnBuffer(
-    const VideoCaptureControllerID& id,
+    VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* event_handler,
     int buffer_id,
     uint32 sync_point) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ControllerClient* client = FindClient(id, event_handler, controller_clients_);
 
   // If this buffer is not held by this client, or this client doesn't exist
   // in controller, do nothing.
   ControllerClient::ActiveBufferMap::iterator iter;
@@ skipping 105 matching lines @@
     has_received_frames_ = true;
   }
 
   buffer_pool_->HoldForConsumers(buffer->id(), count);
 }
 
 void VideoCaptureController::DoErrorOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   state_ = VIDEO_CAPTURE_STATE_ERROR;
 
-  for (ControllerClients::iterator client_it = controller_clients_.begin();
-       client_it != controller_clients_.end(); ++client_it) {
-    ControllerClient* client = *client_it;
+  for (const auto* client : controller_clients_) {
     if (client->session_closed)
        continue;
-
     client->event_handler->OnError(client->controller_id);
   }
 }
 
 void VideoCaptureController::DoLogOnIOThread(const std::string& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   MediaStreamManager::SendMessageToNativeLog("Video capture: " + message);
 }
 
 void VideoCaptureController::DoBufferDestroyedOnIOThread(
     int buffer_id_to_drop) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  for (ControllerClients::iterator client_it = controller_clients_.begin();
-       client_it != controller_clients_.end(); ++client_it) {
-    ControllerClient* client = *client_it;
+  for (auto* client : controller_clients_) {
     if (client->session_closed)
       continue;
 
     if (client->known_buffers.erase(buffer_id_to_drop)) {
       client->event_handler->OnBufferDestroyed(client->controller_id,
                                                buffer_id_to_drop);
     }
   }
 }
 
-VideoCaptureController::ControllerClient*
-VideoCaptureController::FindClient(
-    const VideoCaptureControllerID& id,
+VideoCaptureController::ControllerClient* VideoCaptureController::FindClient(
+    VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* handler,
     const ControllerClients& clients) {
-  for (ControllerClients::const_iterator client_it = clients.begin();
-       client_it != clients.end(); ++client_it) {
-    if ((*client_it)->controller_id == id &&
-        (*client_it)->event_handler == handler) {
-      return *client_it;
-    }
+  for (auto* client : clients) {
+    if (client->controller_id == id && client->event_handler == handler)
+      return client;
   }
   return NULL;
 }
 
-VideoCaptureController::ControllerClient*
-VideoCaptureController::FindClient(
+VideoCaptureController::ControllerClient* VideoCaptureController::FindClient(
     int session_id,
     const ControllerClients& clients) {
-  for (ControllerClients::const_iterator client_it = clients.begin();
-       client_it != clients.end(); ++client_it) {
-    if ((*client_it)->session_id == session_id) {
-      return *client_it;
-    }
+  for (auto client : clients) {
+    if (client->session_id == session_id)
+      return client;
   }
   return NULL;
 }
 
 int VideoCaptureController::GetClientCount() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return controller_clients_.size();
 }
 
 int VideoCaptureController::GetActiveClientCount() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   int active_client_count = 0;
   for (ControllerClient* client : controller_clients_) {
     if (!client->paused)
       ++active_client_count;
   }
   return active_client_count;
 }
 
 }  // namespace content