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

chrome/browser/supervised_user/experimental/supervised_user_async_url_checker.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 "chrome/browser/supervised_user/experimental/supervised_user_async_url_checker.h"
 
 #include <string>
+#include <utility>
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "base/values.h"
@@ skipping 29 matching lines @@
 scoped_ptr<net::URLFetcher> CreateFetcher(URLFetcherDelegate* delegate,
                                           URLRequestContextGetter* context,
                                           const std::string& api_key,
                                           const GURL& url) {
   scoped_ptr<net::URLFetcher> fetcher = URLFetcher::Create(
       0, GURL(kApiUrl), URLFetcher::POST, delegate);
   fetcher->SetUploadData(kDataContentType, BuildRequestData(api_key, url));
   fetcher->SetRequestContext(context);
   fetcher->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                         net::LOAD_DO_NOT_SAVE_COOKIES);
-  return fetcher.Pass();
+  return fetcher;
 }
 
 // Parses a SafeSearch API |response| and stores the result in |is_porn|.
 // On errors, returns false and doesn't set |is_porn|.
 bool ParseResponse(const std::string& response, bool* is_porn) {
   scoped_ptr<base::Value> value = base::JSONReader::Read(response);
   const base::DictionaryValue* dict = nullptr;
   if (!value || !value->GetAsDictionary(&dict)) {
     DLOG(WARNING) << "ParseResponse failed to parse global dictionary";
     return false;
@@ skipping 23 matching lines @@
         scoped_ptr<net::URLFetcher> fetcher,
         const CheckCallback& callback);
   ~Check();
 
   GURL url;
   scoped_ptr<net::URLFetcher> fetcher;
   std::vector<CheckCallback> callbacks;
   base::TimeTicks start_time;
 };
 
-SupervisedUserAsyncURLChecker::Check::Check(
-    const GURL& url,
-    scoped_ptr<net::URLFetcher> fetcher,
-    const CheckCallback& callback)
+SupervisedUserAsyncURLChecker::Check::Check(const GURL& url,
+                                            scoped_ptr<net::URLFetcher> fetcher,
+                                            const CheckCallback& callback)
     : url(url),
-      fetcher(fetcher.Pass()),
+      fetcher(std::move(fetcher)),
       callbacks(1, callback),
-      start_time(base::TimeTicks::Now()) {
-}
+      start_time(base::TimeTicks::Now()) {}
 
 SupervisedUserAsyncURLChecker::Check::~Check() {}
 
 SupervisedUserAsyncURLChecker::CheckResult::CheckResult(
     SupervisedUserURLFilter::FilteringBehavior behavior,
     bool uncertain)
     : behavior(behavior),
       uncertain(uncertain),
       timestamp(base::TimeTicks::Now()) {}
 
@@ skipping 52 matching lines @@
       DVLOG(1) << "Adding to pending check for " << url.spec();
       check->callbacks.push_back(callback);
       return false;
     }
   }
 
   DVLOG(1) << "Checking URL " << url;
   std::string api_key = google_apis::GetSafeSitesAPIKey();
   scoped_ptr<URLFetcher> fetcher(CreateFetcher(this, context_, api_key, url));
   fetcher->Start();
-  checks_in_progress_.push_back(new Check(url, fetcher.Pass(), callback));
+  checks_in_progress_.push_back(new Check(url, std::move(fetcher), callback));
   return false;
 }
 
 void SupervisedUserAsyncURLChecker::OnURLFetchComplete(
     const net::URLFetcher* source) {
   ScopedVector<Check>::iterator it = checks_in_progress_.begin();
   while (it != checks_in_progress_.end()) {
     if (source == (*it)->fetcher.get())
       break;
     ++it;
@@ skipping 19 matching lines @@
 
   UMA_HISTOGRAM_TIMES("ManagedUsers.SafeSitesDelay",
                       base::TimeTicks::Now() - check->start_time);
 
   cache_.Put(check->url, CheckResult(behavior, uncertain));
 
   for (size_t i = 0; i < check->callbacks.size(); i++)
     check->callbacks[i].Run(check->url, behavior, uncertain);
   checks_in_progress_.erase(it);
 }