Remove use of std::function from Mojo internals

mojo/edk/system/ports/node.cc

 // Copyright 2016 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 "mojo/edk/system/ports/node.h"
 
 #include <string.h>
 
 #include <utility>
 
@@ skipping 245 matching lines @@
 
   if (port->state != Port::kReceiving)
     return ERROR_PORT_STATE_UNEXPECTED;
 
   port_status->has_messages = port->message_queue.HasNextMessage();
   port_status->receiving_messages = CanAcceptMoreMessages(port);
   port_status->peer_closed = port->peer_closed;
   return OK;
 }
 
-int Node::GetMessage(const PortRef& port_ref, ScopedMessage* message) {
-  return GetMessageIf(port_ref, nullptr, message);
-}
-
-int Node::GetMessageIf(const PortRef& port_ref,
-                       std::function<bool(const Message&)> selector,
-                       ScopedMessage* message) {
+int Node::GetMessage(const PortRef& port_ref,
+                     ScopedMessage* message,
+                     MessageFilter* filter) {
   *message = nullptr;
 
-  DVLOG(4) << "GetMessageIf for " << port_ref.name() << "@" << name_;
+  DVLOG(4) << "GetMessage for " << port_ref.name() << "@" << name_;
 
   Port* port = port_ref.port();
   {
     base::AutoLock lock(port->lock);
 
     // This could also be treated like the port being unknown since the
     // embedder should no longer be referring to a port that has been sent.
     if (port->state != Port::kReceiving)
       return ERROR_PORT_STATE_UNEXPECTED;
 
     // Let the embedder get messages until there are no more before reporting
     // that the peer closed its end.
     if (!CanAcceptMoreMessages(port))
       return ERROR_PORT_PEER_CLOSED;
 
-    port->message_queue.GetNextMessageIf(std::move(selector), message);
+    port->message_queue.GetNextMessage(message, filter);
   }
 
   // Allow referenced ports to trigger PortStatusChanged calls.
   if (*message) {
     for (size_t i = 0; i < (*message)->num_ports(); ++i) {
       const PortName& new_port_name = (*message)->ports()[i];
       scoped_refptr<Port> new_port = GetPort(new_port_name);
 
       DCHECK(new_port) << "Port " << new_port_name << "@" << name_
                        << " does not exist!";
@@ skipping 685 matching lines @@
   port->peer_port_name = port_descriptor.peer_port_name;
   port->last_sequence_num_to_receive =
       port_descriptor.last_sequence_num_to_receive;
   port->peer_closed = port_descriptor.peer_closed;
 
   DVLOG(2) << "Accepting port " << port_name << " [peer_closed="
            << port->peer_closed << "; last_sequence_num_to_receive="
            << port->last_sequence_num_to_receive << "]";
 
   // A newly accepted port is not signalable until the message referencing the
-  // new port finds its way to the consumer (see GetMessageIf).
+  // new port finds its way to the consumer (see GetMessage).
   port->message_queue.set_signalable(false);
 
   int rv = AddPortWithName(port_name, port);
   if (rv != OK)
     return rv;
 
   // Allow referring port to forward messages.
   delegate_->ForwardMessage(
       port_descriptor.referring_node_name,
       NewInternalMessage(port_descriptor.referring_port_name,
@@ skipping 161 matching lines @@
   return OK;
 }
 
 int Node::ForwardMessages_Locked(const LockedPort& port,
                                  const PortName &port_name) {
   ports_lock_.AssertAcquired();
   port->lock.AssertAcquired();
 
   for (;;) {
     ScopedMessage message;
-    port->message_queue.GetNextMessageIf(nullptr, &message);
+    port->message_queue.GetNextMessage(&message, nullptr);
     if (!message)
       break;
 
     int rv = WillSendMessage_Locked(LockedPort(port), port_name, message.get());
     if (rv != OK)
       return rv;
 
     delegate_->ForwardMessage(port->peer_node_name, std::move(message));
   }
   return OK;
@@ skipping 186 matching lines @@
 
   if (num_data_bytes)
     memcpy(header + 1, data, num_data_bytes);
 
   return message;
 }
 
 }  // namespace ports
 }  // namespace edk
 }  // namespace mojo