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

net/filter/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/filter.h"
+
+#include <utility>
+
 #include "base/macros.h"
 #include "net/base/io_buffer.h"
-#include "net/filter/filter.h"
 #include "net/filter/mock_filter_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 class PassThroughFilter : public Filter {
  public:
   PassThroughFilter() : Filter(FILTER_TYPE_UNSUPPORTED) {}
@@ skipping 30 matching lines @@
   EXPECT_EQ(Filter::FILTER_TYPE_UNSUPPORTED,
             Filter::ConvertEncodingToType("strange"));
 }
 
 TEST(FilterTest, SdchEncoding) {
   // Handle content encodings including SDCH.
   const std::string kTextHtmlMime("text/html");
   MockFilterContext filter_context;
   // Empty handle indicates to filter that SDCH is active.
   filter_context.SetSdchResponse(
-      SdchManager::CreateEmptyDictionarySetForTesting().Pass());
+      SdchManager::CreateEmptyDictionarySetForTesting());
 
   std::vector<Filter::FilterType> encoding_types;
 
   // Check for most common encoding, and verify it survives unchanged.
   encoding_types.clear();
   encoding_types.push_back(Filter::FILTER_TYPE_SDCH);
   encoding_types.push_back(Filter::FILTER_TYPE_GZIP);
   filter_context.SetMimeType(kTextHtmlMime);
   Filter::FixupEncodingTypes(filter_context, &encoding_types);
   ASSERT_EQ(2U, encoding_types.size());
@@ skipping 17 matching lines @@
   ASSERT_EQ(2U, encoding_types.size());
   EXPECT_EQ(Filter::FILTER_TYPE_SDCH, encoding_types[0]);
   EXPECT_EQ(Filter::FILTER_TYPE_GZIP_HELPING_SDCH, encoding_types[1]);
 }
 
 TEST(FilterTest, MissingSdchEncoding) {
   // Handle interesting case where entire SDCH encoding assertion "got lost."
   const std::string kTextHtmlMime("text/html");
   MockFilterContext filter_context;
   filter_context.SetSdchResponse(
-      SdchManager::CreateEmptyDictionarySetForTesting().Pass());
+      SdchManager::CreateEmptyDictionarySetForTesting());
 
   std::vector<Filter::FilterType> encoding_types;
 
   // Loss of encoding, but it was an SDCH response with html type.
   encoding_types.clear();
   filter_context.SetMimeType(kTextHtmlMime);
   Filter::FixupEncodingTypes(filter_context, &encoding_types);
   ASSERT_EQ(2U, encoding_types.size());
   EXPECT_EQ(Filter::FILTER_TYPE_SDCH_POSSIBLE, encoding_types[0]);
   EXPECT_EQ(Filter::FILTER_TYPE_GZIP_HELPING_SDCH, encoding_types[1]);
@@ skipping 40 matching lines @@
 // Regression test for http://crbug.com/418975.
 TEST(FilterTest, ThreeFilterChain) {
   scoped_ptr<PassThroughFilter> filter1(new PassThroughFilter);
   scoped_ptr<PassThroughFilter> filter2(new PassThroughFilter);
   scoped_ptr<PassThroughFilter> filter3(new PassThroughFilter);
 
   filter1->InitBuffer(32 * 1024);
   filter2->InitBuffer(32 * 1024);
   filter3->InitBuffer(32 * 1024);
 
-  filter2->next_filter_ = filter3.Pass();
-  filter1->next_filter_ = filter2.Pass();
+  filter2->next_filter_ = std::move(filter3);
+  filter1->next_filter_ = std::move(filter2);
 
   // Initialize the input array with a varying byte sequence.
   const size_t input_array_size = 64 * 1024;
   char input_array[input_array_size];
   size_t read_array_index = 0;
   for (size_t i = 0; i < input_array_size; i++) {
     input_array[i] = i % 113;
   }
 
   const size_t output_array_size = 4 * 1024;
@@ skipping 32 matching lines @@
            amount_to_copy);
     filter1->FlushStreamBuffer(amount_to_copy);
     read_array_index += amount_to_copy;
   } while (true);
 
   EXPECT_EQ(read_array_index, input_array_size);
   EXPECT_EQ(compare_array_index, input_array_size);
 }
 
 }  // Namespace net