Convert Pass()→std::move() in //net

net/dns/mdns_cache_unittest.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/mdns_cache.h"
+
 #include <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "net/dns/dns_response.h"
 #include "net/dns/dns_test_util.h"
-#include "net/dns/mdns_cache.h"
 #include "net/dns/record_parsed.h"
 #include "net/dns/record_rdata.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::Return;
 using ::testing::StrictMock;
 
 namespace net {
 
@@ skipping 99 matching lines @@
                          sizeof(dns_protocol::Header));
   parser.SkipQuestion();
 
   scoped_ptr<const RecordParsed> record1;
   scoped_ptr<const RecordParsed> record2;
   std::vector<const RecordParsed*> results;
 
   record1 = RecordParsed::CreateFrom(&parser, default_time_);
   record2 = RecordParsed::CreateFrom(&parser, default_time_);
 
-  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record1.Pass()));
+  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(std::move(record1)));
 
-  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record2.Pass()));
+  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(std::move(record2)));
 
   cache_.FindDnsRecords(ARecordRdata::kType, "ghs.l.google.com", &results,
                         default_time_);
 
   EXPECT_EQ(1u, results.size());
   EXPECT_EQ(default_time_, results.front()->time_created());
 
   EXPECT_EQ("ghs.l.google.com", results.front()->name());
 
   results.clear();
@@ skipping 14 matching lines @@
   std::vector<const RecordParsed*> results;
   const RecordParsed* record_to_be_deleted;
 
   record1 = RecordParsed::CreateFrom(&parser, default_time_);
   base::TimeDelta ttl1 = base::TimeDelta::FromSeconds(record1->ttl());
 
   record2 = RecordParsed::CreateFrom(&parser, default_time_);
   base::TimeDelta ttl2 = base::TimeDelta::FromSeconds(record2->ttl());
   record_to_be_deleted = record2.get();
 
-  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record1.Pass()));
-  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record2.Pass()));
+  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(std::move(record1)));
+  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(std::move(record2)));
 
   cache_.FindDnsRecords(ARecordRdata::kType, "ghs.l.google.com", &results,
                         default_time_);
 
   EXPECT_EQ(1u, results.size());
 
   EXPECT_EQ(default_time_ + ttl2, cache_.next_expiration());
 
 
   cache_.FindDnsRecords(ARecordRdata::kType, "ghs.l.google.com", &results,
@@ skipping 23 matching lines @@
                          sizeof(kTestResponsesDifferentAnswers),
                          0);
 
   scoped_ptr<const RecordParsed> record1;
   scoped_ptr<const RecordParsed> record2;
   std::vector<const RecordParsed*> results;
 
   record1 = RecordParsed::CreateFrom(&parser, default_time_);
   record2 = RecordParsed::CreateFrom(&parser, default_time_);
 
-  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record1.Pass()));
+  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(std::move(record1)));
   EXPECT_EQ(MDnsCache::RecordChanged,
-            cache_.UpdateDnsRecord(record2.Pass()));
+            cache_.UpdateDnsRecord(std::move(record2)));
 }
 
 // Test that a new record replacing an otherwise identical one already in the
 // cache causes the cache to output a "no change" event.
 TEST_F(MDnsCacheTest, RecordNoChange) {
   DnsRecordParser parser(kTestResponsesSameAnswers,
                          sizeof(kTestResponsesSameAnswers),
                          0);
 
   scoped_ptr<const RecordParsed> record1;
   scoped_ptr<const RecordParsed> record2;
   std::vector<const RecordParsed*> results;
 
   record1 = RecordParsed::CreateFrom(&parser, default_time_);
   record2 = RecordParsed::CreateFrom(&parser, default_time_ +
                                      base::TimeDelta::FromSeconds(1));
 
-  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record1.Pass()));
-  EXPECT_EQ(MDnsCache::NoChange, cache_.UpdateDnsRecord(record2.Pass()));
+  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(std::move(record1)));
+  EXPECT_EQ(MDnsCache::NoChange, cache_.UpdateDnsRecord(std::move(record2)));
 }
 
 // Test that the next expiration time of the cache is updated properly on record
 // insertion.
 TEST_F(MDnsCacheTest, RecordPreemptExpirationTime) {
   DnsRecordParser parser(kTestResponsesSameAnswers,
                          sizeof(kTestResponsesSameAnswers),
                          0);
 
   scoped_ptr<const RecordParsed> record1;
   scoped_ptr<const RecordParsed> record2;
   std::vector<const RecordParsed*> results;
 
   record1 = RecordParsed::CreateFrom(&parser, default_time_);
   record2 = RecordParsed::CreateFrom(&parser, default_time_);
   base::TimeDelta ttl1 = base::TimeDelta::FromSeconds(record1->ttl());
   base::TimeDelta ttl2 = base::TimeDelta::FromSeconds(record2->ttl());
 
   EXPECT_EQ(base::Time(), cache_.next_expiration());
-  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record2.Pass()));
+  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(std::move(record2)));
   EXPECT_EQ(default_time_ + ttl2, cache_.next_expiration());
