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

net/proxy/multi_threaded_proxy_resolver_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 "net/proxy/multi_threaded_proxy_resolver.h"
 
+#include <utility>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 155 matching lines @@
   base::Lock lock_;
 };
 
 class SingleShotMultiThreadedProxyResolverFactory
     : public MultiThreadedProxyResolverFactory {
  public:
   SingleShotMultiThreadedProxyResolverFactory(
       size_t max_num_threads,
       scoped_ptr<ProxyResolverFactory> factory)
       : MultiThreadedProxyResolverFactory(max_num_threads, false),
-        factory_(factory.Pass()) {}
+        factory_(std::move(factory)) {}
 
   scoped_ptr<ProxyResolverFactory> CreateProxyResolverFactory() override {
     DCHECK(factory_);
-    return factory_.Pass();
+    return std::move(factory_);
   }
 
  private:
   scoped_ptr<ProxyResolverFactory> factory_;
 };
 
 class MultiThreadedProxyResolverTest : public testing::Test {
  public:
   void Init(size_t num_threads) {
     scoped_ptr<BlockableProxyResolverFactory> factory_owner(
         new BlockableProxyResolverFactory);
     factory_ = factory_owner.get();
     resolver_factory_.reset(new SingleShotMultiThreadedProxyResolverFactory(
-        num_threads, factory_owner.Pass()));
+        num_threads, std::move(factory_owner)));
     TestCompletionCallback ready_callback;
     scoped_ptr<ProxyResolverFactory::Request> request;
     resolver_factory_->CreateProxyResolver(
         ProxyResolverScriptData::FromUTF8("pac script bytes"), &resolver_,
         ready_callback.callback(), &request);
     EXPECT_TRUE(request);
     ASSERT_EQ(OK, ready_callback.WaitForResult());
 
     // Verify that the script data reaches the synchronous resolver factory.
     ASSERT_EQ(1u, factory_->script_data().size());
@@ skipping 566 matching lines @@
   }
   // The factory destructor will block until the worker thread stops, but it may
   // post tasks to the origin message loop which are still pending. Run them
   // now to ensure it works as expected.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace
 
 }  // namespace net