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

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 <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
+#include "sync/internal_api/public/attachments/attachment_downloader_impl.h"
 #include "sync/internal_api/public/attachments/attachment_uploader_impl.h"

[Nicolas Zea, 2015/12/18 23:46:54]

This should remain up top

[dcheng, 2015/12/20 00:27:53]

Hmm. I have a script that does this all automatically. Let me think about how to
adapt it for this specific use case (since it'll be useful in //content as well)

 #include "sync/internal_api/public/attachments/attachment_util.h"
 #include "sync/protocol/sync.pb.h"
 #include "url/gurl.h"
 
 namespace syncer {
 
 struct AttachmentDownloaderImpl::DownloadState {
  public:
   DownloadState(const AttachmentId& attachment_id,
                 const AttachmentUrl& attachment_url);
@@ skipping 49 matching lines @@
 
   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(
         new DownloadState(attachment_id, url));
-    iter = state_map_.add(url, new_download_state.Pass()).first;
+    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(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
   DCHECK(CalledOnValidThread());
   DCHECK(request == access_token_request_.get());
   access_token_request_.reset();
   StateList::const_iterator iter;
   // Start downloads for all download requests waiting for access token.
   for (iter = requests_waiting_for_access_token_.begin();
        iter != requests_waiting_for_access_token_.end();
        ++iter) {
     DownloadState* download_state = *iter;
     download_state->access_token = access_token;
     download_state->url_fetcher =
-        CreateFetcher(download_state->attachment_url, access_token).Pass();
+        CreateFetcher(download_state->attachment_url, access_token);
     download_state->start_time = base::TimeTicks::Now();
     download_state->url_fetcher->Start();
   }
   requests_waiting_for_access_token_.clear();
 }
 
 void AttachmentDownloaderImpl::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   DCHECK(CalledOnValidThread());
@@ skipping 79 matching lines @@
 }
 
 scoped_ptr<net::URLFetcher> AttachmentDownloaderImpl::CreateFetcher(
     const AttachmentUrl& url,
     const std::string& access_token) {
   scoped_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.Pass();
+  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);
   }
@@ skipping 52 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