ui/base/resource: Roll our own version of ReadBigEndian() function.

net/dns/dns_response.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.
 
 #include "net/dns/dns_response.h"
 
+#include "base/big_endian.h"
 #include "base/strings/string_util.h"
 #include "base/sys_byteorder.h"
 #include "net/base/address_list.h"
-#include "net/base/big_endian.h"
 #include "net/base/dns_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_query.h"
 
 namespace net {
 
 DnsResourceRecord::DnsResourceRecord() {
 }
@@ skipping 45 matching lines @@
         if (consumed == 0) {
           consumed = p - pos + sizeof(uint16);
           if (!out)
             return consumed;  // If name is not stored, that's all we need.
         }
         seen += sizeof(uint16);
         // If seen the whole packet, then we must be in a loop.
         if (seen > length_)
           return 0;
         uint16 offset;
-        ReadBigEndian<uint16>(p, &offset);
+        base::ReadBigEndian<uint16>(p, &offset);
         offset &= dns_protocol::kOffsetMask;
         p = packet_ + offset;
         if (p >= end)
           return 0;
         break;
       }
       case dns_protocol::kLabelDirect: {
         uint8 label_len = *p;
         ++p;
         // Note: root domain (".") is NOT included.
@@ skipping 19 matching lines @@
         return 0;
     }
   }
 }
 
 bool DnsRecordParser::ReadRecord(DnsResourceRecord* out) {
   DCHECK(packet_);
   size_t consumed = ReadName(cur_, &out->name);
   if (!consumed)
     return false;
-  BigEndianReader reader(cur_ + consumed,
-                         packet_ + length_ - (cur_ + consumed));
+  base::BigEndianReader reader(cur_ + consumed,
+                               packet_ + length_ - (cur_ + consumed));
   uint16 rdlen;
   if (reader.ReadU16(&out->type) &&
       reader.ReadU16(&out->klass) &&
       reader.ReadU32(&out->ttl) &&
       reader.ReadU16(&rdlen) &&
       reader.ReadPiece(&out->rdata, rdlen)) {
     cur_ = reader.ptr();
     return true;
   }
   return false;
@@ skipping 116 matching lines @@
   const size_t hdr_size = sizeof(dns_protocol::Header);
   const size_t qname_size = parser_.GetOffset() - 2 * sizeof(uint16) - hdr_size;
   return base::StringPiece(io_buffer_->data() + hdr_size, qname_size);
 }
 
 uint16 DnsResponse::qtype() const {
   DCHECK(parser_.IsValid());
   // QTYPE starts where QNAME ends.
   const size_t type_offset = parser_.GetOffset() - 2 * sizeof(uint16);
   uint16 type;
-  ReadBigEndian<uint16>(io_buffer_->data() + type_offset, &type);
+  base::ReadBigEndian<uint16>(io_buffer_->data() + type_offset, &type);
   return type;
 }
 
 std::string DnsResponse::GetDottedName() const {
   return DNSDomainToString(qname());
 }
 
 DnsRecordParser DnsResponse::Parser() const {
   DCHECK(parser_.IsValid());
   // Return a copy of the parser.
@@ skipping 63 matching lines @@
 
   // getcanonname in eglibc returns the first owner name of an A or AAAA RR.
   // If the response passed all the checks so far, then |expected_name| is it.
   *addr_list = AddressList::CreateFromIPAddressList(ip_addresses,
                                                     expected_name);
   *ttl = base::TimeDelta::FromSeconds(ttl_sec);
   return DNS_PARSE_OK;
 }
 
 }  // namespace net