[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 453 matching lines @@
 void VideoCaptureController::OnStarted() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   for (const auto& client : controller_clients_) {
     if (client->session_closed)
       continue;
     client->event_handler->OnStarted(client->controller_id);
   }
 }
 
+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,
     const ControllerClients& clients) {
   for (const auto& client : clients) {
     if (client->controller_id == id && client->event_handler == handler)
       return client.get();
   }
   return nullptr;
 }
@@ skipping 53 matching lines @@
     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);
 }
 
 }  // namespace content