Support custom message filtering on Mojo binding objects

mojo/public/cpp/bindings/lib/interface_endpoint_client.cc

 // Copyright 2015 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/public/cpp/bindings/interface_endpoint_client.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 114 matching lines @@
 bool InterfaceEndpointClient::HandleIncomingMessageThunk::Accept(
     Message* message) {
   return owner_->HandleValidatedMessage(message);
 }
 
 // ----------------------------------------------------------------------------
 
 InterfaceEndpointClient::InterfaceEndpointClient(
     ScopedInterfaceEndpointHandle handle,
     MessageReceiverWithResponderStatus* receiver,
-    std::unique_ptr<MessageFilter> payload_validator,
+    std::unique_ptr<MessageReceiver> payload_validator,
     bool expect_sync_requests,
     scoped_refptr<base::SingleThreadTaskRunner> runner)
     : handle_(std::move(handle)),
       incoming_receiver_(receiver),
-      payload_validator_(std::move(payload_validator)),
       thunk_(this),
+      filters_(&thunk_),
       next_request_id_(1),
       encountered_error_(false),
       task_runner_(std::move(runner)),
       weak_ptr_factory_(this) {
   DCHECK(handle_.is_valid());
   DCHECK(handle_.is_local());
 
   // TODO(yzshen): the way to use validator (or message filter in general)
   // directly is a little awkward.
-  payload_validator_->set_sink(&thunk_);
+  filters_.Append(std::move(payload_validator));
 
   controller_ = handle_.group_controller()->AttachEndpointClient(
       handle_, this, task_runner_);
   if (expect_sync_requests)
     controller_->AllowWokenUpBySyncWatchOnSameThread();
 }
 
 InterfaceEndpointClient::~InterfaceEndpointClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 18 matching lines @@
 
   if (!handle_.is_valid())
     return ScopedInterfaceEndpointHandle();
 
   controller_ = nullptr;
   handle_.group_controller()->DetachEndpointClient(handle_);
 
   return std::move(handle_);
 }
 
+void InterfaceEndpointClient::AddFilter(
+    std::unique_ptr<MessageReceiver> filter) {
+  filters_.Append(std::move(filter));
+}
+
 void InterfaceEndpointClient::RaiseError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   handle_.group_controller()->RaiseError();
 }
 
 bool InterfaceEndpointClient::Accept(Message* message) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(controller_);
   DCHECK(!message->has_flag(Message::kFlagExpectsResponse));
@@ skipping 49 matching lines @@
       ignore_result(sync_responder->Accept(&iter->second->response));
     sync_responses_.erase(iter);
   }
 
   // Return true means that we take ownership of |responder|.
   return true;
 }
 
 bool InterfaceEndpointClient::HandleIncomingMessage(Message* message) {
   DCHECK(thread_checker_.CalledOnValidThread());
-
-  return payload_validator_->Accept(message);
+  return filters_.Accept(message);
 }
 
 void InterfaceEndpointClient::NotifyError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (encountered_error_)
     return;
   encountered_error_ = true;
 
   // The callbacks may hold on to resources. There is no need to keep them any
@@ skipping 38 matching lines @@
     return responder->Accept(message);
   } else {
     if (!incoming_receiver_)
       return false;
 
     return incoming_receiver_->Accept(message);
   }
 }
 
 }  // namespace mojo