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

components/search_provider_logos/logo_cache.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_cache.h"
 
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 
 namespace {
 
 // The cached logo metadata is persisted as JSON using these keys.
@@ skipping 58 matching lines @@
   return metadata_.get();
 }
 
 void LogoCache::SetCachedLogo(const EncodedLogo* logo) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scoped_ptr<LogoMetadata> metadata;
   if (logo) {
     metadata.reset(new LogoMetadata(logo->metadata));
     logo_num_bytes_ = static_cast<int>(logo->encoded_image->size());
   }
-  UpdateMetadata(metadata.Pass());
+  UpdateMetadata(std::move(metadata));
   WriteLogo(logo ? logo->encoded_image : NULL);
 }
 
 scoped_ptr<EncodedLogo> LogoCache::GetCachedLogo() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   ReadMetadataIfNeeded();
   if (!metadata_)
     return scoped_ptr<EncodedLogo>();
 
   scoped_refptr<base::RefCountedString> encoded_image =
       new base::RefCountedString();
   if (!base::ReadFileToString(GetLogoPath(), &encoded_image->data())) {
     UpdateMetadata(scoped_ptr<LogoMetadata>());
     return scoped_ptr<EncodedLogo>();
   }
 
   if (encoded_image->size() != static_cast<size_t>(logo_num_bytes_)) {
     // Delete corrupt metadata and logo.
     DeleteLogoAndMetadata();
     UpdateMetadata(scoped_ptr<LogoMetadata>());
     return scoped_ptr<EncodedLogo>();
   }
 
   scoped_ptr<EncodedLogo> logo(new EncodedLogo());
   logo->encoded_image = encoded_image;
   logo->metadata = *metadata_;
-  return logo.Pass();
+  return logo;
 }
 
 // static
 scoped_ptr<LogoMetadata> LogoCache::LogoMetadataFromString(
     const std::string& str, int* logo_num_bytes) {
   scoped_ptr<base::Value> value = base::JSONReader::Read(str);
   base::DictionaryValue* dict;
   if (!value || !value->GetAsDictionary(&dict))
     return scoped_ptr<LogoMetadata>();
 
   scoped_ptr<LogoMetadata> metadata(new LogoMetadata());
   if (!dict->GetString(kSourceUrlKey, &metadata->source_url) ||
       !dict->GetString(kFingerprintKey, &metadata->fingerprint) ||
       !dict->GetString(kOnClickURLKey, &metadata->on_click_url) ||
       !dict->GetString(kAltTextKey, &metadata->alt_text) ||
       !dict->GetString(kAnimatedUrlKey, &metadata->animated_url) ||
       !dict->GetString(kMimeTypeKey, &metadata->mime_type) ||
       !dict->GetBoolean(kCanShowAfterExpirationKey,
                         &metadata->can_show_after_expiration) ||
       !dict->GetInteger(kNumBytesKey, logo_num_bytes) ||
       !GetTimeValue(*dict, kExpirationTimeKey, &metadata->expiration_time)) {
     return scoped_ptr<LogoMetadata>();
   }
 
-  return metadata.Pass();
+  return metadata;
 }
 
 // static
 void LogoCache::LogoMetadataToString(const LogoMetadata& metadata,
                                      int num_bytes,
                                      std::string* str) {
   base::DictionaryValue dict;
   dict.SetString(kSourceUrlKey, metadata.source_url);
   dict.SetString(kFingerprintKey, metadata.fingerprint);
   dict.SetString(kOnClickURLKey, metadata.on_click_url);
   dict.SetString(kAltTextKey, metadata.alt_text);
   dict.SetString(kAnimatedUrlKey, metadata.animated_url);
   dict.SetString(kMimeTypeKey, metadata.mime_type);
   dict.SetBoolean(kCanShowAfterExpirationKey,
                   metadata.can_show_after_expiration);
   dict.SetInteger(kNumBytesKey, num_bytes);
   SetTimeValue(dict, kExpirationTimeKey, metadata.expiration_time);
   base::JSONWriter::Write(dict, str);
 }
 
 base::FilePath LogoCache::GetLogoPath() {
   return cache_directory_.Append(FILE_PATH_LITERAL("logo"));
 }
 
 base::FilePath LogoCache::GetMetadataPath() {
   return cache_directory_.Append(FILE_PATH_LITERAL("metadata"));
 }
 
 void LogoCache::UpdateMetadata(scoped_ptr<LogoMetadata> metadata) {
-  metadata_ = metadata.Pass();
+  metadata_ = std::move(metadata);
   metadata_is_valid_ = true;
 }
 
 void LogoCache::ReadMetadataIfNeeded() {
   if (metadata_is_valid_)
     return;
 
   scoped_ptr<LogoMetadata> metadata;
   base::FilePath metadata_path = GetMetadataPath();
   std::string str;
   if (base::ReadFileToString(metadata_path, &str)) {
     metadata = LogoMetadataFromString(str, &logo_num_bytes_);
     if (!metadata) {
       // Delete corrupt metadata and logo.
       DeleteLogoAndMetadata();
     }
   }
 
-  UpdateMetadata(metadata.Pass());
+  UpdateMetadata(std::move(metadata));
 }
 
 void LogoCache::WriteMetadata() {
   if (!EnsureCacheDirectoryExists())
     return;
 
   std::string str;
   LogoMetadataToString(*metadata_, logo_num_bytes_, &str);
   base::WriteFile(GetMetadataPath(), str.data(), static_cast<int>(str.size()));
 }
@@ skipping 32 matching lines @@
   base::DeleteFile(GetMetadataPath(), false);
 }
 
 bool LogoCache::EnsureCacheDirectoryExists() {
   if (base::DirectoryExists(cache_directory_))
     return true;
   return base::CreateDirectory(cache_directory_);
 }
 
 }  // namespace search_provider_logos