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

chrome/browser/net/chrome_network_delegate_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 "chrome/browser/net/chrome_network_delegate.h"
 
 #include <stdint.h>
+#include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_member.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "build/build_config.h"
@@ skipping 70 matching lines @@
         request.get(), content::RESOURCE_TYPE_MAIN_FRAME, nullptr, -2, -2, -2,
         true, false, true, true, false);
   } else {
     request->SetUserData(
         data_use_measurement::DataUseUserData::kUserDataKey,
         new data_use_measurement::DataUseUserData(
             data_use_measurement::DataUseUserData::SUGGESTIONS));
   }
   request->Start();
   base::RunLoop().RunUntilIdle();
-  return request.Pass();
+  return request;
 }
 
 // A fake DataUseAggregator for testing that only counts how many times its
 // respective methods have been called.
 class FakeDataUseAggregator : public data_usage::DataUseAggregator {
  public:
   FakeDataUseAggregator()
       : data_usage::DataUseAggregator(
             scoped_ptr<data_usage::DataUseAnnotator>(),
             scoped_ptr<data_usage::DataUseAmortizer>()),
@@ skipping 241 matching lines @@
         profile_.GetTestingPrefService());
   }
 
  protected:
   scoped_ptr<net::NetworkDelegate> CreateNetworkDelegate() {
     scoped_ptr<ChromeNetworkDelegate> network_delegate(
         new ChromeNetworkDelegate(forwarder(), &enable_referrers_));
     network_delegate->set_force_google_safe_search(&force_google_safe_search_);
     network_delegate->set_force_youtube_safety_mode(
         &force_youtube_safety_mode_);
-    return network_delegate.Pass();
+    return std::move(network_delegate);
   }
 
   void SetSafeSearch(bool google_safe_search,
                      bool youtube_safety_mode) {
     force_google_safe_search_.SetValue(google_safe_search);
     force_youtube_safety_mode_.SetValue(youtube_safety_mode);
   }
 
   void SetDelegate(net::NetworkDelegate* delegate) {
     network_delegate_ = delegate;
@@ skipping 75 matching lines @@
     ChromeNetworkDelegate::InitializePrefsOnUIThread(
         &enable_referrers_, NULL, NULL, NULL,
         profile_.GetTestingPrefService());
   }
 
  protected:
   scoped_ptr<ChromeNetworkDelegate> CreateNetworkDelegate() {
     scoped_ptr<ChromeNetworkDelegate> network_delegate(
         new ChromeNetworkDelegate(forwarder(), &enable_referrers_));
     network_delegate->set_cookie_settings(cookie_settings_);
-    return network_delegate.Pass();
+    return network_delegate;
   }
 
   void SetDelegate(net::NetworkDelegate* delegate) {
     network_delegate_ = delegate;
     context_.set_network_delegate(network_delegate_);
   }
 
  protected:
   extensions::EventRouterForwarder* forwarder() {
 #if defined(ENABLE_EXTENSIONS)
@@ skipping 69 matching lines @@
                                                        kBlockedFirstPartySite));
 
   cookie_settings_->SetCookieSetting(
       ContentSettingsPattern::FromURL(kBlockedFirstPartySite),
       ContentSettingsPattern::Wildcard(),
       CONTENT_SETTING_BLOCK);
   // Privacy mode is disabled as kAllowedSite is still getting cookies
   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
                                                        kBlockedFirstPartySite));
 }