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

net/spdy/spdy_framer.cc

 // 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.
 
 // TODO(rtenhove) clean up frame buffer size calculations so that we aren't
 // constantly adding and subtracting header sizes; this is ugly and error-
 // prone.
 
 #include "net/spdy/spdy_framer.h"
 
@@ skipping 35 matching lines @@
 };
 
 // Adler ID for the SPDY header compressor dictionaries. Note that they are
 // initialized lazily to avoid static initializers.
 base::LazyInstance<DictionaryIds>::Leaky g_dictionary_ids;
 
 // Creates a FlagsAndLength.
 FlagsAndLength CreateFlagsAndLength(SpdyControlFlags flags, size_t length) {
   DCHECK_EQ(0u, length & ~static_cast<size_t>(kLengthMask));
   FlagsAndLength flags_length;
-  flags_length.length_ = htonl(static_cast<uint32>(length));
+  flags_length.length_ = base::HostToNet32(static_cast<uint32>(length));
   DCHECK_EQ(0, flags & ~kControlFlagsMask);
   flags_length.flags_[0] = flags;
   return flags_length;
 }
 
 // By default is compression on or off.
 bool SpdyFramer::compression_default_ = true;
 
 // The initial size of the control frame buffer; this is used internally
 // as we parse through control frames. (It is exposed here for unit test
@@ skipping 29 matching lines @@
 }
 #else
 #define CHANGE_STATE(newstate) (state_ = newstate)
 #endif
 
 SettingsFlagsAndId SettingsFlagsAndId::FromWireFormat(int version,
                                                       uint32 wire) {
   if (version < 3) {
     ConvertFlagsAndIdForSpdy2(&wire);
   }
-  return SettingsFlagsAndId(ntohl(wire) >> 24, ntohl(wire) & 0x00ffffff);
+  return SettingsFlagsAndId(base::NetToHost32(wire) >> 24,
+                            base::NetToHost32(wire) & 0x00ffffff);
 }
 
 SettingsFlagsAndId::SettingsFlagsAndId(uint8 flags, uint32 id)
     : flags_(flags), id_(id & 0x00ffffff) {
   DCHECK_GT(static_cast<uint32>(1 << 24), id);
 }
 
 uint32 SettingsFlagsAndId::GetWireFormat(int version) const {
-  uint32 wire = htonl(id_ & 0x00ffffff) | htonl(flags_ << 24);
+  uint32 wire =
+      base::HostToNet32(id_ & 0x00ffffff) | base::HostToNet32(flags_ << 24);
   if (version < 3) {
     ConvertFlagsAndIdForSpdy2(&wire);
   }
   return wire;
 }
 
 // SPDY 2 had a bug in it with respect to byte ordering of id/flags field.
 // This method is used to preserve buggy behavior and works on both
 // little-endian and big-endian hosts.
 // This method is also bidirectional (can be used to translate SPDY 2 to SPDY 3
