Convert Pass()→std::move() in //components/[n-z]*

components/search_provider_logos/logo_tracker.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 "components/search_provider_logos/logo_tracker.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/default_clock.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
@@ skipping 30 matching lines @@
   const LogoMetadata* metadata = logo_cache->GetCachedLogoMetadata();
   if (!metadata)
     return scoped_ptr<EncodedLogo>();
 
   if (metadata->source_url != logo_url.spec() ||
       !IsLogoOkToShow(*metadata, now)) {
     logo_cache->SetCachedLogo(NULL);
     return scoped_ptr<EncodedLogo>();
   }
 
-  return logo_cache->GetCachedLogo().Pass();
+  return logo_cache->GetCachedLogo();
 }
 
 void DeleteLogoCacheOnFileThread(LogoCache* logo_cache) {
   delete logo_cache;
 }
 
 }  // namespace
 
 LogoTracker::LogoTracker(
     base::FilePath cached_logo_directory,
     scoped_refptr<base::SequencedTaskRunner> file_task_runner,
     scoped_refptr<base::TaskRunner> background_task_runner,
     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     scoped_ptr<LogoDelegate> delegate)
     : is_idle_(true),
       is_cached_logo_valid_(false),
-      logo_delegate_(delegate.Pass()),
+      logo_delegate_(std::move(delegate)),
       logo_cache_(new LogoCache(cached_logo_directory)),
       clock_(new base::DefaultClock()),
       file_task_runner_(file_task_runner),
       background_task_runner_(background_task_runner),
       request_context_getter_(request_context_getter),
       weak_ptr_factory_(this) {}
 
 LogoTracker::~LogoTracker() {
   ReturnToIdle(kDownloadOutcomeNotTracked);
   file_task_runner_->PostTask(
@@ skipping 42 matching lines @@
 }
 
 void LogoTracker::SetLogoCacheForTests(scoped_ptr<LogoCache> cache) {
   DCHECK(cache);
   file_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DeleteLogoCacheOnFileThread, logo_cache_));
   logo_cache_ = cache.release();
 }
 
 void LogoTracker::SetClockForTests(scoped_ptr<base::Clock> clock) {
-  clock_ = clock.Pass();
+  clock_ = std::move(clock);
 }
 
 void LogoTracker::ReturnToIdle(int outcome) {
   if (outcome != kDownloadOutcomeNotTracked) {
     UMA_HISTOGRAM_ENUMERATION("NewTabPage.LogoDownloadOutcome", outcome,
                               DOWNLOAD_OUTCOME_COUNT);
   }
   // Cancel the current asynchronous operation, if any.
   fetcher_.reset();
   weak_ptr_factory_.InvalidateWeakPtrs();
@@ skipping 71 matching lines @@
 }
 
 void LogoTracker::OnFreshLogoParsed(bool* parsing_failed,
                                     scoped_ptr<EncodedLogo> logo) {
   DCHECK(!is_idle_);
 
   if (logo)
     logo->metadata.source_url = logo_url_.spec();
 
   if (!logo || !logo->encoded_image.get()) {
-    OnFreshLogoAvailable(logo.Pass(), *parsing_failed, SkBitmap());
+    OnFreshLogoAvailable(std::move(logo), *parsing_failed, SkBitmap());
   } else {
     // Store the value of logo->encoded_image for use below. This ensures that
     // logo->encoded_image is evaulated before base::Passed(&logo), which sets
     // logo to NULL.
     scoped_refptr<base::RefCountedString> encoded_image = logo->encoded_image;
     logo_delegate_->DecodeUntrustedImage(
         encoded_image,
         base::Bind(&LogoTracker::OnFreshLogoAvailable,
                    weak_ptr_factory_.GetWeakPtr(),
                    base::Passed(&logo),
@@ skipping 38 matching lines @@
       else
         download_outcome = DOWNLOAD_OUTCOME_NO_LOGO_TODAY;
     }
 
     // Notify observers if a new logo was fetched, or if the new logo is NULL
     // but the cached logo was non-NULL.
     if (logo || cached_logo_) {
       FOR_EACH_OBSERVER(LogoObserver,
                         logo_observers_,
                         OnLogoAvailable(logo.get(), false));
-      SetCachedLogo(encoded_logo.Pass());
+      SetCachedLogo(std::move(encoded_logo));
     }
   }
 
   DCHECK(download_outcome != kDownloadOutcomeNotTracked);
   ReturnToIdle(download_outcome);
 }
 
 void LogoTracker::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(!is_idle_);
   scoped_ptr<net::URLFetcher> cleanup_fetcher(fetcher_.release());
@@ skipping 22 matching lines @@
 void LogoTracker::OnURLFetchDownloadProgress(const net::URLFetcher* source,
                                              int64_t current,
                                              int64_t total) {
   if (total > kMaxDownloadBytes || current > kMaxDownloadBytes) {
     LOG(WARNING) << "Search provider logo exceeded download size limit";
     ReturnToIdle(DOWNLOAD_OUTCOME_DOWNLOAD_FAILED);
   }
 }
 
 }  // namespace search_provider_logos