Mojo: Make room for remotely-allocated channel endpoint IDs.

R=brettw@chromium.org

Review URL: https://codereview.chromium.org/647553004

Cr-Commit-Position: refs/heads/master@{#299043}

mojo/edk/system/channel_endpoint_id.cc

@@ -4,12 +4,20 @@
 
 #include "mojo/edk/system/channel_endpoint_id.h"
 
+#include "base/compiler_specific.h"
+
 namespace mojo {
 namespace system {
 
+STATIC_CONST_MEMBER_DEFINITION const uint32_t
+    ChannelEndpointId::kRemotelyAllocatedFlag;
+STATIC_CONST_MEMBER_DEFINITION const uint32_t
+    ChannelEndpointId::kLocallyAllocatedMask;
+
 ChannelEndpointId LocalChannelEndpointIdGenerator::GetNext() {
   ChannelEndpointId rv = next_channel_endpoint_id_;
-  next_channel_endpoint_id_.value_++;
+  next_channel_endpoint_id_.value_ = (next_channel_endpoint_id_.value_ + 1) &
+                                     ChannelEndpointId::kLocallyAllocatedMask;
   // Skip over the invalid value, in case we wrap.
   if (!next_channel_endpoint_id_.is_valid())
     next_channel_endpoint_id_.value_++;

mojo/edk/system/channel_endpoint_id.h

@@ -26,6 +26,12 @@ FORWARD_DECLARE_TEST(LocalChannelEndpointIdGeneratorTest, WrapAround);
 
 // Represents an ID for an endpoint (i.e., one side of a message pipe) on a
 // |Channel|. This class must be POD.
+//
+// Note: The terminology "remotely allocated ID" is for destination IDs with
+// respect to the receiver. I.e., a destination ID in a message is remotely
+// allocated if the ID was allocated by the sender (i.e., the remote side with
+// respect to the receiver). Conversely, a source ID is remotely allocated if it
+// was allocated by the receiver.
 class MOJO_SYSTEM_IMPL_EXPORT ChannelEndpointId {
  public:
   ChannelEndpointId() : value_(0) {}
@@ -51,6 +57,9 @@ class MOJO_SYSTEM_IMPL_EXPORT ChannelEndpointId {
   }
 
   bool is_valid() const { return !!value_; }
+  bool is_remotely_allocated() const {
+    return !!(value_ & kRemotelyAllocatedFlag);
+  }
   uint32_t value() const { return value_; }
 
  private:
@@ -59,6 +68,9 @@ class MOJO_SYSTEM_IMPL_EXPORT ChannelEndpointId {
 
   uint32_t value_;
 
+  static const uint32_t kRemotelyAllocatedFlag = 0x80000000u;
+  static const uint32_t kLocallyAllocatedMask = ~kRemotelyAllocatedFlag;
+
   // Copying and assignment allowed.
 };
 // This wrapper should add no overhead.

mojo/edk/system/channel_endpoint_id_unittest.cc

@@ -30,6 +30,9 @@ TEST(ChannelEndpointIdTest, Basic) {
   EXPECT_FALSE(invalid.is_valid());
   EXPECT_TRUE(bootstrap.is_valid());
 
+  EXPECT_FALSE(invalid.is_remotely_allocated());
+  EXPECT_FALSE(bootstrap.is_remotely_allocated());
+
   // Test assignment.
   ChannelEndpointId copy;
   copy = bootstrap;
@@ -86,14 +89,17 @@ TEST(LocalChannelEndpointIdGeneratorTest, Basic) {
 // it needs to be friended.
 TEST(LocalChannelEndpointIdGeneratorTest, WrapAround) {
   LocalChannelEndpointIdGenerator gen;
-  gen.next_channel_endpoint_id_.value_ = static_cast<uint32_t>(-1);
+  gen.next_channel_endpoint_id_.value_ =
+      ChannelEndpointId::kRemotelyAllocatedFlag - 1;
 
   ChannelEndpointId id = gen.GetNext();
   EXPECT_TRUE(id.is_valid());
-  EXPECT_EQ(static_cast<uint32_t>(-1), id.value());
+  EXPECT_FALSE(id.is_remotely_allocated());
+  EXPECT_EQ(ChannelEndpointId::kRemotelyAllocatedFlag - 1, id.value());
 
   id = gen.GetNext();
   EXPECT_TRUE(id.is_valid());
+  EXPECT_FALSE(id.is_remotely_allocated());
   EXPECT_EQ(1u, id.value());
 }