diff --git a/net/dcsctp/packet/chunk/data_common.h b/net/dcsctp/packet/chunk/data_common.h
index b67efeee1e..66d67bac3d 100644
--- a/net/dcsctp/packet/chunk/data_common.h
+++ b/net/dcsctp/packet/chunk/data_common.h
@@ -48,7 +48,7 @@ class AnyDataChunk : public Chunk {
 
   StreamID stream_id() const { return data_.stream_id; }
   SSN ssn() const { return data_.ssn; }
-  MID message_id() const { return data_.message_id; }
+  MID mid() const { return data_.mid; }
   FSN fsn() const { return data_.fsn; }
   PPID ppid() const { return data_.ppid; }
   rtc::ArrayView<const uint8_t> payload() const { return data_.payload; }
@@ -59,7 +59,7 @@ class AnyDataChunk : public Chunk {
   AnyDataChunk(TSN tsn,
                StreamID stream_id,
                SSN ssn,
-               MID message_id,
+               MID mid,
                FSN fsn,
                PPID ppid,
                std::vector<uint8_t> payload,
@@ -67,7 +67,7 @@ class AnyDataChunk : public Chunk {
       : tsn_(tsn),
         data_(stream_id,
               ssn,
-              message_id,
+              mid,
               fsn,
               ppid,
               std::move(payload),
diff --git a/net/dcsctp/packet/chunk/forward_tsn_common.h b/net/dcsctp/packet/chunk/forward_tsn_common.h
index 37bd2aafff..b9dddd2cbf 100644
--- a/net/dcsctp/packet/chunk/forward_tsn_common.h
+++ b/net/dcsctp/packet/chunk/forward_tsn_common.h
@@ -24,12 +24,9 @@ class AnyForwardTsnChunk : public Chunk {
  public:
   struct SkippedStream {
     SkippedStream(StreamID stream_id, SSN ssn)
-        : stream_id(stream_id), ssn(ssn), unordered(false), message_id(0) {}
-    SkippedStream(IsUnordered unordered, StreamID stream_id, MID message_id)
-        : stream_id(stream_id),
-          ssn(0),
-          unordered(unordered),
-          message_id(message_id) {}
+        : stream_id(stream_id), ssn(ssn), unordered(false), mid(0) {}
+    SkippedStream(IsUnordered unordered, StreamID stream_id, MID mid)
+        : stream_id(stream_id), ssn(0), unordered(unordered), mid(mid) {}
 
     StreamID stream_id;
 
@@ -38,11 +35,11 @@ class AnyForwardTsnChunk : public Chunk {
 
     // Set for I-FORWARD_TSN
     IsUnordered unordered;
-    MID message_id;
+    MID mid;
 
     bool operator==(const SkippedStream& other) const {
       return stream_id == other.stream_id && ssn == other.ssn &&
-             unordered == other.unordered && message_id == other.message_id;
+             unordered == other.unordered && mid == other.mid;
     }
   };
 
diff --git a/net/dcsctp/packet/chunk/idata_chunk.cc b/net/dcsctp/packet/chunk/idata_chunk.cc
index 9f19c7f053..e9a777dfdc 100644
--- a/net/dcsctp/packet/chunk/idata_chunk.cc
+++ b/net/dcsctp/packet/chunk/idata_chunk.cc
@@ -54,7 +54,7 @@ absl::optional<IDataChunk> IDataChunk::Parse(
   uint8_t flags = reader->Load8<1>();
   TSN tsn(reader->Load32<4>());
   StreamID stream_identifier(reader->Load16<8>());
-  MID message_id(reader->Load32<12>());
+  MID mid(reader->Load32<12>());
   uint32_t ppid_or_fsn = reader->Load32<16>();
 
   Options options;
@@ -65,7 +65,7 @@ absl::optional<IDataChunk> IDataChunk::Parse(
   options.immediate_ack =
       ImmediateAckFlag((flags & (1 << kFlagsBitImmediateAck)) != 0);
 
-  return IDataChunk(tsn, stream_identifier, message_id,
+  return IDataChunk(tsn, stream_identifier, mid,
                     PPID(options.is_beginning ? ppid_or_fsn : 0),
                     FSN(options.is_beginning ? 0 : ppid_or_fsn),
                     std::vector<uint8_t>(reader->variable_data().begin(),
@@ -83,7 +83,7 @@ void IDataChunk::SerializeTo(std::vector<uint8_t>& out) const {
       (*options().immediate_ack ? (1 << kFlagsBitImmediateAck) : 0));
   writer.Store32<4>(*tsn());
   writer.Store16<8>(*stream_id());
-  writer.Store32<12>(*message_id());
+  writer.Store32<12>(*mid());
   writer.Store32<16>(options().is_beginning ? *ppid() : *fsn());
   writer.CopyToVariableData(payload());
 }
@@ -97,7 +97,7 @@ std::string IDataChunk::ToString() const {
          : *options().is_end                          ? "last"
                                                       : "middle")
      << ", tsn=" << *tsn() << ", stream_id=" << *stream_id()
-     << ", message_id=" << *message_id();
+     << ", mid=" << *mid();
 
   if (*options().is_beginning) {
     sb << ", ppid=" << *ppid();
diff --git a/net/dcsctp/packet/chunk/idata_chunk.h b/net/dcsctp/packet/chunk/idata_chunk.h
index 8cdf2a1fc4..36b7e7eaab 100644
--- a/net/dcsctp/packet/chunk/idata_chunk.h
+++ b/net/dcsctp/packet/chunk/idata_chunk.h
@@ -42,7 +42,7 @@ class IDataChunk : public AnyDataChunk, public TLVTrait<IDataChunkConfig> {
   static constexpr size_t kHeaderSize = IDataChunkConfig::kHeaderSize;
   IDataChunk(TSN tsn,
              StreamID stream_id,
-             MID message_id,
+             MID mid,
              PPID ppid,
              FSN fsn,
              std::vector<uint8_t> payload,
@@ -50,7 +50,7 @@ class IDataChunk : public AnyDataChunk, public TLVTrait<IDataChunkConfig> {
       : AnyDataChunk(tsn,
                      stream_id,
                      SSN(0),
-                     message_id,
+                     mid,
                      fsn,
                      ppid,
                      std::move(payload),
diff --git a/net/dcsctp/packet/chunk/idata_chunk_test.cc b/net/dcsctp/packet/chunk/idata_chunk_test.cc
index fea492d71e..d1cc0d8f90 100644
--- a/net/dcsctp/packet/chunk/idata_chunk_test.cc
+++ b/net/dcsctp/packet/chunk/idata_chunk_test.cc
@@ -44,7 +44,7 @@ TEST(IDataChunkTest, AtBeginningFromCapture) {
   ASSERT_HAS_VALUE_AND_ASSIGN(IDataChunk chunk, IDataChunk::Parse(data));
   EXPECT_EQ(*chunk.tsn(), 2487901653);
   EXPECT_EQ(*chunk.stream_id(), 1);
-  EXPECT_EQ(*chunk.message_id(), 0u);
+  EXPECT_EQ(*chunk.mid(), 0u);
   EXPECT_EQ(*chunk.ppid(), 53u);
   EXPECT_EQ(*chunk.fsn(), 0u);  // Not provided (so set to zero)
 }
@@ -62,13 +62,13 @@ TEST(IDataChunkTest, AtBeginningSerializeAndDeserialize) {
                               IDataChunk::Parse(serialized));
   EXPECT_EQ(*deserialized.tsn(), 123u);
   EXPECT_EQ(*deserialized.stream_id(), 456u);
-  EXPECT_EQ(*deserialized.message_id(), 789u);
+  EXPECT_EQ(*deserialized.mid(), 789u);
   EXPECT_EQ(*deserialized.ppid(), 53u);
   EXPECT_EQ(*deserialized.fsn(), 0u);
 
   EXPECT_EQ(deserialized.ToString(),
             "I-DATA, type=ordered::first, tsn=123, stream_id=456, "
-            "message_id=789, ppid=53, length=1");
+            "mid=789, ppid=53, length=1");
 }
 
 TEST(IDataChunkTest, InMiddleFromCapture) {
@@ -93,7 +93,7 @@ TEST(IDataChunkTest, InMiddleFromCapture) {
   ASSERT_HAS_VALUE_AND_ASSIGN(IDataChunk chunk, IDataChunk::Parse(data));
   EXPECT_EQ(*chunk.tsn(), 2487901706);
   EXPECT_EQ(*chunk.stream_id(), 3u);
-  EXPECT_EQ(*chunk.message_id(), 1u);
+  EXPECT_EQ(*chunk.mid(), 1u);
   EXPECT_EQ(*chunk.ppid(), 0u);  // Not provided (so set to zero)
   EXPECT_EQ(*chunk.fsn(), 8u);
 }
@@ -109,14 +109,14 @@ TEST(IDataChunkTest, InMiddleSerializeAndDeserialize) {
                               IDataChunk::Parse(serialized));
   EXPECT_EQ(*deserialized.tsn(), 123u);
   EXPECT_EQ(*deserialized.stream_id(), 456u);
-  EXPECT_EQ(*deserialized.message_id(), 789u);
+  EXPECT_EQ(*deserialized.mid(), 789u);
   EXPECT_EQ(*deserialized.ppid(), 0u);
   EXPECT_EQ(*deserialized.fsn(), 101112u);
   EXPECT_THAT(deserialized.payload(), ElementsAre(1, 2, 3));
 
   EXPECT_EQ(deserialized.ToString(),
             "I-DATA, type=ordered::middle, tsn=123, stream_id=456, "
-            "message_id=789, fsn=101112, length=3");
+            "mid=789, fsn=101112, length=3");
 }
 
 }  // namespace
diff --git a/net/dcsctp/packet/chunk/iforward_tsn_chunk.cc b/net/dcsctp/packet/chunk/iforward_tsn_chunk.cc
index a647a8bf8a..2b8e9c917a 100644
--- a/net/dcsctp/packet/chunk/iforward_tsn_chunk.cc
+++ b/net/dcsctp/packet/chunk/iforward_tsn_chunk.cc
@@ -68,8 +68,8 @@ absl::optional<IForwardTsnChunk> IForwardTsnChunk::Parse(
 
     StreamID stream_id(sub_reader.Load16<0>());
     IsUnordered unordered(sub_reader.Load8<3>() & 0x01);
-    MID message_id(sub_reader.Load32<4>());
-    skipped_streams.emplace_back(unordered, stream_id, message_id);
+    MID mid(sub_reader.Load32<4>());
+    skipped_streams.emplace_back(unordered, stream_id, mid);
     offset += kSkippedStreamBufferSize;
   }
   RTC_DCHECK(offset == reader->variable_data_size());
@@ -89,7 +89,7 @@ void IForwardTsnChunk::SerializeTo(std::vector<uint8_t>& out) const {
 
     sub_writer.Store16<0>(*skipped[i].stream_id);
     sub_writer.Store8<3>(skipped[i].unordered ? 1 : 0);
-    sub_writer.Store32<4>(*skipped[i].message_id);
+    sub_writer.Store32<4>(*skipped[i].mid);
     offset += kSkippedStreamBufferSize;
   }
   RTC_DCHECK(offset == variable_size);
diff --git a/net/dcsctp/packet/data.h b/net/dcsctp/packet/data.h
index c1754ed59a..08174dc052 100644
--- a/net/dcsctp/packet/data.h
+++ b/net/dcsctp/packet/data.h
@@ -42,7 +42,7 @@ struct Data {
 
   Data(StreamID stream_id,
        SSN ssn,
-       MID message_id,
+       MID mid,
        FSN fsn,
        PPID ppid,
        std::vector<uint8_t> payload,
@@ -51,7 +51,7 @@ struct Data {
        IsUnordered is_unordered)
       : stream_id(stream_id),
         ssn(ssn),
-        message_id(message_id),
+        mid(mid),
         fsn(fsn),
         ppid(ppid),
         payload(std::move(payload)),
@@ -65,8 +65,8 @@ struct Data {
 
   // Creates a copy of this `Data` object.
   Data Clone() const {
-    return Data(stream_id, ssn, message_id, fsn, ppid, payload, is_beginning,
-                is_end, is_unordered);
+    return Data(stream_id, ssn, mid, fsn, ppid, payload, is_beginning, is_end,
+                is_unordered);
   }
 
   // The size of this data, which translates to the size of its payload.
@@ -82,7 +82,7 @@ struct Data {
   // Message Identifier (MID) per stream and ordered/unordered. Defined by
   // RFC8260, and used together with options.is_unordered and stream_id to
   // uniquely identify a message. Used only in I-DATA chunks (not DATA).
-  MID message_id;
+  MID mid;
   // Fragment Sequence Number (FSN) per stream and ordered/unordered, as above.
   FSN fsn;
 
diff --git a/net/dcsctp/rx/interleaved_reassembly_streams.cc b/net/dcsctp/rx/interleaved_reassembly_streams.cc
index 8b316de676..9dc2e43a23 100644
--- a/net/dcsctp/rx/interleaved_reassembly_streams.cc
+++ b/net/dcsctp/rx/interleaved_reassembly_streams.cc
@@ -106,8 +106,8 @@ size_t InterleavedReassemblyStreams::Stream::AssembleMessage(
   return payload_size;
 }
 
-size_t InterleavedReassemblyStreams::Stream::EraseTo(MID message_id) {
-  UnwrappedMID unwrapped_mid = mid_unwrapper_.Unwrap(message_id);
+size_t InterleavedReassemblyStreams::Stream::EraseTo(MID mid) {
+  UnwrappedMID unwrapped_mid = mid_unwrapper_.Unwrap(mid);
 
   size_t removed_bytes = 0;
   auto it = chunks_by_mid_.begin();
@@ -135,7 +135,7 @@ int InterleavedReassemblyStreams::Stream::Add(UnwrappedTSN tsn, Data data) {
   RTC_DCHECK_EQ(*data.is_unordered, *stream_id_.unordered);
   RTC_DCHECK_EQ(*data.stream_id, *stream_id_.stream_id);
   int queued_bytes = data.size();
-  UnwrappedMID mid = mid_unwrapper_.Unwrap(data.message_id);
+  UnwrappedMID mid = mid_unwrapper_.Unwrap(data.mid);
   FSN fsn = data.fsn;
   auto [unused, inserted] =
       chunks_by_mid_[mid].emplace(fsn, std::make_pair(tsn, std::move(data)));
@@ -208,7 +208,7 @@ size_t InterleavedReassemblyStreams::HandleForwardTsn(
   for (const auto& skipped : skipped_streams) {
     removed_bytes +=
         GetOrCreateStream(FullStreamId(skipped.unordered, skipped.stream_id))
-            .EraseTo(skipped.message_id);
+            .EraseTo(skipped.mid);
   }
   return removed_bytes;
 }
diff --git a/net/dcsctp/rx/interleaved_reassembly_streams.h b/net/dcsctp/rx/interleaved_reassembly_streams.h
index 605cf42b93..a6faadd302 100644
--- a/net/dcsctp/rx/interleaved_reassembly_streams.h
+++ b/net/dcsctp/rx/interleaved_reassembly_streams.h
@@ -67,7 +67,7 @@ class InterleavedReassemblyStreams : public ReassemblyStreams {
           parent_(*parent),
           next_mid_(mid_unwrapper_.Unwrap(next_mid)) {}
     int Add(UnwrappedTSN tsn, Data data);
-    size_t EraseTo(MID message_id);
+    size_t EraseTo(MID mid);
     void Reset() {
       mid_unwrapper_.Reset();
       next_mid_ = mid_unwrapper_.Unwrap(MID(0));
diff --git a/net/dcsctp/rx/reassembly_queue.cc b/net/dcsctp/rx/reassembly_queue.cc
index b5ab087f68..0b0d8e7f80 100644
--- a/net/dcsctp/rx/reassembly_queue.cc
+++ b/net/dcsctp/rx/reassembly_queue.cc
@@ -70,8 +70,8 @@ ReassemblyQueue::ReassemblyQueue(absl::string_view log_prefix,
 void ReassemblyQueue::Add(TSN tsn, Data data) {
   RTC_DCHECK(IsConsistent());
   RTC_DLOG(LS_VERBOSE) << log_prefix_ << "added tsn=" << *tsn
-                       << ", stream=" << *data.stream_id << ":"
-                       << *data.message_id << ":" << *data.fsn << ", type="
+                       << ", stream=" << *data.stream_id << ":" << *data.mid
+                       << ":" << *data.fsn << ", type="
                        << (data.is_beginning && data.is_end ? "complete"
                            : data.is_beginning              ? "first"
                            : data.is_end                    ? "last"
diff --git a/net/dcsctp/rx/reassembly_queue_test.cc b/net/dcsctp/rx/reassembly_queue_test.cc
index d7b9c1d821..0cd26954a5 100644
--- a/net/dcsctp/rx/reassembly_queue_test.cc
+++ b/net/dcsctp/rx/reassembly_queue_test.cc
@@ -281,9 +281,9 @@ TEST_F(ReassemblyQueueTest, NotReadyForHandoverWhenDeliveredTsnsHaveGap) {
 TEST_F(ReassemblyQueueTest, NotReadyForHandoverWhenResetStreamIsDeferred) {
   ReassemblyQueue reasm("log: ", TSN(10), kBufferSize);
   DataGeneratorOptions opts;
-  opts.message_id = MID(0);
+  opts.mid = MID(0);
   reasm.Add(TSN(10), gen_.Ordered({1, 2, 3, 4}, "BE", opts));
-  opts.message_id = MID(1);
+  opts.mid = MID(1);
   reasm.Add(TSN(11), gen_.Ordered({1, 2, 3, 4}, "BE", opts));
   EXPECT_THAT(reasm.FlushMessages(), SizeIs(2));
 
@@ -295,12 +295,12 @@ TEST_F(ReassemblyQueueTest, NotReadyForHandoverWhenResetStreamIsDeferred) {
             HandoverReadinessStatus().Add(
                 HandoverUnreadinessReason::kStreamResetDeferred));
 
-  opts.message_id = MID(3);
+  opts.mid = MID(3);
   opts.ppid = PPID(3);
   reasm.Add(TSN(13), gen_.Ordered({1, 2, 3, 4}, "BE", opts));
   reasm.MaybeResetStreamsDeferred(TSN(11));
 
-  opts.message_id = MID(2);
+  opts.mid = MID(2);
   opts.ppid = PPID(2);
   reasm.Add(TSN(13), gen_.Ordered({1, 2, 3, 4}, "BE", opts));
   reasm.MaybeResetStreamsDeferred(TSN(15));
diff --git a/net/dcsctp/socket/stream_reset_handler_test.cc b/net/dcsctp/socket/stream_reset_handler_test.cc
index 503cc89094..991f182101 100644
--- a/net/dcsctp/socket/stream_reset_handler_test.cc
+++ b/net/dcsctp/socket/stream_reset_handler_test.cc
@@ -290,10 +290,10 @@ TEST_F(StreamResetHandlerTest, ResetStreamsNotDeferred) {
 
 TEST_F(StreamResetHandlerTest, ResetStreamsDeferred) {
   DataGeneratorOptions opts;
-  opts.message_id = MID(0);
+  opts.mid = MID(0);
   reasm_->Add(kPeerInitialTsn, gen_.Ordered({1, 2, 3, 4}, "BE", opts));
 
-  opts.message_id = MID(1);
+  opts.mid = MID(1);
   reasm_->Add(AddTo(kPeerInitialTsn, 1),
               gen_.Ordered({1, 2, 3, 4}, "BE", opts));
 
@@ -314,25 +314,25 @@ TEST_F(StreamResetHandlerTest, ResetStreamsDeferred) {
   EXPECT_THAT(responses, SizeIs(1));
   EXPECT_EQ(responses[0].result(), ResponseResult::kInProgress);
 
-  opts.message_id = MID(1);
+  opts.mid = MID(1);
   opts.ppid = PPID(5);
   reasm_->Add(AddTo(kPeerInitialTsn, 5),
               gen_.Ordered({1, 2, 3, 4}, "BE", opts));
   reasm_->MaybeResetStreamsDeferred(AddTo(kPeerInitialTsn, 1));
 
-  opts.message_id = MID(0);
+  opts.mid = MID(0);
   opts.ppid = PPID(4);
   reasm_->Add(AddTo(kPeerInitialTsn, 4),
               gen_.Ordered({1, 2, 3, 4}, "BE", opts));
   reasm_->MaybeResetStreamsDeferred(AddTo(kPeerInitialTsn, 1));
 
-  opts.message_id = MID(3);
+  opts.mid = MID(3);
   opts.ppid = PPID(3);
   reasm_->Add(AddTo(kPeerInitialTsn, 3),
               gen_.Ordered({1, 2, 3, 4}, "BE", opts));
   reasm_->MaybeResetStreamsDeferred(AddTo(kPeerInitialTsn, 1));
 
-  opts.message_id = MID(2);
+  opts.mid = MID(2);
   opts.ppid = PPID(2);
   reasm_->Add(AddTo(kPeerInitialTsn, 2),
               gen_.Ordered({1, 2, 3, 4}, "BE", opts));
@@ -765,7 +765,7 @@ TEST_F(StreamResetHandlerTest, PerformCloseAfterOneFirstFailing) {
 
   // Let the socket receive the TSN.
   DataGeneratorOptions opts;
-  opts.message_id = MID(0);
+  opts.mid = MID(0);
   reasm_->Add(kPeerInitialTsn, gen_.Ordered({1, 2, 3, 4}, "BE", opts));
   reasm_->MaybeResetStreamsDeferred(kPeerInitialTsn);
   data_tracker_->Observe(kPeerInitialTsn);
diff --git a/net/dcsctp/testing/data_generator.cc b/net/dcsctp/testing/data_generator.cc
index e4f9f91384..417695c9d0 100644
--- a/net/dcsctp/testing/data_generator.cc
+++ b/net/dcsctp/testing/data_generator.cc
@@ -32,13 +32,13 @@ Data DataGenerator::Ordered(std::vector<uint8_t> payload,
   } else {
     fsn_ = FSN(*fsn_ + 1);
   }
-  MID message_id = opts.message_id.value_or(message_id_);
-  Data ret = Data(opts.stream_id, SSN(static_cast<uint16_t>(*message_id)),
-                  message_id, fsn_, opts.ppid, std::move(payload), is_beginning,
-                  is_end, IsUnordered(false));
+  MID mid = opts.mid.value_or(mid_);
+  Data ret = Data(opts.stream_id, SSN(static_cast<uint16_t>(*mid)), mid, fsn_,
+                  opts.ppid, std::move(payload), is_beginning, is_end,
+                  IsUnordered(false));
 
   if (is_end) {
-    message_id_ = MID(*message_id + 1);
+    mid_ = MID(*mid + 1);
   }
   return ret;
 }
@@ -54,11 +54,11 @@ Data DataGenerator::Unordered(std::vector<uint8_t> payload,
   } else {
     fsn_ = FSN(*fsn_ + 1);
   }
-  MID message_id = opts.message_id.value_or(message_id_);
-  Data ret = Data(opts.stream_id, SSN(0), message_id, fsn_, kPpid,
-                  std::move(payload), is_beginning, is_end, IsUnordered(true));
+  MID mid = opts.mid.value_or(mid_);
+  Data ret = Data(opts.stream_id, SSN(0), mid, fsn_, kPpid, std::move(payload),
+                  is_beginning, is_end, IsUnordered(true));
   if (is_end) {
-    message_id_ = MID(*message_id + 1);
+    mid_ = MID(*mid + 1);
   }
   return ret;
 }
diff --git a/net/dcsctp/testing/data_generator.h b/net/dcsctp/testing/data_generator.h
index f917c740a7..52f98dd1cb 100644
--- a/net/dcsctp/testing/data_generator.h
+++ b/net/dcsctp/testing/data_generator.h
@@ -23,15 +23,14 @@ namespace dcsctp {
 
 struct DataGeneratorOptions {
   StreamID stream_id = StreamID(1);
-  absl::optional<MID> message_id = absl::nullopt;
+  absl::optional<MID> mid = absl::nullopt;
   PPID ppid = PPID(53);
 };
 
 // Generates Data with correct sequence numbers, and used only in unit tests.
 class DataGenerator {
  public:
-  explicit DataGenerator(MID start_message_id = MID(0))
-      : message_id_(start_message_id) {}
+  explicit DataGenerator(MID start_mid = MID(0)) : mid_(start_mid) {}
 
   // Generates ordered "data" with the provided `payload` and flags, which can
   // contain "B" for setting the "is_beginning" flag, and/or "E" for setting the
@@ -48,10 +47,10 @@ class DataGenerator {
                  DataGeneratorOptions opts = {});
 
   // Resets the Message ID identifier - simulating a "stream reset".
-  void ResetStream() { message_id_ = MID(0); }
+  void ResetStream() { mid_ = MID(0); }
 
  private:
-  MID message_id_;
+  MID mid_;
   FSN fsn_ = FSN(0);
 };
 }  // namespace dcsctp
diff --git a/net/dcsctp/tx/mock_send_queue.h b/net/dcsctp/tx/mock_send_queue.h
index 0c8f5d141d..d551885799 100644
--- a/net/dcsctp/tx/mock_send_queue.h
+++ b/net/dcsctp/tx/mock_send_queue.h
@@ -34,7 +34,7 @@ class MockSendQueue : public SendQueue {
               (override));
   MOCK_METHOD(bool,
               Discard,
-              (IsUnordered unordered, StreamID stream_id, MID message_id),
+              (IsUnordered unordered, StreamID stream_id, MID mid),
               (override));
   MOCK_METHOD(void, PrepareResetStream, (StreamID stream_id), (override));
   MOCK_METHOD(bool, HasStreamsReadyToBeReset, (), (const, override));
diff --git a/net/dcsctp/tx/outstanding_data.cc b/net/dcsctp/tx/outstanding_data.cc
index c65c195432..6d18625f6f 100644
--- a/net/dcsctp/tx/outstanding_data.cc
+++ b/net/dcsctp/tx/outstanding_data.cc
@@ -261,7 +261,7 @@ bool OutstandingData::NackItem(UnwrappedTSN tsn,
 void OutstandingData::AbandonAllFor(const Item& item) {
   // Erase all remaining chunks from the producer, if any.
   if (discard_from_send_queue_(item.data().is_unordered, item.data().stream_id,
-                               item.data().message_id)) {
+                               item.data().mid)) {
     // There were remaining chunks to be produced for this message. Since the
     // receiver may have already received all chunks (up till now) for this
     // message, we can't just FORWARD-TSN to the last fragment in this
@@ -272,10 +272,10 @@ void OutstandingData::AbandonAllFor(const Item& item) {
     // TSN in the sent FORWARD-TSN.
     UnwrappedTSN tsn = next_tsn_;
     next_tsn_.Increment();
-    Data message_end(item.data().stream_id, item.data().ssn,
-                     item.data().message_id, item.data().fsn, item.data().ppid,
-                     std::vector<uint8_t>(), Data::IsBeginning(false),
-                     Data::IsEnd(true), item.data().is_unordered);
+    Data message_end(item.data().stream_id, item.data().ssn, item.data().mid,
+                     item.data().fsn, item.data().ppid, std::vector<uint8_t>(),
+                     Data::IsBeginning(false), Data::IsEnd(true),
+                     item.data().is_unordered);
     Item& added_item =
         outstanding_data_
             .emplace(std::piecewise_construct, std::forward_as_tuple(tsn),
@@ -295,7 +295,7 @@ void OutstandingData::AbandonAllFor(const Item& item) {
     if (!other.is_abandoned() &&
         other.data().stream_id == item.data().stream_id &&
         other.data().is_unordered == item.data().is_unordered &&
-        other.data().message_id == item.data().message_id) {
+        other.data().mid == item.data().mid) {
       RTC_DLOG(LS_VERBOSE) << "Marking chunk " << *tsn.Wrap()
                            << " as abandoned";
       if (other.should_be_retransmitted()) {
@@ -378,7 +378,7 @@ void OutstandingData::ExpireOutstandingChunks(TimeMs now) {
       // Already abandoned.
     } else if (item.is_nacked() && item.has_expired(now)) {
       RTC_DLOG(LS_VERBOSE) << "Marking nacked chunk " << *tsn.Wrap()
-                           << " and message " << *item.data().message_id
+                           << " and message " << *item.data().mid
                            << " as expired";
       AbandonAllFor(item);
     } else {
@@ -419,7 +419,7 @@ absl::optional<UnwrappedTSN> OutstandingData::Insert(
     // queue.
     RTC_DLOG(LS_VERBOSE) << "Marking freshly produced chunk "
                          << *it->first.Wrap() << " and message "
-                         << *it->second.data().message_id << " as expired";
+                         << *it->second.data().mid << " as expired";
     AbandonAllFor(it->second);
     RTC_DCHECK(IsConsistent());
     return absl::nullopt;
@@ -522,15 +522,15 @@ IForwardTsnChunk OutstandingData::CreateIForwardTsn() const {
     std::pair<IsUnordered, StreamID> stream_id =
         std::make_pair(item.data().is_unordered, item.data().stream_id);
 
-    if (item.data().message_id > skipped_per_stream[stream_id]) {
-      skipped_per_stream[stream_id] = item.data().message_id;
+    if (item.data().mid > skipped_per_stream[stream_id]) {
+      skipped_per_stream[stream_id] = item.data().mid;
     }
   }
 
   std::vector<IForwardTsnChunk::SkippedStream> skipped_streams;
   skipped_streams.reserve(skipped_per_stream.size());
-  for (const auto& [stream, message_id] : skipped_per_stream) {
-    skipped_streams.emplace_back(stream.first, stream.second, message_id);
+  for (const auto& [stream, mid] : skipped_per_stream) {
+    skipped_streams.emplace_back(stream.first, stream.second, mid);
   }
 
   return IForwardTsnChunk(new_cumulative_ack.Wrap(),
diff --git a/net/dcsctp/tx/retransmission_queue.cc b/net/dcsctp/tx/retransmission_queue.cc
index 4cc0b64074..e2b28b1d81 100644
--- a/net/dcsctp/tx/retransmission_queue.cc
+++ b/net/dcsctp/tx/retransmission_queue.cc
@@ -86,8 +86,8 @@ RetransmissionQueue::RetransmissionQueue(
           data_chunk_header_size_,
           tsn_unwrapper_.Unwrap(my_initial_tsn),
           tsn_unwrapper_.Unwrap(TSN(*my_initial_tsn - 1)),
-          [this](IsUnordered unordered, StreamID stream_id, MID message_id) {
-            return send_queue_.Discard(unordered, stream_id, message_id);
+          [this](IsUnordered unordered, StreamID stream_id, MID mid) {
+            return send_queue_.Discard(unordered, stream_id, mid);
           }) {}
 
 bool RetransmissionQueue::IsConsistent() const {
diff --git a/net/dcsctp/tx/retransmission_queue_test.cc b/net/dcsctp/tx/retransmission_queue_test.cc
index e62c030bfa..88de0b54f0 100644
--- a/net/dcsctp/tx/retransmission_queue_test.cc
+++ b/net/dcsctp/tx/retransmission_queue_test.cc
@@ -1067,7 +1067,7 @@ TEST_F(RetransmissionQueueTest, ExpireFromSendQueueWhenPartiallySent) {
   RetransmissionQueue queue = CreateQueue();
   DataGeneratorOptions options;
   options.stream_id = StreamID(17);
-  options.message_id = MID(42);
+  options.mid = MID(42);
   TimeMs test_start = now_;
   EXPECT_CALL(producer_, Produce)
       .WillOnce([&](TimeMs, size_t) {
diff --git a/net/dcsctp/tx/rr_send_queue.cc b/net/dcsctp/tx/rr_send_queue.cc
index 4df253dddf..4212d3e0de 100644
--- a/net/dcsctp/tx/rr_send_queue.cc
+++ b/net/dcsctp/tx/rr_send_queue.cc
@@ -143,7 +143,7 @@ absl::optional<SendQueue::DataToSend> RRSendQueue::OutgoingStream::Produce(
     DcSctpMessage& message = item.message;
 
     // Allocate Message ID and SSN when the first fragment is sent.
-    if (!item.message_id.has_value()) {
+    if (!item.mid.has_value()) {
       // Oops, this entire message has already expired. Try the next one.
       if (item.attributes.expires_at <= now) {
         HandleMessageExpired(item);
@@ -153,7 +153,7 @@ absl::optional<SendQueue::DataToSend> RRSendQueue::OutgoingStream::Produce(
 
       MID& mid =
           item.attributes.unordered ? next_unordered_mid_ : next_ordered_mid_;
-      item.message_id = mid;
+      item.mid = mid;
       mid = MID(*mid + 1);
     }
     if (!item.attributes.unordered && !item.ssn.has_value()) {
@@ -184,10 +184,9 @@ absl::optional<SendQueue::DataToSend> RRSendQueue::OutgoingStream::Produce(
     buffered_amount_.Decrease(payload.size());
     parent_.total_buffered_amount_.Decrease(payload.size());
 
-    SendQueue::DataToSend chunk(Data(stream_id, item.ssn.value_or(SSN(0)),
-                                     item.message_id.value(), fsn, ppid,
-                                     std::move(payload), is_beginning, is_end,
-                                     item.attributes.unordered));
+    SendQueue::DataToSend chunk(Data(
+        stream_id, item.ssn.value_or(SSN(0)), item.mid.value(), fsn, ppid,
+        std::move(payload), is_beginning, is_end, item.attributes.unordered));
     chunk.max_retransmissions = item.attributes.max_retransmissions;
     chunk.expires_at = item.attributes.expires_at;
     chunk.lifecycle_id =
@@ -231,13 +230,12 @@ void RRSendQueue::OutgoingStream::HandleMessageExpired(
   }
 }
 
-bool RRSendQueue::OutgoingStream::Discard(IsUnordered unordered,
-                                          MID message_id) {
+bool RRSendQueue::OutgoingStream::Discard(IsUnordered unordered, MID mid) {
   bool result = false;
   if (!items_.empty()) {
     Item& item = items_.front();
-    if (item.attributes.unordered == unordered && item.message_id.has_value() &&
-        *item.message_id == message_id) {
+    if (item.attributes.unordered == unordered && item.mid.has_value() &&
+        *item.mid == mid) {
       HandleMessageExpired(item);
       items_.pop_front();
 
@@ -329,7 +327,7 @@ void RRSendQueue::OutgoingStream::Reset() {
                                             item.remaining_size);
     item.remaining_offset = 0;
     item.remaining_size = item.message.payload().size();
-    item.message_id = absl::nullopt;
+    item.mid = absl::nullopt;
     item.ssn = absl::nullopt;
     item.current_fsn = FSN(0);
     if (old_pause_state == PauseState::kPaused ||
@@ -344,7 +342,7 @@ bool RRSendQueue::OutgoingStream::has_partially_sent_message() const {
   if (items_.empty()) {
     return false;
   }
-  return items_.front().message_id.has_value();
+  return items_.front().mid.has_value();
 }
 
 void RRSendQueue::Add(TimeMs now,
@@ -386,11 +384,8 @@ absl::optional<SendQueue::DataToSend> RRSendQueue::Produce(TimeMs now,
   return scheduler_.Produce(now, max_size);
 }
 
-bool RRSendQueue::Discard(IsUnordered unordered,
-                          StreamID stream_id,
-                          MID message_id) {
-  bool has_discarded =
-      GetOrCreateStreamInfo(stream_id).Discard(unordered, message_id);
+bool RRSendQueue::Discard(IsUnordered unordered, StreamID stream_id, MID mid) {
+  bool has_discarded = GetOrCreateStreamInfo(stream_id).Discard(unordered, mid);
 
   RTC_DCHECK(IsConsistent());
   return has_discarded;
diff --git a/net/dcsctp/tx/rr_send_queue.h b/net/dcsctp/tx/rr_send_queue.h
index c4111ff717..e30fbe5105 100644
--- a/net/dcsctp/tx/rr_send_queue.h
+++ b/net/dcsctp/tx/rr_send_queue.h
@@ -76,9 +76,7 @@ class RRSendQueue : public SendQueue {
 
   // Implementation of `SendQueue`.
   absl::optional<DataToSend> Produce(TimeMs now, size_t max_size) override;
-  bool Discard(IsUnordered unordered,
-               StreamID stream_id,
-               MID message_id) override;
+  bool Discard(IsUnordered unordered, StreamID stream_id, MID mid) override;
   void PrepareResetStream(StreamID streams) override;
   bool HasStreamsReadyToBeReset() const override;
   std::vector<StreamID> GetStreamsReadyToBeReset() override;
@@ -163,7 +161,7 @@ class RRSendQueue : public SendQueue {
     ThresholdWatcher& buffered_amount() { return buffered_amount_; }
 
     // Discards a partially sent message, see `SendQueue::Discard`.
-    bool Discard(IsUnordered unordered, MID message_id);
+    bool Discard(IsUnordered unordered, MID mid);
 
     // Pauses this stream, which is used before resetting it.
     void Pause();
@@ -232,7 +230,7 @@ class RRSendQueue : public SendQueue {
       size_t remaining_size;
       // If set, an allocated Message ID and SSN. Will be allocated when the
       // first fragment is sent.
-      absl::optional<MID> message_id = absl::nullopt;
+      absl::optional<MID> mid = absl::nullopt;
       absl::optional<SSN> ssn = absl::nullopt;
       // The current Fragment Sequence Number, incremented for each fragment.
       FSN current_fsn = FSN(0);
diff --git a/net/dcsctp/tx/rr_send_queue_test.cc b/net/dcsctp/tx/rr_send_queue_test.cc
index 95416b193a..1684ffda49 100644
--- a/net/dcsctp/tx/rr_send_queue_test.cc
+++ b/net/dcsctp/tx/rr_send_queue_test.cc
@@ -228,7 +228,7 @@ TEST_F(RRSendQueueTest, DiscardPartialPackets) {
   EXPECT_FALSE(chunk_one->data.is_end);
   EXPECT_EQ(chunk_one->data.stream_id, kStreamID);
   buf_.Discard(IsUnordered(false), chunk_one->data.stream_id,
-               chunk_one->data.message_id);
+               chunk_one->data.mid);
 
   absl::optional<SendQueue::DataToSend> chunk_two =
       buf_.Produce(kNow, kOneFragmentPacketSize);
@@ -245,7 +245,7 @@ TEST_F(RRSendQueueTest, DiscardPartialPackets) {
 
   // Calling it again shouldn't cause issues.
   buf_.Discard(IsUnordered(false), chunk_one->data.stream_id,
-               chunk_one->data.message_id);
+               chunk_one->data.mid);
   ASSERT_FALSE(buf_.Produce(kNow, kOneFragmentPacketSize));
 }
 
@@ -860,7 +860,7 @@ TEST_F(RRSendQueueTest, WillSendLifecycleExpireWhenDiscardingExplicitly) {
                                                     /*maybe_delivered=*/false));
   EXPECT_CALL(callbacks_, OnLifecycleEnd(LifecycleId(1)));
   buf_.Discard(IsUnordered(false), chunk_one->data.stream_id,
-               chunk_one->data.message_id);
+               chunk_one->data.mid);
 }
 }  // namespace
 }  // namespace dcsctp
diff --git a/net/dcsctp/tx/send_queue.h b/net/dcsctp/tx/send_queue.h
index 0b96e9041a..c969917913 100644
--- a/net/dcsctp/tx/send_queue.h
+++ b/net/dcsctp/tx/send_queue.h
@@ -54,7 +54,7 @@ class SendQueue {
   virtual absl::optional<DataToSend> Produce(TimeMs now, size_t max_size) = 0;
 
   // Discards a partially sent message identified by the parameters `unordered`,
-  // `stream_id` and `message_id`. The `message_id` comes from the returned
+  // `stream_id` and `mid`. The `mid` comes from the returned
   // information when having called `Produce`. A partially sent message means
   // that it has had at least one fragment of it returned when `Produce` was
   // called prior to calling this method).
@@ -67,9 +67,7 @@ class SendQueue {
   //
   // This function returns true if this message had unsent fragments still in
   // the queue that were discarded, and false if there were no such fragments.
-  virtual bool Discard(IsUnordered unordered,
-                       StreamID stream_id,
-                       MID message_id) = 0;
+  virtual bool Discard(IsUnordered unordered, StreamID stream_id, MID mid) = 0;
 
   // Prepares the stream to be reset. This is used to close a WebRTC data
   // channel and will be signaled to the other side.
diff --git a/net/dcsctp/tx/stream_scheduler_test.cc b/net/dcsctp/tx/stream_scheduler_test.cc
index 20833371c1..e55272b16b 100644
--- a/net/dcsctp/tx/stream_scheduler_test.cc
+++ b/net/dcsctp/tx/stream_scheduler_test.cc
@@ -29,8 +29,8 @@ MATCHER_P(HasDataWithMid, mid, "") {
     return false;
   }
 
-  if (arg->data.message_id != mid) {
-    *result_listener << "the produced data had mid " << *arg->data.message_id
+  if (arg->data.mid != mid) {
+    *result_listener << "the produced data had mid " << *arg->data.mid
                      << " and not the expected " << *mid;
     return false;
   }