Convert Pass()→std::move() in //components/[n-z]*

components/url_matcher/url_matcher_unittest.cc

 // Copyright 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 "components/url_matcher/url_matcher.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace url_matcher {
 
 //
 // URLMatcherCondition
@@ skipping 473 matching lines @@
                                  scoped_ptr<URLMatcherSchemeFilter>(
                                      new URLMatcherSchemeFilter("http")),
                                  scoped_ptr<URLMatcherPortFilter>()));
   EXPECT_TRUE(condition_set3->IsMatch(matching_patterns, url1));
 
   // Test port filters.
   std::vector<URLMatcherPortFilter::Range> ranges;
   ranges.push_back(URLMatcherPortFilter::CreateRange(80));
   scoped_ptr<URLMatcherPortFilter> filter(new URLMatcherPortFilter(ranges));
   scoped_refptr<URLMatcherConditionSet> condition_set4(
-      new URLMatcherConditionSet(
-          1, conditions, scoped_ptr<URLMatcherSchemeFilter>(), filter.Pass()));
+      new URLMatcherConditionSet(1, conditions,
+                                 scoped_ptr<URLMatcherSchemeFilter>(),
+                                 std::move(filter)));
   EXPECT_TRUE(condition_set4->IsMatch(matching_patterns, url1));
   EXPECT_TRUE(condition_set4->IsMatch(matching_patterns, url3));
   EXPECT_FALSE(condition_set4->IsMatch(matching_patterns, url4));
 
   // Test regex patterns.
   matching_patterns.clear();
   URLMatcherCondition r1 = factory.CreateURLMatchesCondition("/fo?oo");
   std::set<URLMatcherCondition> regex_conditions;
   regex_conditions.insert(r1);
   scoped_refptr<URLMatcherConditionSet> condition_set5(
@@ skipping 43 matching lines @@
                                      query_element_type,
                                      match_type,
                                      &factory);
   URLMatcherConditionSet::QueryConditions query_conditions;
   query_conditions.insert(q1);
 
   scoped_ptr<URLMatcherSchemeFilter> scheme_filter;
   scoped_ptr<URLMatcherPortFilter> port_filter;
 
   scoped_refptr<URLMatcherConditionSet> condition_set(
-      new URLMatcherConditionSet(1,
-                                 conditions,
-                                 query_conditions,
-                                 scheme_filter.Pass(),
-                                 port_filter.Pass()));
+      new URLMatcherConditionSet(1, conditions, query_conditions,
+                                 std::move(scheme_filter),
+                                 std::move(port_filter)));
 
   GURL url("http://www.example.com/foo?" + url_query);
 
   URLMatcher matcher;
   URLMatcherConditionSet::Vector vector;
   vector.push_back(condition_set);
   matcher.AddConditionSets(vector);
 
   return matcher.MatchURL(url).size() == 1;
 }
@@ skipping 399 matching lines @@
   conditions.insert(factory->CreateOriginAndPathMatchesCondition("val"));
   const int kConditionSetId = 1;
   URLMatcherConditionSet::Vector insert;
   insert.push_back(make_scoped_refptr(
       new URLMatcherConditionSet(kConditionSetId, conditions)));
   matcher.AddConditionSets(insert);
   EXPECT_EQ(0u, matcher.MatchURL(url).size());
 }
 
 }  // namespace url_matcher