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

content/browser/renderer_host/media/video_capture_controller.cc

Index: content/browser/renderer_host/media/video_capture_controller.cc
diff --git a/content/browser/renderer_host/media/video_capture_controller.cc b/content/browser/renderer_host/media/video_capture_controller.cc
index ec20aa05f04d15f662c7042b303989a8dfc64d4c..0eae4e752e772e9a0683e2744b0a1589f77056a1 100644
--- a/content/browser/renderer_host/media/video_capture_controller.cc
+++ b/content/browser/renderer_host/media/video_capture_controller.cc
@@ -471,6 +471,15 @@ void VideoCaptureController::OnStarted() {
   }
 }
 
+void VideoCaptureController::OnStartedUsingGpuDecode() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  for (const auto& client : controller_clients_) {
+    if (client->session_closed)
+      continue;
+    client->event_handler->OnStartedUsingGpuDecode(client->controller_id);
+  }
+}

[mcasas, 2017/03/08 01:33:17]

This code looks a lot like l.452-455 and l.467-470 (and
perhaps others), but I don't see an easy way to generalize
it since functions cannot have function templates.

template <typename F>
void NotifyEventHandlerIfSessionOpen(F handler) {
  DCHECK_CURRENTLY_ON(BrowserThread::IO);
  for (const auto& client : controller_clients_) {
    if (client->session_closed)
      continue;
    handler(client->controller_id);
  }
}

called e.g. like
NotifyEventHandlerIfSessionOpen(client->event_handler->OnStartedUsingGpuDecode);
probably won't compile as-is :S

Not sure if this is better or worse, after writing it :-)

[chfremer, 2017/03/08 18:58:08]

Without saying anything about whether or not it is worth it, I see two C++ ways
of doing what you want (not counting anything that would involve pre-processor
macros). A template approach would probably look as follows:

template <typename Action>
void VideoCaptureController::PerformForClientsWithOpenSession() {
  DCHECK_CURRENTLY_ON(BrowserThread::IO);
  for (const auto& client : controller_clients_) {
    if (client->session_closed)
      continue;
    Action::Perform(client->event_handler, client->controller_id);
  }
}

struct CallOnStartedAction {
  static void Perform(VideoCaptureControllerEventHandler* client,
                      VideoCaptureControllerID id) {
    client->OnStarted(id);
  }
};

void VideoCaptureController::OnStarted() {
  PerformForClientsWithOpenSession<CallOnStartedAction>();
}

However, the same could be achieved by passing the "actions" as runtime
parameters:

using EventHandlerAction =
    base::Callback<void(VideoCaptureControllerEventHandler* client,
                        VideoCaptureControllerID id)>;

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);
  }
}

void CallOnStarted(VideoCaptureControllerEventHandler* client,
                 VideoCaptureControllerID id) {
  client->OnStarted(id);
}

void VideoCaptureController::OnStarted() {
  PerformForClientsWithOpenSession(base::Bind(&CallOnStarted));
}

As a variation, we could use lambdas instead of file-scope functions such as
CallOnStarted().
I went with the second version in the latest patch set.

+
 VideoCaptureController::ControllerClient* VideoCaptureController::FindClient(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* handler,