Mojo: Add NotifyBadMessage API

mojo/edk/system/node_channel.h

 // 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.
 
 #ifndef MOJO_EDK_SYSTEM_NODE_CHANNEL_H_
 #define MOJO_EDK_SYSTEM_NODE_CHANNEL_H_
 
 #include <queue>
 #include <unordered_map>
 #include <utility>
 
+#include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/process/process_handle.h"
 #include "base/synchronization/lock.h"
 #include "base/task_runner.h"
 #include "build/build_config.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/ports/name.h"
@@ skipping 39 matching lines @@
     virtual void OnRequestIntroduction(const ports::NodeName& from_node,
                                        const ports::NodeName& name) = 0;
     virtual void OnIntroduce(const ports::NodeName& from_node,
                              const ports::NodeName& name,
                              ScopedPlatformHandle channel_handle) = 0;
 #if defined(OS_WIN) || (defined(OS_MACOSX) && !defined(OS_IOS))
     virtual void OnRelayPortsMessage(const ports::NodeName& from_node,
                                      base::ProcessHandle from_process,
                                      const ports::NodeName& destination,
                                      Channel::MessagePtr message) = 0;
+    virtual void OnPortsMessageFromRelay(const ports::NodeName& from_node,
+                                         const ports::NodeName& source_node,
+                                         Channel::MessagePtr message) = 0;
 #endif
 
     virtual void OnChannelError(const ports::NodeName& node) = 0;
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
     virtual MachPortRelay* GetMachPortRelay() = 0;
 #endif
   };
 
   static scoped_refptr<NodeChannel> Create(
       Delegate* delegate,
       ScopedPlatformHandle platform_handle,
-      scoped_refptr<base::TaskRunner> io_task_runner);
+      scoped_refptr<base::TaskRunner> io_task_runner,
+      const base::Closure& bad_message_callback);
 
   static Channel::MessagePtr CreatePortsMessage(size_t payload_size,
                                                 void** payload,
                                                 size_t num_handles);
 
   static void GetPortsMessageData(Channel::Message* message, void** data,
                                   size_t* num_data_bytes);
 
   // Start receiving messages.
   void Start();
 
   // Permanently stop the channel from sending or receiving messages.
   void ShutDown();
 
+  // Invokes the bad message callback for this channel, if any.
+  void NotifyBadMessage();
+
   void SetRemoteProcessHandle(base::ProcessHandle process_handle);
   bool HasRemoteProcessHandle();
   // Note: The returned |ProcessHandle| is owned by the caller and should be
   // freed if necessary.
   base::ProcessHandle CopyRemoteProcessHandle();
 
   // Used for context in Delegate calls (via |from_node| arguments.)
   void SetRemoteNodeName(const ports::NodeName& name);
 
   void AcceptChild(const ports::NodeName& parent_name,
@@ skipping 13 matching lines @@
   void Introduce(const ports::NodeName& name,
                  ScopedPlatformHandle channel_handle);
 
 #if defined(OS_WIN) || (defined(OS_MACOSX) && !defined(OS_IOS))
   // Relay the message to the specified node via this channel.  This is used to
   // pass windows handles between two processes that do not have permission to
   // duplicate handles into the other's address space. The relay process is
   // assumed to have that permission.
   void RelayPortsMessage(const ports::NodeName& destination,
                          Channel::MessagePtr message);
+
+  // Sends a message to its destination from a relay. This is interpreted by the
+  // receiver similarly to PortsMessage, but the original source node is
+  // provided as additional message metadata from the (trusted) relay node.
+  void PortsMessageFromRelay(const ports::NodeName& source,
+                             Channel::MessagePtr message);
 #endif
 
  private:
   friend class base::RefCountedThreadSafe<NodeChannel>;
 
   using PendingMessageQueue = std::queue<Channel::MessagePtr>;
   using PendingRelayMessageQueue =
       std::queue<std::pair<ports::NodeName, Channel::MessagePtr>>;
 
   NodeChannel(Delegate* delegate,
               ScopedPlatformHandle platform_handle,
-              scoped_refptr<base::TaskRunner> io_task_runner);
+              scoped_refptr<base::TaskRunner> io_task_runner,
+              const base::Closure& bad_message_callback);
   ~NodeChannel() override;
 
   // Channel::Delegate:
   void OnChannelMessage(const void* payload,
                         size_t payload_size,
                         ScopedPlatformHandleVectorPtr handles) override;
   void OnChannelError() override;
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   // MachPortRelay::Observer:
   void OnProcessReady(base::ProcessHandle process) override;
 
   void ProcessPendingMessagesWithMachPorts();
 #endif
 
   void WriteChannelMessage(Channel::MessagePtr message);
 
   Delegate* const delegate_;
   const scoped_refptr<base::TaskRunner> io_task_runner_;
+  const base::Closure bad_message_callback_;
 
   base::Lock channel_lock_;
   scoped_refptr<Channel> channel_;
 
   // Must only be accessed from |io_task_runner_|'s thread.
   ports::NodeName remote_node_name_;
 
   base::Lock remote_process_handle_lock_;
   base::ProcessHandle remote_process_handle_ = base::kNullProcessHandle;
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   base::Lock pending_mach_messages_lock_;
   PendingMessageQueue pending_write_messages_;
   PendingRelayMessageQueue pending_relay_messages_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(NodeChannel);
 };
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_NODE_CHANNEL_H_