Multicast DNS implementation (initial)

net/dns/record_rdata.cc

 // Copyright (c) 2013 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/record_rdata.h"
 
 #include "net/base/big_endian.h"
 #include "net/base/dns_util.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_response.h"
@@ skipping 37 matching lines @@
 
 bool SrvRecordRdata::IsEqual(const RecordRdata* other) const {
   if (other->Type() != Type()) return false;
   const SrvRecordRdata* srv_other = static_cast<const SrvRecordRdata*>(other);
   return weight_ == srv_other->weight_ &&
       port_ == srv_other->port_ &&
       priority_ == srv_other->priority_ &&
       target_ == srv_other->target_;
 }
 
+scoped_ptr<const RecordRdata> SrvRecordRdata::Clone() const {
+  scoped_ptr<SrvRecordRdata> return_value(new SrvRecordRdata);
+
+  return_value->port_ = port_;
+  return_value->weight_ = weight_;
+  return_value->priority_ = priority_;
+  return_value->target_ = target_;
+
+  return scoped_ptr<const RecordRdata>(return_value.Pass());
+}
+
 ARecordRdata::ARecordRdata() {
 }
 
 ARecordRdata::~ARecordRdata() {
 }
 
 // static
 scoped_ptr<ARecordRdata> ARecordRdata::Create(
     const base::StringPiece& data,
     const DnsRecordParser& parser) {
@@ skipping 13 matching lines @@
 uint16 ARecordRdata::Type() const {
   return ARecordRdata::kType;
 }
 
 bool ARecordRdata::IsEqual(const RecordRdata* other) const {
   if (other->Type() != Type()) return false;
   const ARecordRdata* a_other = static_cast<const ARecordRdata*>(other);
   return address_ == a_other->address_;
 }
 
+scoped_ptr<const RecordRdata> ARecordRdata::Clone() const {
+  scoped_ptr<ARecordRdata> return_value(new ARecordRdata);
+
+  return_value->address_ = address_;
+
+  return return_value.PassAs<const RecordRdata>();
+}
+
 AAAARecordRdata::AAAARecordRdata() {
 }
 
 AAAARecordRdata::~AAAARecordRdata() {
 }
 
 // static
 scoped_ptr<AAAARecordRdata> AAAARecordRdata::Create(
     const base::StringPiece& data,
     const DnsRecordParser& parser) {
@@ skipping 13 matching lines @@
 uint16 AAAARecordRdata::Type() const {
   return AAAARecordRdata::kType;
 }
 
 bool AAAARecordRdata::IsEqual(const RecordRdata* other) const {
   if (other->Type() != Type()) return false;
   const AAAARecordRdata* a_other = static_cast<const AAAARecordRdata*>(other);
   return address_ == a_other->address_;
 }
 
+scoped_ptr<const RecordRdata> AAAARecordRdata::Clone() const {
+  scoped_ptr<AAAARecordRdata> return_value(new AAAARecordRdata);
+
+  return_value->address_ = address_;
+
+  return return_value.PassAs<const RecordRdata>();
+}
+
 CnameRecordRdata::CnameRecordRdata() {
 }
 
 CnameRecordRdata::~CnameRecordRdata() {
 }
 
 // static
 scoped_ptr<CnameRecordRdata> CnameRecordRdata::Create(
     const base::StringPiece& data,
     const DnsRecordParser& parser) {
   scoped_ptr<CnameRecordRdata> rdata(new CnameRecordRdata);
 
   if (!parser.ReadName(data.begin(), &rdata->cname_))
     return scoped_ptr<CnameRecordRdata>();
 
   return rdata.Pass();
 }
 
 uint16 CnameRecordRdata::Type() const {
   return CnameRecordRdata::kType;
 }
 
 bool CnameRecordRdata::IsEqual(const RecordRdata* other) const {
   if (other->Type() != Type()) return false;
   const CnameRecordRdata* cname_other =
       static_cast<const CnameRecordRdata*>(other);
   return cname_ == cname_other->cname_;
 }
 
+scoped_ptr<const RecordRdata> CnameRecordRdata::Clone() const {
+  scoped_ptr<CnameRecordRdata> return_value(new CnameRecordRdata);
+
+  return_value->cname_ = cname_;
+
+  return return_value.PassAs<const RecordRdata>();
+}
+
 PtrRecordRdata::PtrRecordRdata() {
 }
 
 PtrRecordRdata::~PtrRecordRdata() {
 }
 
 // static
 scoped_ptr<PtrRecordRdata> PtrRecordRdata::Create(
     const base::StringPiece& data,
     const DnsRecordParser& parser) {
   scoped_ptr<PtrRecordRdata> rdata(new PtrRecordRdata);
 
   if (!parser.ReadName(data.begin(), &rdata->ptrdomain_))
     return scoped_ptr<PtrRecordRdata>();
 
   return rdata.Pass();
 }
 
 uint16 PtrRecordRdata::Type() const {
   return PtrRecordRdata::kType;
 }
 
 bool PtrRecordRdata::IsEqual(const RecordRdata* other) const {
   if (other->Type() != Type()) return false;
   const PtrRecordRdata* ptr_other = static_cast<const PtrRecordRdata*>(other);
   return ptrdomain_ == ptr_other->ptrdomain_;
 }
 
+scoped_ptr<const RecordRdata> PtrRecordRdata::Clone() const {
+  scoped_ptr<PtrRecordRdata> return_value(new PtrRecordRdata);
+
+  return_value->ptrdomain_ = ptrdomain_;
+
+  return return_value.PassAs<const RecordRdata>();
+}
+
 TxtRecordRdata::TxtRecordRdata() {
 }
 
 TxtRecordRdata::~TxtRecordRdata() {
 }
 
 // static
 scoped_ptr<TxtRecordRdata> TxtRecordRdata::Create(
     const base::StringPiece& data,
     const DnsRecordParser& parser) {
@@ skipping 14 matching lines @@
   return rdata.Pass();
 }
 
 uint16 TxtRecordRdata::Type() const {
   return TxtRecordRdata::kType;
 }
 
 bool TxtRecordRdata::IsEqual(const RecordRdata* other) const {
   if (other->Type() != Type()) return false;
   const TxtRecordRdata* txt_other = static_cast<const TxtRecordRdata*>(other);
+
   return texts_ == txt_other->texts_;
 }
 
+scoped_ptr<const RecordRdata> TxtRecordRdata::Clone() const {
+  scoped_ptr<TxtRecordRdata> return_value(new TxtRecordRdata);
+
+  return_value->texts_ = texts_;
+
+  return return_value.PassAs<const RecordRdata>();
+}
+
 }  // namespace net