Convert //third_party from scoped_ptr to std::unique_ptr

third_party/libaddressinput/chromium/chrome_metadata_source.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 "third_party/libaddressinput/chromium/chrome_metadata_source.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_response_writer.h"
 #include "url/gurl.h"
 
 namespace autofill {
@@ skipping 44 matching lines @@
                                const Callback& downloaded) const {
   const_cast<ChromeMetadataSource*>(this)->Download(key, downloaded);
 }
 
 void ChromeMetadataSource::OnURLFetchComplete(const net::URLFetcher* source) {
   std::map<const net::URLFetcher*, Request*>::iterator request =
       requests_.find(source);
   DCHECK(request != requests_.end());
 
   bool ok = source->GetResponseCode() == net::HTTP_OK;
-  scoped_ptr<std::string> data(new std::string());
+  std::unique_ptr<std::string> data(new std::string());
   if (ok)
     data->swap(request->second->data);
   request->second->callback(ok, request->second->key, data.release());
 
   delete request->second;
   requests_.erase(request);
 }
 
 ChromeMetadataSource::Request::Request(const std::string& key,
-                                       scoped_ptr<net::URLFetcher> fetcher,
+                                       std::unique_ptr<net::URLFetcher> fetcher,
                                        const Callback& callback)
     : key(key), fetcher(std::move(fetcher)), callback(callback) {}
 
 void ChromeMetadataSource::Download(const std::string& key,
                                     const Callback& downloaded) {
   GURL resource(validation_data_url_ + key);
   if (!resource.SchemeIsCryptographic()) {
     downloaded(false, key, NULL);
     return;
   }
 
-  scoped_ptr<net::URLFetcher> fetcher =
+  std::unique_ptr<net::URLFetcher> fetcher =
       net::URLFetcher::Create(resource, net::URLFetcher::GET, this);
   fetcher->SetLoadFlags(
       net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES);
   fetcher->SetRequestContext(getter_);
 
   Request* request = new Request(key, std::move(fetcher), downloaded);
   request->fetcher->SaveResponseWithWriter(
-      scoped_ptr<net::URLFetcherResponseWriter>(
+      std::unique_ptr<net::URLFetcherResponseWriter>(
           new UnownedStringWriter(&request->data)));
   requests_[request->fetcher.get()] = request;
   request->fetcher->Start();
 }
 
 }  // namespace autofill