Convert //chrome/browser/safe_browsing from scoped_ptr to std::unique_ptr

chrome/browser/safe_browsing/protocol_parser_unittest.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 <stddef.h>
 
 #include <string>
 #include <vector>
 
 #include "base/strings/stringprintf.h"
@@ skipping 21 matching lines @@
     '\x22',                    // field 4, wire format length-delimited
     '\x18',                    // varint length 24
     '1', '1', '1', '1',        // 4-byte prefixes
     '2', '2', '2', '2',
     '3', '3', '3', '3',
     '4', '4', '4', '4',
     '8', '8', '8', '8',
     '9', '9', '9', '9',
   };
 
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   EXPECT_TRUE(ParseChunk(kRawAddChunk, sizeof(kRawAddChunk), &chunks));
   ASSERT_EQ(1U, chunks.size());
   EXPECT_EQ(1, chunks[0]->ChunkNumber());
   EXPECT_TRUE(chunks[0]->IsAdd());
   EXPECT_FALSE(chunks[0]->IsSub());
   EXPECT_TRUE(chunks[0]->IsPrefix());
   EXPECT_FALSE(chunks[0]->IsFullHash());
   ASSERT_EQ(6U, chunks[0]->PrefixCount());
   EXPECT_EQ(0x31313131U, chunks[0]->PrefixAt(0));  // 1111
   EXPECT_EQ(0x32323232U, chunks[0]->PrefixAt(1));  // 2222
@@ skipping 24 matching lines @@
     '2', '3', '2', '3', '2', '3', '2', '3',
     '2', '3', '2', '3', '2', '3', '2', '3',
   };
 
   SBFullHash full_hash1, full_hash2;
   for (int i = 0; i < 32; ++i) {
     full_hash1.full_hash[i] = (i % 2) ? '1' : '0';
     full_hash2.full_hash[i] = (i % 2) ? '3' : '2';
   }
 
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   EXPECT_TRUE(ParseChunk(kRawAddChunk, sizeof(kRawAddChunk), &chunks));
   ASSERT_EQ(1U, chunks.size());
   EXPECT_EQ(1, chunks[0]->ChunkNumber());
   EXPECT_TRUE(chunks[0]->IsAdd());
   EXPECT_FALSE(chunks[0]->IsSub());
   EXPECT_FALSE(chunks[0]->IsPrefix());
   EXPECT_TRUE(chunks[0]->IsFullHash());
 
   ASSERT_EQ(2U, chunks[0]->FullHashCount());
   EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1));
@@ skipping 19 matching lines @@
 
     '\0', '\0', '\0', '\x0C',  // 32-bit payload length in network byte order.
     '\x08',                    // field 1, wire format varint
     '\x02',                    // chunk_number varint 1
     '\x22',                    // field 4, wire format length-delimited
     '\x08',                    // varint length 8
     'p', 'p', 'p', 'p',        // 4-byte prefixes
     'g', 'g', 'g', 'g',
   };
 
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   EXPECT_TRUE(ParseChunk(kRawAddChunk, sizeof(kRawAddChunk), &chunks));
   ASSERT_EQ(2U, chunks.size());
 
   EXPECT_EQ(1, chunks[0]->ChunkNumber());
   EXPECT_TRUE(chunks[0]->IsAdd());
   EXPECT_FALSE(chunks[0]->IsSub());
   EXPECT_TRUE(chunks[0]->IsPrefix());
   EXPECT_FALSE(chunks[0]->IsFullHash());
   ASSERT_EQ(6U, chunks[0]->PrefixCount());
   EXPECT_EQ(0x31313131U, chunks[0]->PrefixAt(0));  // 1111
