Add base::HostToNetXX() & NetToHostXX(), and use them to replace htonX() & ntohX() in Chrome.

net/spdy/spdy_protocol.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.
 
 // This file contains some protocol structures for use with Spdy.
 
 #ifndef NET_SPDY_SPDY_PROTOCOL_H_
 #define NET_SPDY_SPDY_PROTOCOL_H_
 #pragma once
 
@@ skipping 557 matching lines @@
   }
 
   // Provides access to the frame bytes, which is a buffer containing
   // the frame packed as expected for sending over the wire.
   char* data() const { return reinterpret_cast<char*>(frame_); }
 
   uint8 flags() const { return frame_->flags_length_.flags_[0]; }
   void set_flags(uint8 flags) { frame_->flags_length_.flags_[0] = flags; }
 
   uint32 length() const {
-    return ntohl(frame_->flags_length_.length_) & kLengthMask;
+    return base::NetToHost32(frame_->flags_length_.length_) & kLengthMask;
   }
 
   void set_length(uint32 length) {
     DCHECK_EQ(0u, (length & ~kLengthMask));
-    length = htonl(length & kLengthMask);
+    length = base::HostToNet32(length & kLengthMask);
     frame_->flags_length_.length_ = flags() | length;
   }
 
   bool is_control_frame() const {
-    return (ntohs(frame_->control_.version_) & kControlFlagMask) ==
+    return (base::NetToHost16(frame_->control_.version_) & kControlFlagMask) ==
         kControlFlagMask;
   }
 
   // The size of the SpdyFrameBlock structure.
   // Every SpdyFrame* class has a static size() method for accessing
   // the size of the data structure which will be sent over the wire.
   // Note:  this is not the same as sizeof(SpdyFrame).
   enum { kHeaderSize = sizeof(struct SpdyFrameBlock) };
 
  protected:
   SpdyFrameBlock* frame_;
 
  private:
   bool owns_buffer_;
   DISALLOW_COPY_AND_ASSIGN(SpdyFrame);
 };
 
 // A Data Frame.
 class SpdyDataFrame : public SpdyFrame {
  public:
   SpdyDataFrame() : SpdyFrame(size()) {}
   SpdyDataFrame(char* data, bool owns_buffer)
       : SpdyFrame(data, owns_buffer) {}
 
   SpdyStreamId stream_id() const {
-    return ntohl(frame_->data_.stream_id_) & kStreamIdMask;
+    return base::NetToHost32(frame_->data_.stream_id_) & kStreamIdMask;
   }
 
   // Note that setting the stream id sets the control bit to false.
   // As stream id should always be set, this means the control bit
   // should always be set correctly.
   void set_stream_id(SpdyStreamId id) {
     DCHECK_EQ(0u, (id & ~kStreamIdMask));
-    frame_->data_.stream_id_ = htonl(id & kStreamIdMask);
+    frame_->data_.stream_id_ = base::HostToNet32(id & kStreamIdMask);
   }
 
   // Returns the size of the SpdyFrameBlock structure.
   // Note: this is not the size of the SpdyDataFrame class.
   static size_t size() { return SpdyFrame::kHeaderSize; }
 
   const char* payload() const {
     return reinterpret_cast<const char*>(frame_) + size();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyDataFrame);
 };
 
 // A Control Frame.
 class SpdyControlFrame : public SpdyFrame {
  public:
   explicit SpdyControlFrame(size_t size) : SpdyFrame(size) {}
   SpdyControlFrame(char* data, bool owns_buffer)
       : SpdyFrame(data, owns_buffer) {}
 
   // Callers can use this method to check if the frame appears to be a valid
   // frame.  Does not guarantee that there are no errors.
   bool AppearsToBeAValidControlFrame() const {
     // Right now we only check if the frame has an out-of-bounds type.
-    uint16 type = ntohs(block()->control_.type_);
+    uint16 type = base::NetToHost16(block()->control_.type_);
     // NOOP is not a 'valid' control frame in SPDY/3 and beyond.
     return type >= SYN_STREAM &&
         type < NUM_CONTROL_FRAME_TYPES &&
         (version() == 2 || type != NOOP);
   }
 
   uint16 version() const {
     const int kVersionMask = 0x7fff;
-    return ntohs(block()->control_.version_) & kVersionMask;
+    return base::NetToHost16(block()->control_.version_) & kVersionMask;
   }
 
   void set_version(uint16 version) {
     const uint16 kControlBit = 0x80;
     DCHECK_EQ(0, version & kControlBit);
-    mutable_block()->control_.version_ = kControlBit | htons(version);
+    mutable_block()->control_.version_ =
+        kControlBit | base::HostToNet16(version);
   }
 
   SpdyControlType type() const {
-    uint16 type = ntohs(block()->control_.type_);
+    uint16 type = base::NetToHost16(block()->control_.type_);
     LOG_IF(DFATAL, type < SYN_STREAM || type >= NUM_CONTROL_FRAME_TYPES)
         << "Invalid control frame type " << type;
     return static_cast<SpdyControlType>(type);
   }
 
   void set_type(SpdyControlType type) {
     DCHECK(type >= SYN_STREAM && type < NUM_CONTROL_FRAME_TYPES);
-    mutable_block()->control_.type_ = htons(type);
+    mutable_block()->control_.type_ = base::HostToNet16(type);
   }
 
   // Returns true if this control frame is of a type that has a header block,
   // otherwise it returns false.
   bool has_header_block() const {
     return type() == SYN_STREAM || type() == SYN_REPLY || type() == HEADERS;
   }
 
  private:
   const struct SpdyFrameBlock* block() const {
     return frame_;
   }
   struct SpdyFrameBlock* mutable_block() {
     return frame_;
   }
   DISALLOW_COPY_AND_ASSIGN(SpdyControlFrame);
 };
 
 // A SYN_STREAM frame.
 class SpdySynStreamControlFrame : public SpdyControlFrame {
  public:
   SpdySynStreamControlFrame() : SpdyControlFrame(size()) {}
   SpdySynStreamControlFrame(char* data, bool owns_buffer)
       : SpdyControlFrame(data, owns_buffer) {}
 
   SpdyStreamId stream_id() const {
-    return ntohl(block()->stream_id_) & kStreamIdMask;
+    return base::NetToHost32(block()->stream_id_) & kStreamIdMask;
   }
 
   void set_stream_id(SpdyStreamId id) {
-    mutable_block()->stream_id_ = htonl(id & kStreamIdMask);
+    mutable_block()->stream_id_ = base::HostToNet32(id & kStreamIdMask);
   }
 
   SpdyStreamId associated_stream_id() const {
-    return ntohl(block()->associated_stream_id_) & kStreamIdMask;
+    return base::NetToHost32(block()->associated_stream_id_) & kStreamIdMask;
   }
 
   void set_associated_stream_id(SpdyStreamId id) {
-    mutable_block()->associated_stream_id_ = htonl(id & kStreamIdMask);
+    mutable_block()->associated_stream_id_ =
+        base::HostToNet32(id & kStreamIdMask);
   }
 
   SpdyPriority priority() const {
     if (version() < 3) {
       return (block()->priority_ & kSpdy2PriorityMask) >> 6;
     } else {
       return (block()->priority_ & kSpdy3PriorityMask) >> 5;
     }
   }
 
@@ skipping 21 matching lines @@
 };
 
 // A SYN_REPLY frame.
 class SpdySynReplyControlFrame : public SpdyControlFrame {
  public:
   SpdySynReplyControlFrame() : SpdyControlFrame(size()) {}
   SpdySynReplyControlFrame(char* data, bool owns_buffer)
       : SpdyControlFrame(data, owns_buffer) {}
 
   SpdyStreamId stream_id() const {
-    return ntohl(block()->stream_id_) & kStreamIdMask;
+    return base::NetToHost32(block()->stream_id_) & kStreamIdMask;
   }
 
   void set_stream_id(SpdyStreamId id) {
-    mutable_block()->stream_id_ = htonl(id & kStreamIdMask);
+    mutable_block()->stream_id_ = base::HostToNet32(id & kStreamIdMask);
   }
 
   int header_block_len() const {
     size_t header_block_len = length() - (size() - SpdyFrame::kHeaderSize);
     // SPDY 2 had 2 bytes of unused space preceeding the header block.
     if (version() < 3) {
       header_block_len -= 2;
     }
     return header_block_len;
   }
@@ skipping 22 matching lines @@
 };
 
 // A RST_STREAM frame.
 class SpdyRstStreamControlFrame : public SpdyControlFrame {
  public:
   SpdyRstStreamControlFrame() : SpdyControlFrame(size()) {}
   SpdyRstStreamControlFrame(char* data, bool owns_buffer)
       : SpdyControlFrame(data, owns_buffer) {}
 
   SpdyStreamId stream_id() const {
-    return ntohl(block()->stream_id_) & kStreamIdMask;
+    return base::NetToHost32(block()->stream_id_) & kStreamIdMask;
   }
 
   void set_stream_id(SpdyStreamId id) {
-    mutable_block()->stream_id_ = htonl(id & kStreamIdMask);
+    mutable_block()->stream_id_ = base::HostToNet32(id & kStreamIdMask);
   }
 
   SpdyStatusCodes status() const {
     SpdyStatusCodes status =
-        static_cast<SpdyStatusCodes>(ntohl(block()->status_));
+        static_cast<SpdyStatusCodes>(base::NetToHost32(block()->status_));
     if (status < INVALID || status >= NUM_STATUS_CODES) {
       status = INVALID;
     }
     return status;
   }
   void set_status(SpdyStatusCodes status) {
-    mutable_block()->status_ = htonl(static_cast<uint32>(status));
+    mutable_block()->status_ = base::HostToNet32(static_cast<uint32>(status));
   }
 
   // Returns the size of the SpdyRstStreamControlFrameBlock structure.
   // Note: this is not the size of the SpdyRstStreamControlFrame class.
   static size_t size() { return sizeof(SpdyRstStreamControlFrameBlock); }
 
  private:
   const struct SpdyRstStreamControlFrameBlock* block() const {
     return static_cast<SpdyRstStreamControlFrameBlock*>(frame_);
   }
   struct SpdyRstStreamControlFrameBlock* mutable_block() {
     return static_cast<SpdyRstStreamControlFrameBlock*>(frame_);
   }
   DISALLOW_COPY_AND_ASSIGN(SpdyRstStreamControlFrame);
 };
 
 class SpdySettingsControlFrame : public SpdyControlFrame {
  public:
   SpdySettingsControlFrame() : SpdyControlFrame(size()) {}
   SpdySettingsControlFrame(char* data, bool owns_buffer)
       : SpdyControlFrame(data, owns_buffer) {}
 
   uint32 num_entries() const {
-    return ntohl(block()->num_entries_);
+    return base::NetToHost32(block()->num_entries_);
   }
 
   void set_num_entries(int val) {
-    mutable_block()->num_entries_ = htonl(val);
+    mutable_block()->num_entries_ = base::HostToNet32(val);
   }
 
   int header_block_len() const {
     return length() - (size() - SpdyFrame::kHeaderSize);
   }
 
   const char* header_block() const {
     return reinterpret_cast<const char*>(block()) + size();
   }
 
@@ skipping 11 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SpdySettingsControlFrame);
 };
 
 class SpdyPingControlFrame : public SpdyControlFrame {
  public:
   SpdyPingControlFrame() : SpdyControlFrame(size()) {}
   SpdyPingControlFrame(char* data, bool owns_buffer)
       : SpdyControlFrame(data, owns_buffer) {}
 
   uint32 unique_id() const {
-    return ntohl(block()->unique_id_);
+    return base::NetToHost32(block()->unique_id_);
   }
 
   void set_unique_id(uint32 unique_id) {
-    mutable_block()->unique_id_ = htonl(unique_id);
+    mutable_block()->unique_id_ = base::HostToNet32(unique_id);
   }
 
   static size_t size() { return sizeof(SpdyPingControlFrameBlock); }
 
  private:
   const struct SpdyPingControlFrameBlock* block() const {
     return static_cast<SpdyPingControlFrameBlock*>(frame_);
   }
   struct SpdyPingControlFrameBlock* mutable_block() {
     return static_cast<SpdyPingControlFrameBlock*>(frame_);
@@ skipping 19 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SpdyCredentialControlFrame);
 };
 
 class SpdyGoAwayControlFrame : public SpdyControlFrame {
  public:
   SpdyGoAwayControlFrame() : SpdyControlFrame(size()) {}
   SpdyGoAwayControlFrame(char* data, bool owns_buffer)
       : SpdyControlFrame(data, owns_buffer) {}
 
   SpdyStreamId last_accepted_stream_id() const {
-    return ntohl(block()->last_accepted_stream_id_) & kStreamIdMask;
+    return base::NetToHost32(block()->last_accepted_stream_id_) & kStreamIdMask;
   }
 
   void set_last_accepted_stream_id(SpdyStreamId id) {
-    mutable_block()->last_accepted_stream_id_ = htonl(id & kStreamIdMask);
+    mutable_block()->last_accepted_stream_id_ =
+        base::HostToNet32(id & kStreamIdMask);
   }
 
   static size_t size() { return sizeof(SpdyGoAwayControlFrameBlock); }
 
  private:
   const struct SpdyGoAwayControlFrameBlock* block() const {
     return static_cast<SpdyGoAwayControlFrameBlock*>(frame_);
   }
   struct SpdyGoAwayControlFrameBlock* mutable_block() {
     return static_cast<SpdyGoAwayControlFrameBlock*>(frame_);
   }
   DISALLOW_COPY_AND_ASSIGN(SpdyGoAwayControlFrame);
 };
 
 // A HEADERS frame.
 class SpdyHeadersControlFrame : public SpdyControlFrame {
  public:
   SpdyHeadersControlFrame() : SpdyControlFrame(size()) {}
   SpdyHeadersControlFrame(char* data, bool owns_buffer)
       : SpdyControlFrame(data, owns_buffer) {}
 
   SpdyStreamId stream_id() const {
-    return ntohl(block()->stream_id_) & kStreamIdMask;
+    return base::NetToHost32(block()->stream_id_) & kStreamIdMask;
   }
 
   void set_stream_id(SpdyStreamId id) {
-    mutable_block()->stream_id_ = htonl(id & kStreamIdMask);
+    mutable_block()->stream_id_ = base::HostToNet32(id & kStreamIdMask);
   }
 
   // The number of bytes in the header block beyond the frame header length.
   int header_block_len() const {
     size_t header_block_len = length() - (size() - SpdyFrame::kHeaderSize);
     // SPDY 2 had 2 bytes of unused space preceeding the header block.
     if (version() < 3) {
       header_block_len -= 2;
     }
     return header_block_len;
@@ skipping 23 matching lines @@
 };
 
 // A WINDOW_UPDATE frame.
 class SpdyWindowUpdateControlFrame : public SpdyControlFrame {
  public:
   SpdyWindowUpdateControlFrame() : SpdyControlFrame(size()) {}
   SpdyWindowUpdateControlFrame(char* data, bool owns_buffer)
       : SpdyControlFrame(data, owns_buffer) {}
 
   SpdyStreamId stream_id() const {
-    return ntohl(block()->stream_id_) & kStreamIdMask;
+    return base::NetToHost32(block()->stream_id_) & kStreamIdMask;
   }
 
   void set_stream_id(SpdyStreamId id) {
-    mutable_block()->stream_id_ = htonl(id & kStreamIdMask);
+    mutable_block()->stream_id_ = base::HostToNet32(id & kStreamIdMask);
   }
 
   uint32 delta_window_size() const {
-    return ntohl(block()->delta_window_size_);
+    return base::NetToHost32(block()->delta_window_size_);
   }
 
   void set_delta_window_size(uint32 delta_window_size) {
-    mutable_block()->delta_window_size_ = htonl(delta_window_size);
+    mutable_block()->delta_window_size_ = base::HostToNet32(delta_window_size);
   }
 
   // Returns the size of the SpdyWindowUpdateControlFrameBlock structure.
   // Note: this is not the size of the SpdyWindowUpdateControlFrame class.
   static size_t size() { return sizeof(SpdyWindowUpdateControlFrameBlock); }
 
  private:
   const struct SpdyWindowUpdateControlFrameBlock* block() const {
     return static_cast<SpdyWindowUpdateControlFrameBlock*>(frame_);
   }
   struct SpdyWindowUpdateControlFrameBlock* mutable_block() {
     return static_cast<SpdyWindowUpdateControlFrameBlock*>(frame_);
   }
 
   DISALLOW_COPY_AND_ASSIGN(SpdyWindowUpdateControlFrame);
 };
 
 }  // namespace spdy
 
 #endif  // NET_SPDY_SPDY_PROTOCOL_H_