@@ skipping 657 matching lines @@
   return processed_bytes;
 }
 
 bool SpdyFramer::ProcessSetting(const char* data) {
   // Extract fields.
   // Maintain behavior of old SPDY 2 bug with byte ordering of flags/id.
   const uint32 id_and_flags_wire = *(reinterpret_cast<const uint32*>(data));
   SettingsFlagsAndId id_and_flags =
       SettingsFlagsAndId::FromWireFormat(spdy_version_, id_and_flags_wire);
   uint8 flags = id_and_flags.flags();
-  uint32 value = ntohl(*(reinterpret_cast<const uint32*>(data + 4)));
+  uint32 value =
+      base::NetToHost32(*(reinterpret_cast<const uint32*>(data + 4)));
 
   // Validate id.
   switch (id_and_flags.id()) {
     case SETTINGS_UPLOAD_BANDWIDTH:
     case SETTINGS_DOWNLOAD_BANDWIDTH:
     case SETTINGS_ROUND_TRIP_TIME:
     case SETTINGS_MAX_CONCURRENT_STREAMS:
     case SETTINGS_CURRENT_CWND:
     case SETTINGS_DOWNLOAD_RETRANS_RATE:
     case SETTINGS_INITIAL_WINDOW_SIZE:
@@ skipping 194 matching lines @@
 bool SpdyFramer::ParseSettings(const SpdySettingsControlFrame* frame,
                                SpdySettings* settings) {
   DCHECK_EQ(frame->type(), SETTINGS);
   DCHECK(settings);
 
   SpdyFrameReader parser(frame->header_block(), frame->header_block_len());
   for (size_t index = 0; index < frame->num_entries(); ++index) {
     uint32 id_and_flags_wire;
     uint32 value;
     // SettingsFlagsAndId accepts off-the-wire (network byte order) data, so we
-    // use ReadBytes() instead of ReadUInt32() as the latter calls ntohl().
+    // use ReadBytes() instead of ReadUInt32(), which calls base::NetToHost32().
     if (!parser.ReadBytes(&id_and_flags_wire, 4)) {
       return false;
     }
     if (!parser.ReadUInt32(&value))
       return false;
     SettingsFlagsAndId id_and_flags =
         SettingsFlagsAndId::FromWireFormat(frame->version(), id_and_flags_wire);
     settings->insert(settings->end(), std::make_pair(id_and_flags, value));
   }
   return true;
@@ skipping 50 matching lines @@
   frame.WriteUInt16(SYN_STREAM);
   frame.WriteBytes(&flags_length, sizeof(flags_length));
   frame.WriteUInt32(stream_id);
   frame.WriteUInt32(associated_stream_id);
   // Cap as appropriate.
   if (priority > GetLowestPriority()) {
     DLOG(ERROR) << "Priority out-of-bounds.";
     priority = GetLowestPriority();
   }
   // Priority is 2 bits for <spdy3, 3 bits otherwise.
-  frame.WriteUInt16(ntohs(priority) << (spdy_version_ < 3 ? 6 : 5));
+  frame.WriteUInt16(base::NetToHost16(priority) << (spdy_version_ < 3 ? 6 : 5));
   WriteHeaderBlock(&frame, headers);
 
   scoped_ptr<SpdySynStreamControlFrame> syn_frame(
       reinterpret_cast<SpdySynStreamControlFrame*>(frame.take()));
   if (compressed) {
     return reinterpret_cast<SpdySynStreamControlFrame*>(
         CompressControlFrame(*syn_frame.get()));
   }
   return syn_frame.release();
 }
@@ skipping 198 matching lines @@
 SpdyDataFrame* SpdyFramer::CreateDataFrame(SpdyStreamId stream_id,
                                            const char* data,
                                            uint32 len, SpdyDataFlags flags) {
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
 
   SpdyFrameBuilder frame(SpdyDataFrame::size() + len);
   frame.WriteUInt32(stream_id);
 
   DCHECK_EQ(0u, len & ~static_cast<size_t>(kLengthMask));
   FlagsAndLength flags_length;
-  flags_length.length_ = htonl(len);
+  flags_length.length_ = base::HostToNet32(len);
   DCHECK_EQ(0, flags & ~kDataFlagsMask);
   flags_length.flags_[0] = flags;
   frame.WriteBytes(&flags_length, sizeof(flags_length));
 
   frame.WriteBytes(data, len);
   scoped_ptr<SpdyFrame> data_frame(frame.take());
   SpdyDataFrame* rv;
   if (flags & DATA_FLAG_COMPRESSED) {
     LOG(DFATAL) << "DATA_FLAG_COMPRESSED invalid for " << display_protocol_
                 << ".";
@@ skipping 459 matching lines @@
 
 void SpdyFramer::set_validate_control_frame_sizes(bool value) {
   validate_control_frame_sizes_ = value;
 }
 
 void SpdyFramer::set_enable_compression_default(bool value) {
   compression_default_ = value;
 }
 
 }  // namespace spdy