@@ skipping 19 matching lines @@
     '\0', '\0', '\0', '\x1C',  // 32-bit payload length in network byte order.
     '\x08',                    // field 1, wire format varint
     '\x01',                    // chunk_number varint 1
     '\x22',                    // field 4, wire format length-delimited
     '\x18',                    // varint length 24
     '1', '1', '1', '1',        // 4-byte prefixes
     '2', '2', '2', '2',
     '3', '3', '3', '3',
   };
 
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   EXPECT_FALSE(ParseChunk(kRawAddChunk, sizeof(kRawAddChunk), &chunks));
 }
 
 TEST(SafeBrowsingProtocolParsingTest, TestTruncatedFullHashChunk) {
   // This chunk delares there are two full hashes but there is only one.
   const char kRawAddChunk[] = {
     '\0', '\0', '\0', '\x46',  // 32-bit payload length in network byte order.
     '\x08',                    // field 1, wire format varint
     '\x01',                    // chunk_number varint 1
     '\x18',                    // field 3, wire format varint
     '\x01',                    // enum PrefixType == FULL_32B
     '\x22',                    // field 4, wire format length-delimited
     '\x40',                    // varint length 64 (2 full hashes)
 
     '0', '1', '0', '1', '0', '1', '0', '1',
     '0', '1', '0', '1', '0', '1', '0', '1',
     '0', '1', '0', '1', '0', '1', '0', '1',
     '0', '1', '0', '1', '0', '1', '0', '1',
   };
 
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   EXPECT_FALSE(ParseChunk(kRawAddChunk, sizeof(kRawAddChunk), &chunks));
 }
 
 TEST(SafeBrowsingProtocolParsingTest, TestHugeChunk) {
   // This chunk delares there are 6 prefixes but actually only contains 3.
   const char kRawAddChunk[] = {
     '\x1', '\0', '\0', '\0',   // 32-bit payload length in network byte order.
     '\x08',                    // field 1, wire format varint
     '\x01',                    // chunk_number varint 1
     '\x22',                    // field 4, wire format length-delimited
     '\x18',                    // varint length 24
     '1', '1', '1', '1',        // 4-byte prefixes
     '2', '2', '2', '2',
     '3', '3', '3', '3',
   };
 
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   EXPECT_FALSE(ParseChunk(kRawAddChunk, sizeof(kRawAddChunk), &chunks));
 }
 
 // Test parsing one sub chunk.
 TEST(SafeBrowsingProtocolParsingTest, TestSubChunk) {
   const char kRawSubChunk[] = {
     '\0', '\0', '\0', '\x12',  // 32-bit payload length in network byte order
     '\x08',                    // field 1, wire format varint
     '\x03',                    // chunk_number varint 3
     '\x10',                    // field 2, wire format varint
     '\x01',                    // enum ChunkType == SUB
     '\x22',                    // field 4, wire format length-delimited
     '\x08',                    // varint length 8 (2 prefixes)
     '1', '1', '1', '1',        // 4-byte prefixes
     '2', '2', '2', '2',
     '\x2a',                    // field 5, wire format length-delimited
     '\x02',                    // varint length 2 (2 add-chunk numbers)
     '\x07', '\x09',            // varint 7, varint 9
   };
 
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   EXPECT_TRUE(ParseChunk(kRawSubChunk, sizeof(kRawSubChunk), &chunks));
   ASSERT_EQ(1U, chunks.size());
   EXPECT_EQ(3, chunks[0]->ChunkNumber());
   EXPECT_FALSE(chunks[0]->IsAdd());
   EXPECT_TRUE(chunks[0]->IsSub());
   EXPECT_TRUE(chunks[0]->IsPrefix());
   EXPECT_FALSE(chunks[0]->IsFullHash());
   ASSERT_EQ(2U, chunks[0]->PrefixCount());
   EXPECT_EQ(0x31313131U, chunks[0]->PrefixAt(0));  // 1111
   EXPECT_EQ(7, chunks[0]->AddChunkNumberAt(0));
@@ skipping 28 matching lines @@
     '\x02',                    // varint length 2 (2 add-chunk numbers)
     '\x07', '\x09',            // varint 7, varint 9
   };
 
   SBFullHash full_hash1, full_hash2;
   for (int i = 0; i < 32; ++i) {
     full_hash1.full_hash[i] = i % 2 ? '1' : '0';
     full_hash2.full_hash[i] = i % 2 ? '3' : '2';
   }
 
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   EXPECT_TRUE(ParseChunk(kRawSubChunk, sizeof(kRawSubChunk), &chunks));
   ASSERT_EQ(1U, chunks.size());
   EXPECT_EQ(2, chunks[0]->ChunkNumber());
   EXPECT_FALSE(chunks[0]->IsAdd());
   EXPECT_TRUE(chunks[0]->IsSub());
   EXPECT_FALSE(chunks[0]->IsPrefix());
   EXPECT_TRUE(chunks[0]->IsFullHash());
 
   ASSERT_EQ(2U, chunks[0]->FullHashCount());
   EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1));
