Mojo: Report bindings validation errors via MojoNotifyBadMessage

mojo/public/cpp/bindings/lib/multiplex_router.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/lib/multiplex_router.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 93 matching lines @@
   }
 
   // ---------------------------------------------------------------------------
   // The following public methods (i.e., InterfaceEndpointController
   // implementation) are called by the client on the same thread as the
   // AttachClient() call. They are called outside of the router's lock.
 
   bool SendMessage(Message* message) override {
     DCHECK(task_runner_->BelongsToCurrentThread());
     message->set_interface_id(id_);
-    return router_->connector_.Accept(message);
+
+    return router_->connector_.Accept(message).Succeeded();
   }
 
   void AllowWokenUpBySyncWatchOnSameThread() override {
     DCHECK(task_runner_->BelongsToCurrentThread());
 
     EnsureSyncWatcherExists();
     sync_watcher_->AllowWokenUpBySyncWatchOnSameThread();
   }
 
   bool SyncWatch(const bool* should_stop) override {
@@ skipping 298 matching lines @@
 
   DCHECK(IsValidInterfaceId(id));
 
   base::AutoLock locker(lock_);
   DCHECK(ContainsKey(endpoints_, id));
 
   InterfaceEndpoint* endpoint = endpoints_[id].get();
   endpoint->DetachClient();
 }
 
-void MultiplexRouter::RaiseError() {
+void MultiplexRouter::RaiseError(Result error) {
   if (task_runner_->BelongsToCurrentThread()) {
-    connector_.RaiseError();
+    connector_.RaiseError(std::move(error));
   } else {
     task_runner_->PostTask(FROM_HERE,
-                           base::Bind(&MultiplexRouter::RaiseError, this));
+                           base::Bind(&MultiplexRouter::RaiseError, this,
+                                      base::Passed(&error)));
   }
 }
 
 std::unique_ptr<AssociatedGroup> MultiplexRouter::CreateAssociatedGroup() {
   std::unique_ptr<AssociatedGroup> group(new AssociatedGroup);
   group->router_ = this;
   return group;
 }
 
 // static
@@ skipping 15 matching lines @@
   base::AutoLock locker(lock_);
 
   if (endpoints_.size() > 1)
     return true;
   if (endpoints_.size() == 0)
     return false;
 
   return !ContainsKey(endpoints_, kMasterInterfaceId);
 }
 
+void MultiplexRouter::SetMasterInterfaceName(const std::string& name) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  control_message_handler_.set_interface_name(name);
+  header_validator_.set_debug_info(name + " master interface header validator");
+}
+
 void MultiplexRouter::EnableTestingMode() {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock locker(lock_);
 
   testing_mode_ = true;
   connector_.set_enforce_errors_from_incoming_receiver(false);
 }
 
-bool MultiplexRouter::Accept(Message* message) {
+MessageReceiver::Result MultiplexRouter::Accept(Message* message) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scoped_refptr<MultiplexRouter> protector(this);
   base::AutoLock locker(lock_);
 
   ClientCallBehavior client_call_behavior =
       connector_.during_sync_handle_watcher_callback()
           ? ALLOW_DIRECT_CLIENT_CALLS_FOR_SYNC_MESSAGES
           : ALLOW_DIRECT_CLIENT_CALLS;
 
@@ skipping 14 matching lines @@
       if (iter != endpoints_.end())
         iter->second->SignalSyncMessageEvent();
     }
   } else if (!tasks_.empty()) {
     // Processing the message may result in new tasks (for error notification)
     // being added to the queue. In this case, we have to attempt to process the
     // tasks.
     ProcessTasks(client_call_behavior, connector_.task_runner());
   }
 
-  // Always return true. If we see errors during message processing, we will
+  // Always succeed. If we see errors during message processing, we will
   // explicitly call Connector::RaiseError() to disconnect the message pipe.
