Initial implementation of an IPC adapter to expose Chrome IPC to Native Client.

ipc/ipc_message.h

 // Copyright (c) 2012 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 IPC_IPC_MESSAGE_H_
 #define IPC_IPC_MESSAGE_H_
 #pragma once
 
 #include <string>
 
@@ skipping 39 matching lines @@
     // false otherwise.
     virtual bool Send(Message* msg) = 0;
   };
 
   enum PriorityValue {
     PRIORITY_LOW = 1,
     PRIORITY_NORMAL,
     PRIORITY_HIGH
   };
 
+  // Bit values used in the flags field.
+  enum {
+    PRIORITY_MASK     = 0x0003,  // Low 2 bits of store the priority value.
+    SYNC_BIT          = 0x0004,
+    REPLY_BIT         = 0x0008,
+    REPLY_ERROR_BIT   = 0x0010,
+    UNBLOCK_BIT       = 0x0020,
+    PUMPING_MSGS_BIT  = 0x0040,
+    HAS_SENT_TIME_BIT = 0x0080,
+  };
+
   virtual ~Message();
 
   Message();
 
   // Initialize a message with a user-defined type, priority value, and
   // destination WebView ID.
   Message(int32 routing_id, uint32 type, PriorityValue priority);
 
   // 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.
+  void set_sync() {
+    header()->flags |= SYNC_BIT;
+  }
   bool is_sync() const {
     return (header()->flags & SYNC_BIT) != 0;
   }
 
   // Set this on a reply to a synchronous message.
   void set_reply() {
     header()->flags |= REPLY_BIT;
   }
 
   bool is_reply() const {
@@ skipping 36 matching lines @@
   }
 
   int32 routing_id() const {
     return header()->routing;
   }
 
   void set_routing_id(int32 new_id) {
     header()->routing = new_id;
   }
 
+  uint32 flags() const {
+    return header()->flags;
+  }
+
   template<class T, class S>
   static bool Dispatch(const Message* msg, T* obj, S* sender,
                        void (T::*func)()) {
     (obj->*func)();
     return true;
   }
 
   template<class T, class S>
   static bool Dispatch(const Message* msg, T* obj, S* sender,
                        void (T::*func)() const) {
@@ skipping 55 matching lines @@
   LogData* sync_log_data() const { return log_data_; }
   void set_dont_log() const { dont_log_ = true; }
   bool dont_log() const { return dont_log_; }
 #endif
 
  protected:
   friend class Channel;
   friend class MessageReplyDeserializer;
   friend class SyncMessage;
 
-  void set_sync() {
-    header()->flags |= SYNC_BIT;
-  }
-
-  // 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,
-  };
-
 #pragma pack(push, 4)
   struct Header : Pickle::Header {
     int32 routing;  // ID of the view that this message is destined for
     uint32 type;    // specifies the user-defined message type
     uint32 flags;   // specifies control flags for the message
 #if defined(OS_POSIX)
     uint16 num_fds; // the number of descriptors included with this message
     uint16 pad;     // explicitly initialize this to appease valgrind
 #endif
   };
@@ skipping 42 matching lines @@
   MSG_ROUTING_NONE = -2,
 
   // indicates a general message not sent to a particular tab.
   MSG_ROUTING_CONTROL = kint32max,
 };
 
 #define IPC_REPLY_ID 0xFFFFFFF0  // Special message id for replies
 #define IPC_LOGGING_ID 0xFFFFFFF1  // Special message id for logging
 
 #endif  // IPC_IPC_MESSAGE_H_