Reland [Mojo Video Capture] Add test coverage for accelerated jpeg decoding

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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 28 matching lines @@
 namespace content {
 
 namespace {
 
 static const int kInfiniteRatio = 99999;
 
 #define UMA_HISTOGRAM_ASPECT_RATIO(name, width, height) \
   UMA_HISTOGRAM_SPARSE_SLOWLY(                          \
       name, (height) ? ((width)*100) / (height) : kInfiniteRatio);
 
+void CallOnError(VideoCaptureControllerEventHandler* client,
+                 VideoCaptureControllerID id) {
+  client->OnError(id);
+}
+
+void CallOnStarted(VideoCaptureControllerEventHandler* client,
+                   VideoCaptureControllerID id) {
+  client->OnStarted(id);
+}
+
+void CallOnStartedUsingGpuDecode(VideoCaptureControllerEventHandler* client,
+                                 VideoCaptureControllerID id) {
+  client->OnStartedUsingGpuDecode(id);
+}
+
 }  // anonymous namespace
 
 struct VideoCaptureController::ControllerClient {
   ControllerClient(VideoCaptureControllerID id,
                    VideoCaptureControllerEventHandler* handler,
                    media::VideoCaptureSessionId session_id,
                    const media::VideoCaptureParams& params)
       : controller_id(id),
         event_handler(handler),
         session_id(session_id),
@@ skipping 332 matching lines @@
         const size_t mapped_size =
             media::VideoCaptureFormat(frame_info->coded_size, 0.0f,
                                       frame_info->pixel_format,
                                       frame_info->storage_type)
                 .ImageAllocationSize();
         client->event_handler->OnBufferCreated(
             client->controller_id, buffer_context_iter->CloneHandle(),
             mapped_size, buffer_context_id);
       }
 
-      client->event_handler->OnBufferReady(client->controller_id,
-                                           buffer_context_id, frame_info);
-
       if (!base::ContainsValue(client->buffers_in_use, buffer_context_id))
         client->buffers_in_use.push_back(buffer_context_id);
       else
         NOTREACHED() << "Unexpected duplicate buffer: " << buffer_context_id;
 
       buffer_context_iter->IncreaseConsumerCount();
+      client->event_handler->OnBufferReady(client->controller_id,
+                                           buffer_context_id, frame_info);
     }
     if (buffer_context_iter->HasConsumers()) {
       buffer_context_iter->set_read_permission(
           std::move(buffer_read_permission));
     }
   }
 
   if (!has_received_frames_) {
     UMA_HISTOGRAM_COUNTS("Media.VideoCapture.Width",
                          frame_info->coded_size.width());
@@ skipping 24 matching lines @@
   // because it contains the consumer hold.
   if (!buffer_context_iter->HasConsumers())
     ReleaseBufferContext(buffer_context_iter);
   else
     buffer_context_iter->set_is_retired();
 }
 
 void VideoCaptureController::OnError() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   state_ = VIDEO_CAPTURE_STATE_ERROR;
-
-  for (const auto& client : controller_clients_) {
-    if (client->session_closed)
-      continue;
-    client->event_handler->OnError(client->controller_id);
-  }
+  PerformForClientsWithOpenSession(base::Bind(&CallOnError));
 }
 
 void VideoCaptureController::OnLog(const std::string& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   MediaStreamManager::SendMessageToNativeLog("Video capture: " + message);
 }
 
 void VideoCaptureController::OnStarted() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   state_ = VIDEO_CAPTURE_STATE_STARTED;
+  PerformForClientsWithOpenSession(base::Bind(&CallOnStarted));
+}
 
-  for (const auto& client : controller_clients_) {
-    if (client->session_closed)
-      continue;
-    client->event_handler->OnStarted(client->controller_id);
-  }
+void VideoCaptureController::OnStartedUsingGpuDecode() {
+  PerformForClientsWithOpenSession(base::Bind(&CallOnStartedUsingGpuDecode));
 }
 
 VideoCaptureController::ControllerClient* VideoCaptureController::FindClient(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* handler,
     const ControllerClients& clients) {
   for (const auto& client : clients) {
     if (client->controller_id == id && client->event_handler == handler)
       return client.get();
   }
@@ skipping 54 matching lines @@
                                 buffer_context_iter->buffer_context_id());
     if (entry_iter != std::end(client->known_buffer_context_ids)) {
       client->known_buffer_context_ids.erase(entry_iter);
       client->event_handler->OnBufferDestroyed(
           client->controller_id, buffer_context_iter->buffer_context_id());
     }
   }
   buffer_contexts_.erase(buffer_context_iter);
 }
 
+void VideoCaptureController::PerformForClientsWithOpenSession(
+    EventHandlerAction action) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  for (const auto& client : controller_clients_) {
+    if (client->session_closed)
+      continue;
+    action.Run(client->event_handler, client->controller_id);
+  }
+}
+
 }  // namespace content