Convert //sync from scoped_ptr to std::unique_ptr

sync/internal_api/attachments/attachment_downloader_impl.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 "sync/internal_api/public/attachments/attachment_downloader_impl.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/base64.h"
@@ skipping 20 matching lines @@
 struct AttachmentDownloaderImpl::DownloadState {
  public:
   DownloadState(const AttachmentId& attachment_id,
                 const AttachmentUrl& attachment_url);
 
   AttachmentId attachment_id;
   AttachmentUrl attachment_url;
   // |access_token| needed to invalidate if downloading attachment fails with
   // HTTP_UNAUTHORIZED.
   std::string access_token;
-  scoped_ptr<net::URLFetcher> url_fetcher;
+  std::unique_ptr<net::URLFetcher> url_fetcher;
   std::vector<DownloadCallback> user_callbacks;
   base::TimeTicks start_time;
 };
 
 AttachmentDownloaderImpl::DownloadState::DownloadState(
     const AttachmentId& attachment_id,
     const AttachmentUrl& attachment_url)
     : attachment_id(attachment_id), attachment_url(attachment_url) {
 }
 
@@ skipping 30 matching lines @@
     const DownloadCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   AttachmentUrl url = AttachmentUploaderImpl::GetURLForAttachmentId(
                           sync_service_url_, attachment_id).spec();
 
   StateMap::iterator iter = state_map_.find(url);
   if (iter == state_map_.end()) {
     // There is no request started for this attachment id. Let's create
     // DownloadState and request access token for it.
-    scoped_ptr<DownloadState> new_download_state(
+    std::unique_ptr<DownloadState> new_download_state(
         new DownloadState(attachment_id, url));
     iter = state_map_.add(url, std::move(new_download_state)).first;
     RequestAccessToken(iter->second);
   }
   DownloadState* download_state = iter->second;
   DCHECK(download_state->attachment_id == attachment_id);
   download_state->user_callbacks.push_back(callback);
 }
 
 void AttachmentDownloaderImpl::OnGetTokenSuccess(
@@ skipping 96 matching lines @@
   } else if (response_code == net::HTTP_FORBIDDEN) {
     // User is not allowed to use attachments.  Retrying won't help.
     result = DOWNLOAD_UNSPECIFIED_ERROR;
   } else if (response_code == net::URLFetcher::RESPONSE_CODE_INVALID) {
     result = DOWNLOAD_TRANSIENT_ERROR;
   }
   ReportResult(download_state, result, attachment_data);
   state_map_.erase(iter);
 }
 
-scoped_ptr<net::URLFetcher> AttachmentDownloaderImpl::CreateFetcher(
+std::unique_ptr<net::URLFetcher> AttachmentDownloaderImpl::CreateFetcher(
     const AttachmentUrl& url,
     const std::string& access_token) {
-  scoped_ptr<net::URLFetcher> url_fetcher =
+  std::unique_ptr<net::URLFetcher> url_fetcher =
       net::URLFetcher::Create(GURL(url), net::URLFetcher::GET, this);
   AttachmentUploaderImpl::ConfigureURLFetcherCommon(
       url_fetcher.get(), access_token, raw_store_birthday_, model_type_,
       url_request_context_getter_.get());
   return url_fetcher;
 }
 
 void AttachmentDownloaderImpl::RequestAccessToken(
     DownloadState* download_state) {
   requests_waiting_for_access_token_.push_back(download_state);
   // Start access token request if there is no active one.
   if (access_token_request_ == NULL) {
     access_token_request_ = OAuth2TokenServiceRequest::CreateAndStart(
         token_service_provider_.get(), account_id_, oauth2_scopes_, this);
   }
 }
 
 void AttachmentDownloaderImpl::ReportResult(
     const DownloadState& download_state,
     const DownloadResult& result,
     const scoped_refptr<base::RefCountedString>& attachment_data) {
   std::vector<DownloadCallback>::const_iterator iter;
   for (iter = download_state.user_callbacks.begin();
        iter != download_state.user_callbacks.end();
        ++iter) {
-    scoped_ptr<Attachment> attachment;
+    std::unique_ptr<Attachment> attachment;
     if (result == DOWNLOAD_SUCCESS) {
       attachment.reset(new Attachment(Attachment::CreateFromParts(
           download_state.attachment_id, attachment_data)));
     }
 
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(*iter, result, base::Passed(&attachment)));
   }
 }
 
@@ skipping 31 matching lines @@
 
   if (crc32c_raw.size() != sizeof(*crc32c))
     return false;
 
   *crc32c =
       base::NetToHost32(*reinterpret_cast<const uint32_t*>(crc32c_raw.c_str()));
   return true;
 }
 
 }  // namespace syncer