-  EXPECT_EQ(MDnsCache::NoChange, cache_.UpdateDnsRecord(record1.Pass()));
+  EXPECT_EQ(MDnsCache::NoChange, cache_.UpdateDnsRecord(std::move(record1)));
   EXPECT_EQ(default_time_ + ttl1, cache_.next_expiration());
 }
 
 // Test that the cache handles mDNS "goodbye" packets correctly, not adding the
 // records to the cache if they are not already there, and eventually removing
 // records from the cache if they are.
 TEST_F(MDnsCacheTest, GoodbyePacket) {
   DnsRecordParser parser(kTestResponsesGoodbyePacket,
                          sizeof(kTestResponsesGoodbyePacket),
                          0);
 
   scoped_ptr<const RecordParsed> record_goodbye;
   scoped_ptr<const RecordParsed> record_hello;
   scoped_ptr<const RecordParsed> record_goodbye2;
   std::vector<const RecordParsed*> results;
 
   record_goodbye = RecordParsed::CreateFrom(&parser, default_time_);
   record_hello = RecordParsed::CreateFrom(&parser, default_time_);
   parser = DnsRecordParser(kTestResponsesGoodbyePacket,
                            sizeof(kTestResponsesGoodbyePacket),
                            0);
   record_goodbye2 = RecordParsed::CreateFrom(&parser, default_time_);
 
   base::TimeDelta ttl = base::TimeDelta::FromSeconds(record_hello->ttl());
 
   EXPECT_EQ(base::Time(), cache_.next_expiration());
-  EXPECT_EQ(MDnsCache::NoChange, cache_.UpdateDnsRecord(record_goodbye.Pass()));
+  EXPECT_EQ(MDnsCache::NoChange,
+            cache_.UpdateDnsRecord(std::move(record_goodbye)));
   EXPECT_EQ(base::Time(), cache_.next_expiration());
   EXPECT_EQ(MDnsCache::RecordAdded,
-            cache_.UpdateDnsRecord(record_hello.Pass()));
+            cache_.UpdateDnsRecord(std::move(record_hello)));
   EXPECT_EQ(default_time_ + ttl, cache_.next_expiration());
   EXPECT_EQ(MDnsCache::NoChange,
-            cache_.UpdateDnsRecord(record_goodbye2.Pass()));
+            cache_.UpdateDnsRecord(std::move(record_goodbye2)));
   EXPECT_EQ(default_time_ + base::TimeDelta::FromSeconds(1),
             cache_.next_expiration());
 }
 
 TEST_F(MDnsCacheTest, AnyRRType) {
   DnsRecordParser parser(kTestResponseTwoRecords,
                          sizeof(kTestResponseTwoRecords),
                          0);
 
   scoped_ptr<const RecordParsed> record1;
   scoped_ptr<const RecordParsed> record2;
   std::vector<const RecordParsed*> results;
 
   record1 = RecordParsed::CreateFrom(&parser, default_time_);
   record2 = RecordParsed::CreateFrom(&parser, default_time_);
-  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record1.Pass()));
-  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record2.Pass()));
+  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(std::move(record1)));
+  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(std::move(record2)));
 
   cache_.FindDnsRecords(0, "ghs.l.google.com", &results, default_time_);
 
   EXPECT_EQ(2u, results.size());
   EXPECT_EQ(default_time_, results.front()->time_created());
 
   EXPECT_EQ("ghs.l.google.com", results[0]->name());
   EXPECT_EQ("ghs.l.google.com", results[1]->name());
   EXPECT_EQ(dns_protocol::kTypeA,
             std::min(results[0]->type(), results[1]->type()));
   EXPECT_EQ(dns_protocol::kTypeAAAA,
             std::max(results[0]->type(), results[1]->type()));
 }
 
 TEST_F(MDnsCacheTest, RemoveRecord) {
   DnsRecordParser parser(kT1ResponseDatagram, sizeof(kT1ResponseDatagram),
                          sizeof(dns_protocol::Header));
   parser.SkipQuestion();
 
   scoped_ptr<const RecordParsed> record1;
   std::vector<const RecordParsed*> results;
 
   record1 = RecordParsed::CreateFrom(&parser, default_time_);
-  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(record1.Pass()));
+  EXPECT_EQ(MDnsCache::RecordAdded, cache_.UpdateDnsRecord(std::move(record1)));
 
   cache_.FindDnsRecords(dns_protocol::kTypeCNAME, "codereview.chromium.org",
                         &results, default_time_);
 
   EXPECT_EQ(1u, results.size());
 
   scoped_ptr<const RecordParsed> record_out =
       cache_.RemoveRecord(results.front());
 
   EXPECT_EQ(record_out.get(), results.front());
 
   cache_.FindDnsRecords(dns_protocol::kTypeCNAME, "codereview.chromium.org",
                         &results, default_time_);
 
   EXPECT_EQ(0u, results.size());
 }
 
 }  // namespace net