Convert Pass()→std::move() in //chrome/browser/extensions

chrome/browser/extensions/install_signer.cc

 // Copyright 2013 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 "chrome/browser/extensions/install_signer.h"
 
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 165 matching lines @@
     const base::DictionaryValue& value) {
 
   scoped_ptr<InstallSignature> result(new InstallSignature);
 
   // For now we don't want to support any backwards compability, but in the
   // future if we do, we would want to put the migration code here.
   int format_version = 0;
   if (!value.GetInteger(kSignatureFormatVersionKey, &format_version) ||
       format_version != kSignatureFormatVersion) {
     result.reset();
-    return result.Pass();
+    return result;
   }
 
   std::string salt_base64;
   std::string signature_base64;
   if (!value.GetString(kExpireDateKey, &result->expire_date) ||
       !value.GetString(kSaltKey, &salt_base64) ||
       !value.GetString(kSignatureKey, &signature_base64) ||
       !base::Base64Decode(salt_base64, &result->salt) ||
       !base::Base64Decode(signature_base64, &result->signature)) {
     result.reset();
-    return result.Pass();
+    return result;
   }
 
   // Note: earlier versions of the code did not write out a timestamp value
   // so older entries will not necessarily have this.
   if (value.HasKey(kTimestampKey)) {
     std::string timestamp;
     int64_t timestamp_value = 0;
     if (!value.GetString(kTimestampKey, &timestamp) ||
         !base::StringToInt64(timestamp, &timestamp_value)) {
       result.reset();
-      return result.Pass();
+      return result;
     }
     result->timestamp = base::Time::FromInternalValue(timestamp_value);
   }
 
   if (!GetExtensionIdSet(value, kIdsKey, &result->ids) ||
       !GetExtensionIdSet(value, kInvalidIdsKey, &result->invalid_ids)) {
     result.reset();
-    return result.Pass();
+    return result;
   }
 
-  return result.Pass();
+  return result;
 }
 
 
 InstallSigner::InstallSigner(net::URLRequestContextGetter* context_getter,
                              const ExtensionIdSet& ids)
     : ids_(ids), context_getter_(context_getter) {
 }
 
 InstallSigner::~InstallSigner() {
 }
@@ skipping 262 matching lines @@
     result->timestamp = request_start_time_;
     bool verified = VerifySignature(*result);
     UMA_HISTOGRAM_BOOLEAN("ExtensionInstallSigner.ResultWasValid", verified);
     UMA_HISTOGRAM_COUNTS_100("ExtensionInstallSigner.InvalidCount",
                              invalid_ids.size());
     if (!verified)
       result.reset();
   }
 
   if (!callback_.is_null())
-    callback_.Run(result.Pass());
+    callback_.Run(std::move(result));
 }
 
 
 }  // namespace extensions