The Tor Browser: ipc/chromium/src/chrome/common/ipc_message.h@6474c204b198 (annotated)

ipc/chromium/src/chrome/common/ipc_message.h@6474c204b198 (annotated)

ipc/chromium/src/chrome/common/ipc_message.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // Copyright (c) 2006-2008 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 CHROME_COMMON_IPC_MESSAGE_H__
 #define CHROME_COMMON_IPC_MESSAGE_H__
 #include <string>
 #include "base/basictypes.h"
 #include "base/pickle.h"
 #ifdef MOZ_TASK_TRACER
 #include "GeckoTaskTracer.h"
 #endif
 #ifndef NDEBUG
 #define IPC_MESSAGE_LOG_ENABLED
 #endif
 #if defined(OS_POSIX)
 #include "base/ref_counted.h"
 #endif
 namespace base {
 struct FileDescriptor;
 }
 class FileDescriptorSet;
 namespace IPC {
 //------------------------------------------------------------------------------
 class Channel;
 class Message;
 struct LogData;
 class Message : public Pickle {
  public:
   typedef uint32_t msgid_t;
   // Implemented by objects that can send IPC messages across a channel.
   class Sender {
    public:
     virtual ~Sender() {}
     // Sends the given IPC message.  The implementor takes ownership of the
     // given Message regardless of whether or not this method succeeds.  This
     // is done to make this method easier to use.  Returns true on success and
     // false otherwise.
     virtual bool Send(Message* msg) = 0;
   };
   enum PriorityValue {
     PRIORITY_LOW = 1,
     PRIORITY_NORMAL,
     PRIORITY_HIGH
   };
   enum MessageCompression {
     COMPRESSION_NONE,
     COMPRESSION_ENABLED
   };
   virtual ~Message();
   Message();
   // Initialize a message with a user-defined type, priority value, and
   // destination WebView ID.
   Message(int32_t routing_id, msgid_t type, PriorityValue priority,
           MessageCompression compression = COMPRESSION_NONE,
           const char* const name="???");
   // Initializes a message from a const block of data.  The data is not copied;
   // instead the data is merely referenced by this message.  Only const methods
   // should be used on the message when initialized this way.
   Message(const char* data, int data_len);
   Message(const Message& other);
   Message& operator=(const Message& other);
   PriorityValue priority() const {
     return static_cast<PriorityValue>(header()->flags & PRIORITY_MASK);
   }
   // True if this is a synchronous message.
   bool is_sync() const {
     return (header()->flags & SYNC_BIT) != 0;
   }
   // True if this is a synchronous message.
   bool is_interrupt() const {
     return (header()->flags & INTERRUPT_BIT) != 0;
   }
   // True if this is an urgent message.
   bool is_urgent() const {
     return (header()->flags & URGENT_BIT) != 0;
   }
   // True if this is an RPC message.
   bool is_rpc() const {
     return (header()->flags & RPC_BIT) != 0;
   }
   // True if compression is enabled for this message.
   bool compress() const {
     return (header()->flags & COMPRESS_BIT) != 0;
   }
   // Set this on a reply to a synchronous message.
   void set_reply() {
     header()->flags |= REPLY_BIT;
   }
   bool is_reply() const {
     return (header()->flags & REPLY_BIT) != 0;
   }
   // Set this on a reply to a synchronous message to indicate that no receiver
   // was found.
   void set_reply_error() {
     header()->flags |= REPLY_ERROR_BIT;
   }
   bool is_reply_error() const {
     return (header()->flags & REPLY_ERROR_BIT) != 0;
   }
   // Normally when a receiver gets a message and they're blocked on a
   // synchronous message Send, they buffer a message.  Setting this flag causes
   // the receiver to be unblocked and the message to be dispatched immediately.
   void set_unblock(bool unblock) {
     if (unblock) {
       header()->flags |= UNBLOCK_BIT;
     } else {
       header()->flags &= ~UNBLOCK_BIT;
     }
   }
   bool should_unblock() const {
     return (header()->flags & UNBLOCK_BIT) != 0;
   }
   // Tells the receiver that the caller is pumping messages while waiting
   // for the result.
   bool is_caller_pumping_messages() const {
     return (header()->flags & PUMPING_MSGS_BIT) != 0;
   }
   msgid_t type() const {
     return header()->type;
   }
   int32_t routing_id() const {
     return header()->routing;
   }
   void set_routing_id(int32_t new_id) {
     header()->routing = new_id;
   }
   int32_t transaction_id() const {
     return header()->txid;
   }
   void set_transaction_id(int32_t txid) {
     header()->txid = txid;
   }
   uint32_t interrupt_remote_stack_depth_guess() const {
     return header()->interrupt_remote_stack_depth_guess;
   }
   void set_interrupt_remote_stack_depth_guess(uint32_t depth) {
     DCHECK(is_interrupt());
     header()->interrupt_remote_stack_depth_guess = depth;
   }
   uint32_t interrupt_local_stack_depth() const {
     return header()->interrupt_local_stack_depth;
   }
   void set_interrupt_local_stack_depth(uint32_t depth) {
     DCHECK(is_interrupt());
     header()->interrupt_local_stack_depth = depth;
   }
   int32_t seqno() const {
     return header()->seqno;
   }
   void set_seqno(int32_t seqno) {
     header()->seqno = seqno;
   }
   const char* const name() const {
     return name_;
   }
   void set_name(const char* const name) {
     name_ = name;
   }
   template<class T>
   static bool Dispatch(const Message* msg, T* obj, void (T::*func)()) {
     (obj->*func)();
     return true;
   }
   template<class T>
   static bool Dispatch(const Message* msg, T* obj, void (T::*func)() const) {
     (obj->*func)();
     return true;
   }
   template<class T>
   static bool Dispatch(const Message* msg, T* obj,
                        void (T::*func)(const Message&)) {
     (obj->*func)(*msg);
     return true;
   }
   template<class T>
   static bool Dispatch(const Message* msg, T* obj,
                        void (T::*func)(const Message&) const) {
     (obj->*func)(*msg);
     return true;
   }
   // Used for async messages with no parameters.
   static void Log(const Message* msg, std::wstring* l) {
   }
   // Find the end of the message data that starts at range_start.  Returns NULL
   // if the entire message is not found in the given data range.
   static const char* FindNext(const char* range_start, const char* range_end) {
     return Pickle::FindNext(sizeof(Header), range_start, range_end);
   }
 #if defined(OS_POSIX)
   // On POSIX, a message supports reading / writing FileDescriptor objects.
   // This is used to pass a file descriptor to the peer of an IPC channel.
   // Add a descriptor to the end of the set. Returns false iff the set is full.
   bool WriteFileDescriptor(const base::FileDescriptor& descriptor);
   // Get a file descriptor from the message. Returns false on error.
   //   iter: a Pickle iterator to the current location in the message.
   bool ReadFileDescriptor(void** iter, base::FileDescriptor* descriptor) const;
 #if defined(OS_MACOSX)
   void set_fd_cookie(uint32_t cookie) {
     header()->cookie = cookie;
   }
   uint32_t fd_cookie() const {
     return header()->cookie;
   }
 #endif
 #endif
 #ifdef IPC_MESSAGE_LOG_ENABLED
   // Adds the outgoing time from Time::Now() at the end of the message and sets
   // a bit to indicate that it's been added.
   void set_sent_time(int64_t time);
   int64_t sent_time() const;
   void set_received_time(int64_t time) const;
   int64_t received_time() const { return received_time_; }
   void set_output_params(const std::wstring& op) const { output_params_ = op; }
   const std::wstring& output_params() const { return output_params_; }
   // The following four functions are needed so we can log sync messages with
   // delayed replies.  We stick the log data from the sent message into the
   // reply message, so that when it's sent and we have the output parameters
   // we can log it.  As such, we set a flag on the sent message to not log it.
   void set_sync_log_data(LogData* data) const { log_data_ = data; }
   LogData* sync_log_data() const { return log_data_; }
   void set_dont_log() const { dont_log_ = true; }
   bool dont_log() const { return dont_log_; }
 #endif
   friend class Channel;
   friend class MessageReplyDeserializer;
   friend class SyncMessage;
   void set_sync() {
     header()->flags |= SYNC_BIT;
   }
   void set_interrupt() {
     header()->flags |= INTERRUPT_BIT;
   }
   void set_urgent() {
     header()->flags |= URGENT_BIT;
   }
   void set_rpc() {
     header()->flags |= RPC_BIT;
   }
 #if !defined(OS_MACOSX)
  protected:
 #endif
   // flags
   enum {
     PRIORITY_MASK   = 0x0003,
     SYNC_BIT        = 0x0004,
     REPLY_BIT       = 0x0008,
     REPLY_ERROR_BIT = 0x0010,
     UNBLOCK_BIT     = 0x0020,
     PUMPING_MSGS_BIT= 0x0040,
     HAS_SENT_TIME_BIT = 0x0080,
     INTERRUPT_BIT   = 0x0100,
     COMPRESS_BIT    = 0x0200,
     URGENT_BIT      = 0x0400,
     RPC_BIT         = 0x0800
   };
   struct Header : Pickle::Header {
     int32_t routing;  // ID of the view that this message is destined for
     msgid_t type;   // specifies the user-defined message type
     uint32_t flags;   // specifies control flags for the message
 #if defined(OS_POSIX)
     uint32_t num_fds; // the number of descriptors included with this message
 # if defined(OS_MACOSX)
     uint32_t cookie;  // cookie to ACK that the descriptors have been read.
 # endif
 #endif
     union {
       // For Interrupt messages, a guess at what the *other* side's stack depth is.
       uint32_t interrupt_remote_stack_depth_guess;
       // For RPC and Urgent messages, a transaction ID for message ordering.
       int32_t txid;
     };
     // The actual local stack depth.
     uint32_t interrupt_local_stack_depth;
     // Sequence number
     int32_t seqno;
 #ifdef MOZ_TASK_TRACER
     uint64_t source_event_id;
     uint64_t parent_task_id;
     mozilla::tasktracer::SourceEventType source_event_type;
 #endif
   };
   Header* header() {
     return headerT<Header>();
   }
   const Header* header() const {
     return headerT<Header>();
   }
   void InitLoggingVariables(const char* const name="???");
 #if defined(OS_POSIX)
   // The set of file descriptors associated with this message.
   scoped_refptr<FileDescriptorSet> file_descriptor_set_;
   // Ensure that a FileDescriptorSet is allocated
   void EnsureFileDescriptorSet();
   FileDescriptorSet* file_descriptor_set() {
     EnsureFileDescriptorSet();
     return file_descriptor_set_.get();
   }
   const FileDescriptorSet* file_descriptor_set() const {
     return file_descriptor_set_.get();
   }
 #endif
   const char* name_;
 #ifdef IPC_MESSAGE_LOG_ENABLED
   // Used for logging.
   mutable int64_t received_time_;
   mutable std::wstring output_params_;
   mutable LogData* log_data_;
   mutable bool dont_log_;
 #endif
 };
 //------------------------------------------------------------------------------
 }  // namespace IPC
 enum SpecialRoutingIDs {
   // indicates that we don't have a routing ID yet.
   MSG_ROUTING_NONE = kint32min,
   // indicates a general message not sent to a particular tab.
   MSG_ROUTING_CONTROL = kint32max
 };
 #define IPC_REPLY_ID 0xFFF0  // Special message id for replies
 #define IPC_LOGGING_ID 0xFFF1  // Special message id for logging
 #endif  // CHROME_COMMON_IPC_MESSAGE_H__

The Tor Browser / annotate

ipc/chromium/src/chrome/common/ipc_message.h@6474c204b198 (annotated)

ipc/chromium/src/chrome/common/ipc_message.h