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

net/base/network_quality_estimator_unittest.cc

 // Copyright 2015 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/base/network_quality_estimator.h"
 
 #include <stdint.h>
-
 #include <limits>
 #include <map>
+#include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/histogram_tester.h"
@@ skipping 11 matching lines @@
 #include "url/gurl.h"
 
 namespace {
 
 // Helps in setting the current network type and id.
 class TestNetworkQualityEstimator : public net::NetworkQualityEstimator {
  public:
   TestNetworkQualityEstimator(
       const std::map<std::string, std::string>& variation_params,
       scoped_ptr<net::ExternalEstimateProvider> external_estimate_provider)
-      : NetworkQualityEstimator(external_estimate_provider.Pass(),
+      : NetworkQualityEstimator(std::move(external_estimate_provider),
                                 variation_params,
                                 true,
                                 true) {
     // Set up embedded test server.
     embedded_test_server_.ServeFilesFromDirectory(
         base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
     EXPECT_TRUE(embedded_test_server_.Start());
     embedded_test_server_.RegisterRequestHandler(base::Bind(
         &TestNetworkQualityEstimator::HandleRequest, base::Unretained(this)));
   }
@@ skipping 16 matching lines @@
   }
 
   // Called by embedded server when a HTTP request is received.
   scoped_ptr<net::test_server::HttpResponse> HandleRequest(
       const net::test_server::HttpRequest& request) {
     scoped_ptr<net::test_server::BasicHttpResponse> http_response(
         new net::test_server::BasicHttpResponse());
     http_response->set_code(net::HTTP_OK);
     http_response->set_content("hello");
     http_response->set_content_type("text/plain");
-    return http_response.Pass();
+    return std::move(http_response);
   }
 
   // Returns a GURL hosted at embedded test server.
   const GURL GetEchoURL() const {
     return embedded_test_server_.GetURL("/echo.html");
   }
 
   using NetworkQualityEstimator::ReadCachedNetworkQualityEstimate;
   using NetworkQualityEstimator::OnConnectionTypeChanged;
 
@@ skipping 711 matching lines @@
 
 // Tests if the RTT value from external estimate provider is discarded if the
 // external estimate provider is invalid.
 TEST(NetworkQualityEstimatorTest, InvalidExternalEstimateProvider) {
   InvalidExternalEstimateProvider* invalid_external_estimate_provider =
       new InvalidExternalEstimateProvider();
   scoped_ptr<ExternalEstimateProvider> external_estimate_provider(
       invalid_external_estimate_provider);
 
   TestNetworkQualityEstimator estimator(std::map<std::string, std::string>(),
-                                        external_estimate_provider.Pass());
+                                        std::move(external_estimate_provider));
 
   base::TimeDelta rtt;
   int32_t kbps;
   EXPECT_EQ(1U, invalid_external_estimate_provider->get_rtt_count());
   EXPECT_FALSE(estimator.GetRTTEstimate(&rtt));
   EXPECT_FALSE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
 }
 
 class TestExternalEstimateProvider : public ExternalEstimateProvider {
  public:
@@ skipping 77 matching lines @@
 // Tests if the external estimate provider is called in the constructor and
 // on network change notification.
 TEST(NetworkQualityEstimatorTest, TestExternalEstimateProvider) {
   TestExternalEstimateProvider* test_external_estimate_provider =
       new TestExternalEstimateProvider(base::TimeDelta::FromMilliseconds(1),
                                        100);
   scoped_ptr<ExternalEstimateProvider> external_estimate_provider(
       test_external_estimate_provider);
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params,
-                                        external_estimate_provider.Pass());
+                                        std::move(external_estimate_provider));
 
   base::TimeDelta rtt;
   int32_t kbps;
   EXPECT_TRUE(estimator.GetRTTEstimate(&rtt));
   EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
 
   EXPECT_EQ(
       1U, test_external_estimate_provider->get_time_since_last_update_count());
   EXPECT_EQ(1U, test_external_estimate_provider->get_rtt_count());
   EXPECT_EQ(
@@ skipping 54 matching lines @@
   const int32_t external_estimate_provider_downstream_throughput = 100;
   TestExternalEstimateProvider* test_external_estimate_provider =
       new TestExternalEstimateProvider(
           external_estimate_provider_rtt,
           external_estimate_provider_downstream_throughput);
   scoped_ptr<ExternalEstimateProvider> external_estimate_provider(
       test_external_estimate_provider);
 
   std::map<std::string, std::string> variation_params;
   TestNetworkQualityEstimator estimator(variation_params,
-                                        external_estimate_provider.Pass());
+                                        std::move(external_estimate_provider));
 
   base::TimeDelta rtt;
   // Estimate provided by network quality estimator should match the estimate
   // provided by external estimate provider.
   EXPECT_TRUE(estimator.GetRTTEstimate(&rtt));
   EXPECT_EQ(external_estimate_provider_rtt, rtt);
 
   int32_t kbps;
   EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
   EXPECT_EQ(external_estimate_provider_downstream_throughput, kbps);
@@ skipping 79 matching lines @@
 
   EXPECT_EQ(4U, rtt_observer.observations().size());
   EXPECT_EQ(2U, throughput_observer.observations().size());
 
   EXPECT_EQ(tcp_rtt.InMilliseconds(), rtt_observer.observations().at(2).rtt_ms);
   EXPECT_EQ(quic_rtt.InMilliseconds(),
             rtt_observer.observations().at(3).rtt_ms);
 }
 
 }  // namespace net