-  return true;
+  return Result::ForSuccess();
 }
 
 bool MultiplexRouter::OnPeerAssociatedEndpointClosed(InterfaceId id) {
   lock_.AssertAcquired();
 
   if (IsMasterInterfaceId(id))
     return false;
 
   InterfaceEndpoint* endpoint = FindOrInsertEndpoint(id, nullptr);
 
@@ skipping 169 matching lines @@
   DCHECK(!current_task_runner || current_task_runner->BelongsToCurrentThread());
   lock_.AssertAcquired();
 
   if (!message) {
     // This is a sync message and has been processed during sync handle
     // watching.
     return true;
   }
 
   if (PipeControlMessageHandler::IsPipeControlMessage(message)) {
-    if (!control_message_handler_.Accept(message))
-      RaiseErrorInNonTestingMode();
+    Result result = control_message_handler_.Accept(message);
+    if (!result.Succeeded())
+      RaiseErrorInNonTestingMode(std::move(result));
     return true;
   }
 
   InterfaceId id = message->interface_id();
   DCHECK(IsValidInterfaceId(id));
 
   bool inserted = false;
   InterfaceEndpoint* endpoint = FindOrInsertEndpoint(id, &inserted);
   if (inserted) {
     // Currently, it is legitimate to receive messages for an endpoint
@@ skipping 35 matching lines @@
   }
 
   if (!can_direct_call) {
     MaybePostToProcessTasks(endpoint->task_runner());
     return false;
   }
 
   DCHECK(endpoint->task_runner()->BelongsToCurrentThread());
 
   InterfaceEndpointClient* client = endpoint->client();
-  bool result = false;
+  Result result(Result::Type::UNKNOWN_ERROR);
   {
     // We must unlock before calling into |client| because it may call this
     // object within HandleIncomingMessage(). Holding the lock will lead to
     // deadlock.
     //
     // It is safe to call into |client| without the lock. Because |client| is
     // always accessed on the same thread, including DetachEndpointClient().
     base::AutoUnlock unlocker(lock_);
     result = client->HandleIncomingMessage(message);
   }
-  if (!result)
-    RaiseErrorInNonTestingMode();
+  if (!result.Succeeded())
+    RaiseErrorInNonTestingMode(std::move(result));
 
   return true;
 }
 
 void MultiplexRouter::MaybePostToProcessTasks(
     base::SingleThreadTaskRunner* task_runner) {
   lock_.AssertAcquired();
   if (posted_to_process_tasks_)
     return;
 
@@ skipping 24 matching lines @@
       endpoint->set_peer_closed();
       // If the interface endpoint is performing a sync watch, this makes sure
       // it is notified and eventually exits the sync watch.
       endpoint->SignalSyncMessageEvent();
       break;
   }
   if (endpoint->closed() && endpoint->peer_closed())
     endpoints_.erase(endpoint->id());
 }
 
-void MultiplexRouter::RaiseErrorInNonTestingMode() {
+void MultiplexRouter::RaiseErrorInNonTestingMode(Result error) {
   lock_.AssertAcquired();
   if (!testing_mode_)
-    RaiseError();
+    RaiseError(std::move(error));
 }
 
 MultiplexRouter::InterfaceEndpoint* MultiplexRouter::FindOrInsertEndpoint(
     InterfaceId id,
     bool* inserted) {
   lock_.AssertAcquired();
   // Either |inserted| is nullptr or it points to a boolean initialized as
   // false.
   DCHECK(!inserted || !*inserted);
 
   auto iter = endpoints_.find(id);
   InterfaceEndpoint* endpoint;
   if (iter == endpoints_.end()) {
     endpoint = new InterfaceEndpoint(this, id);
     endpoints_[id] = endpoint;
     if (inserted)
       *inserted = true;
   } else {
     endpoint = iter->second.get();
   }
 
   return endpoint;
 }
 
 }  // namespace internal
 }  // namespace mojo