Change scoped_ptr to std::unique_ptr in //net.

net/filter/sdch_filter_unittest.cc

 // Copyright 2014 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/filter/sdch_filter.h"
+
 #include <limits.h>
 
 #include <algorithm>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/bit_cast.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/simple_test_clock.h"
 #include "net/base/io_buffer.h"
 #include "net/base/sdch_dictionary.h"
 #include "net/base/sdch_manager.h"
 #include "net/base/sdch_observer.h"
 #include "net/filter/mock_filter_context.h"
-#include "net/filter/sdch_filter.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_http_job.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/zlib/zlib.h"
 
 namespace net {
 
 //------------------------------------------------------------------------------
 // Provide sample data and compression results with a sample VCDIFF dictionary.
 // Note an SDCH dictionary has extra meta-data before the VCDIFF dictionary.
@@ skipping 62 matching lines @@
     std::string compressed(server_hash);
     compressed.append("\0", 1);
     compressed.append(vcdiff_compressed_data_);
     return compressed;
   }
 
   const std::string test_vcdiff_dictionary_;
   const std::string vcdiff_compressed_data_;
   const std::string expanded_;  // Desired final, decompressed data.
 
-  scoped_ptr<SdchManager> sdch_manager_;
-  scoped_ptr<MockFilterContext> filter_context_;
+  std::unique_ptr<SdchManager> sdch_manager_;
+  std::unique_ptr<MockFilterContext> filter_context_;
 };
 
 TEST_F(SdchFilterTest, Hashing) {
   std::string client_hash, server_hash;
   std::string dictionary("test contents");
   SdchManager::GenerateHash(dictionary, &client_hash, &server_hash);
 
   EXPECT_EQ(client_hash, "lMQBjS3P");
   EXPECT_EQ(server_hash, "MyciMVll");
 }
 
 //------------------------------------------------------------------------------
 // Provide a generic helper function for trying to filter data.
 // This function repeatedly calls the filter to process data, until the entire
 // source is consumed. The return value from the filter is appended to output.
 // This allows us to vary input and output block sizes in order to test for edge
 // effects (boundary effects?) during the filtering process.
 // This function provides data to the filter in blocks of no-more-than the
 // specified input_block_length. It allows the filter to fill no more than
 // output_buffer_length in any one call to proccess (a.k.a., Read) data, and
 // concatenates all these little output blocks into the singular output string.
 static bool FilterTestData(const std::string& source,
                            size_t input_block_length,
                            const size_t output_buffer_length,
                            Filter* filter, std::string* output) {
   CHECK_GT(input_block_length, 0u);
   Filter::FilterStatus status(Filter::FILTER_NEED_MORE_DATA);
   size_t source_index = 0;
-  scoped_ptr<char[]> output_buffer(new char[output_buffer_length]);
+  std::unique_ptr<char[]> output_buffer(new char[output_buffer_length]);
   size_t input_amount = std::min(input_block_length,
       static_cast<size_t>(filter->stream_buffer_size()));
 
   do {
     int copy_amount = std::min(input_amount, source.size() - source_index);
     if (copy_amount > 0 && status == Filter::FILTER_NEED_MORE_DATA) {
       memcpy(filter->stream_buffer()->data(), source.data() + source_index,
              copy_amount);
       filter->FlushStreamBuffer(copy_amount);
       source_index += copy_amount;
@@ skipping 35 matching lines @@
   dictionary.append(kTestVcdiffDictionary, sizeof(kTestVcdiffDictionary) - 1);
   return dictionary;
 }
 
 TEST_F(SdchFilterTest, EmptyInputOk) {
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
   char output_buffer[20];
   std::string url_string("http://ignore.com");
   filter_context()->SetURL(GURL(url_string));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   // With no input data, try to read output.
   int output_bytes_or_buffer_size = sizeof(output_buffer);
   Filter::FilterStatus status = filter->ReadData(output_buffer,
                                                  &output_bytes_or_buffer_size);
 
   EXPECT_EQ(0, output_bytes_or_buffer_size);
   EXPECT_EQ(Filter::FILTER_NEED_MORE_DATA, status);
 }
 
 // Make sure that the filter context has everything that might be
 // nuked from it during URLRequest teardown before the SdchFilter
 // destructor.
 TEST_F(SdchFilterTest, SparseContextOk) {
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
   char output_buffer[20];
   std::string url_string("http://ignore.com");
   filter_context()->SetURL(GURL(url_string));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   // With no input data, try to read output.
   int output_bytes_or_buffer_size = sizeof(output_buffer);
   Filter::FilterStatus status = filter->ReadData(output_buffer,
                                                  &output_bytes_or_buffer_size);
 
   EXPECT_EQ(0, output_bytes_or_buffer_size);
   EXPECT_EQ(Filter::FILTER_NEED_MORE_DATA, status);
 
   // Partially tear down context. Anything that goes through request()
   // without checking it for null in the URLRequestJob::HttpFilterContext
   // implementation is suspect. Everything that does check it for null should
   // return null. This is to test for incorrectly relying on filter_context()
   // from the SdchFilter destructor.
   filter_context()->NukeUnstableInterfaces();
 }
 
 TEST_F(SdchFilterTest, PassThroughWhenTentative) {
   std::vector<Filter::FilterType> filter_types;
   // Selective a tentative filter (which can fall back to pass through).
   filter_types.push_back(Filter::FILTER_TYPE_GZIP_HELPING_SDCH);
   char output_buffer[20];
   // Response code needs to be 200 to allow a pass through.
   filter_context()->SetResponseCode(200);
   std::string url_string("http://ignore.com");
   filter_context()->SetURL(GURL(url_string));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   // Supply enough data to force a pass-through mode..
   std::string non_gzip_content("not GZIPed data");
 
   char* input_buffer = filter->stream_buffer()->data();
   int input_buffer_size = filter->stream_buffer_size();
 
   EXPECT_LT(static_cast<int>(non_gzip_content.size()),
             input_buffer_size);
   memcpy(input_buffer, non_gzip_content.data(),
@@ skipping 18 matching lines @@
   std::vector<Filter::FilterType> filter_types;
   // Selective a tentative filter (which can fall back to pass through).
   filter_types.push_back(Filter::FILTER_TYPE_SDCH_POSSIBLE);
   char output_buffer[20];
   // Response code needs to be 200 to allow a pass through.
   filter_context()->SetResponseCode(403);
   // Meta refresh will only appear for html content
   filter_context()->SetMimeType("text/html");
   std::string url_string("http://ignore.com");
   filter_context()->SetURL(GURL(url_string));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   // Supply enough data to force a pass-through mode, which means we have
   // provided more than 9 characters that can't be a dictionary hash.
   std::string non_sdch_content("This is not SDCH");
 
   char* input_buffer = filter->stream_buffer()->data();
   int input_buffer_size = filter->stream_buffer_size();
 
   EXPECT_LT(static_cast<int>(non_sdch_content.size()),
             input_buffer_size);
@@ skipping 20 matching lines @@
   // Selective a tentative filter (which can fall back to pass through).
   filter_types.push_back(Filter::FILTER_TYPE_SDCH_POSSIBLE);
   char output_buffer[20];
   // Response code needs to be 200 to allow a pass through.
   filter_context()->SetResponseCode(403);
   // Meta refresh will only appear for html content, so set to something else
   // to induce an error (we can't meta refresh).
   filter_context()->SetMimeType("anything");
   std::string url_string("http://ignore.com");
   filter_context()->SetURL(GURL(url_string));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   // Supply enough data to force a pass-through mode, which means we have
   // provided more than 9 characters that can't be a dictionary hash.
   std::string non_sdch_content("This is not SDCH");
 
   char* input_buffer = filter->stream_buffer()->data();
   int input_buffer_size = filter->stream_buffer_size();
 
   EXPECT_LT(static_cast<int>(non_sdch_content.size()),
             input_buffer_size);
@@ skipping 14 matching lines @@
   std::vector<Filter::FilterType> filter_types;
   // Selective a tentative filter (which can fall back to pass through).
   filter_types.push_back(Filter::FILTER_TYPE_SDCH_POSSIBLE);
   char output_buffer[20];
   // Response code needs to be 200 to allow a pass through.
   filter_context()->SetResponseCode(403);
   // Meta refresh will only appear for html content
   filter_context()->SetMimeType("text/html");
   std::string url_string("http://ignore.com");
   filter_context()->SetURL(GURL(url_string));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   // Supply enough data to force a pass-through mode, which means we have
   // provided more than 9 characters that can't be a dictionary hash.
   std::string non_sdch_content("This is not SDCH");
 
   char* input_buffer = filter->stream_buffer()->data();
   int input_buffer_size = filter->stream_buffer_size();
 
   EXPECT_LT(static_cast<int>(non_sdch_content.size()),
             input_buffer_size);
@@ skipping 15 matching lines @@
       sizeof(output_buffer)));
   EXPECT_EQ(Filter::FILTER_OK, status);
 }
 
 TEST_F(SdchFilterTest, BasicBadDictionary) {
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
   char output_buffer[20];
   std::string url_string("http://ignore.com");
   filter_context()->SetURL(GURL(url_string));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   // Supply bogus data (which doesn't yet specify a full dictionary hash).
   // Dictionary hash is 8 characters followed by a null.
   std::string dictionary_hash_prefix("123");
 
   char* input_buffer = filter->stream_buffer()->data();
   int input_buffer_size = filter->stream_buffer_size();
 
   EXPECT_LT(static_cast<int>(dictionary_hash_prefix.size()),
             input_buffer_size);
@@ skipping 64 matching lines @@
   GURL url(url_string);
   EXPECT_TRUE(AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   SetupFilterContextWithGURL(url);
 
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   std::string output;
   EXPECT_TRUE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 
   // Decode with really small buffers (size 1) to check for edge effects.
   filter.reset(Filter::Factory(filter_types, *filter_context()));
@@ skipping 16 matching lines @@
   GURL url(url_string);
   EXPECT_TRUE(AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   GURL filter_context_gurl("https://" + kSampleDomain);
   SetupFilterContextWithGURL(GURL("https://" + kSampleDomain));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 // Current failsafe TODO/hack refuses to decode any content that doesn't use
 // http as the scheme (see use of DICTIONARY_SELECTED_FOR_NON_HTTP).
 // The following tests this blockage. Note that blacklisting results, so we
 // we need separate tests for each of these.
 TEST_F(SdchFilterTest, NoDecodeFtp) {
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   SetupFilterContextWithGURL(GURL("ftp://" + kSampleDomain));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 TEST_F(SdchFilterTest, NoDecodeFileColon) {
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   SetupFilterContextWithGURL(GURL("file://" + kSampleDomain));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 TEST_F(SdchFilterTest, NoDecodeAboutColon) {
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   SetupFilterContextWithGURL(GURL("about://" + kSampleDomain));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 TEST_F(SdchFilterTest, NoDecodeJavaScript) {
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   SetupFilterContextWithGURL(GURL("javascript://" + kSampleDomain));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
 }
 
 TEST_F(SdchFilterTest, CanStillDecodeHttp) {
   // Construct a valid SDCH dictionary from a VCDIFF dictionary.
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
 
   std::string url_string = "http://" + kSampleDomain;
 
   GURL url(url_string);
   EXPECT_TRUE(AddSdchDictionary(dictionary, url));
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   SetupFilterContextWithGURL(GURL("http://" + kSampleDomain));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   const size_t feed_block_size(100);
   const size_t output_block_size(100);
   std::string output;
 
   base::HistogramTester tester;
 
   EXPECT_TRUE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
   // The filter's destructor is responsible for uploading total ratio
@@ skipping 16 matching lines @@
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   // Decode with content arriving from the "wrong" domain.
   // This tests SdchManager::CanSet().
   GURL wrong_domain_url("http://www.wrongdomain.com");
   SetupFilterContextWithGURL(wrong_domain_url);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types,  *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   std::string output;
   EXPECT_FALSE(FilterTestData(compressed, feed_block_size, output_block_size,
                               filter.get(), &output));
   EXPECT_EQ(output.size(), 0u);  // No output written.
 
   EXPECT_EQ(SDCH_OK, sdch_manager_->IsInSupportedDomain(GURL(url_string)));
   EXPECT_EQ(SDCH_DOMAIN_BLACKLIST_INCLUDES_TARGET,
@@ skipping 19 matching lines @@
   GURL url2(url_string + path);
   EXPECT_TRUE(AddSdchDictionary(dictionary_with_path, url2));
 
   std::string compressed_for_path(NewSdchCompressedData(dictionary_with_path));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   // Test decode the path data, arriving from a valid path.
   SetupFilterContextWithGURL(GURL(url_string + path));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   std::string output;
 
   EXPECT_TRUE(FilterTestData(compressed_for_path, feed_block_size,
                              output_block_size, filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 
   // Test decode the path data, arriving from a invalid path.
@@ skipping 31 matching lines @@
   EXPECT_TRUE(AddSdchDictionary(dictionary_with_port,
                                 GURL(url_string + ":" + port)));
 
   std::string compressed_for_port(NewSdchCompressedData(dictionary_with_port));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   // Test decode the port data, arriving from a valid port.
   SetupFilterContextWithGURL(GURL(url_string + ":" + port));
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   std::string output;
   EXPECT_TRUE(FilterTestData(compressed_for_port, feed_block_size,
                              output_block_size, filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 
   // Test decode the port data, arriving from a valid (default) port.
   SetupFilterContextWithGURL(GURL(url_string));  // Default port.
@@ skipping 36 matching lines @@
                       Z_DEFAULT_STRATEGY);
 
   CHECK_EQ(Z_OK, code);
 
   // Fill in zlib control block
   zlib_stream.next_in = bit_cast<Bytef*>(input.data());
   zlib_stream.avail_in = input.size();
 
   // Assume we can compress into similar buffer (add 100 bytes to be sure).
   size_t gzip_compressed_length = zlib_stream.avail_in + 100;
-  scoped_ptr<char[]> gzip_compressed(new char[gzip_compressed_length]);
+  std::unique_ptr<char[]> gzip_compressed(new char[gzip_compressed_length]);
   zlib_stream.next_out = bit_cast<Bytef*>(gzip_compressed.get());
   zlib_stream.avail_out = gzip_compressed_length;
 
   // The GZIP header (see RFC 1952):
   //   +---+---+---+---+---+---+---+---+---+---+
   //   |ID1|ID2|CM |FLG|     MTIME     |XFL|OS |
   //   +---+---+---+---+---+---+---+---+---+---+
   //     ID1     \037
   //     ID2     \213
   //     CM      \010 (compression method == DEFLATE)
@@ skipping 51 matching lines @@
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
   filter_types.push_back(Filter::FILTER_TYPE_GZIP);
 
   // First try with a large buffer (larger than test input, or compressed data).
   const size_t kLargeInputBufferSize(1000);  // Used internally in filters.
   CHECK_GT(kLargeInputBufferSize, gzip_compressed_sdch.size());
   CHECK_GT(kLargeInputBufferSize, sdch_compressed.size());
   CHECK_GT(kLargeInputBufferSize, expanded_.size());
   SetupFilterContextWithGURL(url);
-  scoped_ptr<Filter> filter(
-      SdchFilterChainingTest::Factory(filter_types, *filter_context(),
-                                      kLargeInputBufferSize));
+  std::unique_ptr<Filter> filter(SdchFilterChainingTest::Factory(
+      filter_types, *filter_context(), kLargeInputBufferSize));
   EXPECT_EQ(static_cast<int>(kLargeInputBufferSize),
             filter->stream_buffer_size());
 
   // Verify that chained filter is waiting for data.
   char tiny_output_buffer[10];
   int tiny_output_size = sizeof(tiny_output_buffer);
   EXPECT_EQ(Filter::FILTER_NEED_MORE_DATA,
             filter->ReadData(tiny_output_buffer, &tiny_output_size));
 
   // Make chain process all data.
@@ skipping 62 matching lines @@
 
   filter_context()->SetMimeType("anything/mime");
   SetupFilterContextWithGURL(url);
 
   Filter::FixupEncodingTypes(*filter_context(), &filter_types);
   ASSERT_EQ(filter_types.size(), 2u);
   EXPECT_EQ(filter_types[0], Filter::FILTER_TYPE_SDCH);
   EXPECT_EQ(filter_types[1], Filter::FILTER_TYPE_GZIP_HELPING_SDCH);
 
   // First try with a large buffer (larger than test input, or compressed data).
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   // Verify that chained filter is waiting for data.
   char tiny_output_buffer[10];
   int tiny_output_size = sizeof(tiny_output_buffer);
   EXPECT_EQ(Filter::FILTER_NEED_MORE_DATA,
             filter->ReadData(tiny_output_buffer, &tiny_output_size));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   std::string output;
@@ skipping 36 matching lines @@
 
   filter_context()->SetMimeType("anything/mime");
   SetupFilterContextWithGURL(url);
   Filter::FixupEncodingTypes(*filter_context(), &filter_types);
   ASSERT_EQ(filter_types.size(), 3u);
   EXPECT_EQ(filter_types[0], Filter::FILTER_TYPE_SDCH_POSSIBLE);
   EXPECT_EQ(filter_types[1], Filter::FILTER_TYPE_GZIP_HELPING_SDCH);
   EXPECT_EQ(filter_types[2], Filter::FILTER_TYPE_GZIP);
 
   // First try with a large buffer (larger than test input, or compressed data).
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   // Verify that chained filter is waiting for data.
   char tiny_output_buffer[10];
   int tiny_output_size = sizeof(tiny_output_buffer);
   EXPECT_EQ(Filter::FILTER_NEED_MORE_DATA,
             filter->ReadData(tiny_output_buffer, &tiny_output_size));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   std::string output;
@@ skipping 33 matching lines @@
   std::vector<Filter::FilterType> filter_types;
 
   filter_context()->SetMimeType("anything/mime");
   SetupFilterContextWithGURL(url);
   Filter::FixupEncodingTypes(*filter_context(), &filter_types);
   ASSERT_EQ(filter_types.size(), 2u);
   EXPECT_EQ(filter_types[0], Filter::FILTER_TYPE_SDCH_POSSIBLE);
   EXPECT_EQ(filter_types[1], Filter::FILTER_TYPE_GZIP_HELPING_SDCH);
 
   // First try with a large buffer (larger than test input, or compressed data).
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   // Verify that chained filter is waiting for data.
   char tiny_output_buffer[10];
   int tiny_output_size = sizeof(tiny_output_buffer);
   EXPECT_EQ(Filter::FILTER_NEED_MORE_DATA,
             filter->ReadData(tiny_output_buffer, &tiny_output_size));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   std::string output;
@@ skipping 39 matching lines @@
 
   filter_context()->SetMimeType("anything/mime");
   SetupFilterContextWithGURL(url);
   Filter::FixupEncodingTypes(*filter_context(), &filter_types);
   ASSERT_EQ(filter_types.size(), 3u);
   EXPECT_EQ(filter_types[0], Filter::FILTER_TYPE_SDCH_POSSIBLE);
   EXPECT_EQ(filter_types[1], Filter::FILTER_TYPE_GZIP_HELPING_SDCH);
   EXPECT_EQ(filter_types[2], Filter::FILTER_TYPE_GZIP);
 
   // First try with a large buffer (larger than test input, or compressed data).
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   // Verify that chained filter is waiting for data.
   char tiny_output_buffer[10];
   int tiny_output_size = sizeof(tiny_output_buffer);
   EXPECT_EQ(Filter::FILTER_NEED_MORE_DATA,
             filter->ReadData(tiny_output_buffer, &tiny_output_size));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   std::string output;
@@ skipping 19 matching lines @@
   const std::string kSampleDomain = "sdchtest.com";
   std::string dictionary(NewSdchDictionary(kSampleDomain));
   std::string url_string = "http://" + kSampleDomain;
   GURL url(url_string);
   EXPECT_TRUE(AddSdchDictionary(dictionary, url));
 
   SetupFilterContextWithGURL(url);
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   // Setup another dictionary, expired. Don't add it to the filter context.
   // Delete stored dictionaries first to handle platforms which only
   // have room for a single dictionary.
   sdch_manager_->ClearData();
   std::string expired_dictionary(NewSdchExpiredDictionary(kSampleDomain));
 
   // Don't use the Helper function since its insertion check is indeterminate
   // for a Max-Age: 0 dictionary.
   sdch_manager_->AddSdchDictionary(expired_dictionary, url, nullptr);
 
   std::string client_hash;
   std::string server_hash;
   SdchManager::GenerateHash(expired_dictionary, &client_hash, &server_hash);
 
   SdchProblemCode problem_code;
-  scoped_ptr<SdchManager::DictionarySet> hash_set(
+  std::unique_ptr<SdchManager::DictionarySet> hash_set(
       sdch_manager_->GetDictionarySetByHash(url, server_hash, &problem_code));
   ASSERT_TRUE(hash_set);
   ASSERT_EQ(SDCH_OK, problem_code);
 
   // Encode output with the second dictionary.
   std::string sdch_compressed(NewSdchCompressedData(expired_dictionary));
 
   // See if the filter decodes it.
   std::string output;
   EXPECT_TRUE(FilterTestData(sdch_compressed, 100, 100, filter.get(), &output));
@@ skipping 47 matching lines @@
   std::string server_hash;
   SdchManager::GenerateHash(dictionary, &client_hash, &server_hash);
 
   std::string compressed(NewSdchCompressedData(dictionary));
 
   std::vector<Filter::FilterType> filter_types;
   filter_types.push_back(Filter::FILTER_TYPE_SDCH);
 
   SetupFilterContextWithGURL(url);
 
-  scoped_ptr<Filter> filter(Filter::Factory(filter_types, *filter_context()));
+  std::unique_ptr<Filter> filter(
+      Filter::Factory(filter_types, *filter_context()));
 
   size_t feed_block_size = 100;
   size_t output_block_size = 100;
   std::string output;
   EXPECT_TRUE(FilterTestData(compressed, feed_block_size, output_block_size,
                              filter.get(), &output));
   EXPECT_EQ(output, expanded_);
 
   filter.reset(nullptr);
 
   // Confirm that we got a "DictionaryUsed" signal from the SdchManager
   // for our dictionary.
   EXPECT_EQ(1, observer.dictionary_used_calls());
   EXPECT_EQ(server_hash, observer.last_server_hash());
 }
 
 }  // namespace net