@@ skipping 283 matching lines @@
 // The SafeBrowsing service will occasionally send zero length chunks so that
 // client requests will have longer contiguous chunk number ranges, and thus
 // reduce the request size.
 TEST(SafeBrowsingProtocolParsingTest, TestZeroSizeAddChunk) {
   const char kEmptyAddChunk[] = {
     '\0', '\0', '\0', '\x02',  // 32-bit payload length in network byte order.
     '\x08',                    // field 1, wire format varint
     '\x02',                    // chunk_number varint 2
   };
 
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   EXPECT_TRUE(ParseChunk(kEmptyAddChunk, sizeof(kEmptyAddChunk), &chunks));
   ASSERT_EQ(1U, chunks.size());
   EXPECT_EQ(2, chunks[0]->ChunkNumber());
   EXPECT_TRUE(chunks[0]->IsAdd());
   EXPECT_FALSE(chunks[0]->IsSub());
   EXPECT_TRUE(chunks[0]->IsPrefix());
   EXPECT_FALSE(chunks[0]->IsFullHash());
   EXPECT_EQ(0U, chunks[0]->PrefixCount());
 
   // Now test a zero size chunk in between normal chunks.
@@ skipping 50 matching lines @@
 // Test parsing a zero sized sub chunk.
 TEST(SafeBrowsingProtocolParsingTest, TestZeroSizeSubChunk) {
   const char kEmptySubChunk[] = {
     '\0', '\0', '\0', '\x04',  // 32-bit payload length in network byte order.
     '\x08',                    // field 1, wire format varint
     '\x02',                    // chunk_number varint 2
     '\x10',                    // field 2, wire format varint
     '\x01',                    // enum ChunkType == SUB
   };
 
-  std::vector<scoped_ptr<SBChunkData>> chunks;
+  std::vector<std::unique_ptr<SBChunkData>> chunks;
   EXPECT_TRUE(ParseChunk(kEmptySubChunk, sizeof(kEmptySubChunk), &chunks));
   ASSERT_EQ(1U, chunks.size());
   EXPECT_EQ(2, chunks[0]->ChunkNumber());
   EXPECT_FALSE(chunks[0]->IsAdd());
   EXPECT_TRUE(chunks[0]->IsSub());
   EXPECT_TRUE(chunks[0]->IsPrefix());
   EXPECT_FALSE(chunks[0]->IsFullHash());
   EXPECT_EQ(0U, chunks[0]->PrefixCount());
 
   // Test parsing a zero sized sub chunk mixed in with content carrying chunks.
@@ skipping 56 matching lines @@
   EXPECT_FALSE(chunks[0]->IsAdd());
   EXPECT_TRUE(chunks[0]->IsSub());
   EXPECT_TRUE(chunks[2]->IsPrefix());
   EXPECT_FALSE(chunks[2]->IsFullHash());
   ASSERT_EQ(1U, chunks[2]->PrefixCount());
   EXPECT_EQ(0x70707070U, chunks[2]->PrefixAt(0));  // pppp
   EXPECT_EQ(11, chunks[2]->AddChunkNumberAt(0));
 }
 
 }  // namespace safe_browsing