chrome/browser/password_manager: scoped_ptr -> unique_ptr

chrome/browser/password_manager/native_backend_libsecret.cc

 // Copyright (c) 2015 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/password_manager/native_backend_libsecret.h"
 
 #include <dlfcn.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <list>
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/password_manager/core/browser/password_manager_metrics_util.h"
 #include "components/password_manager/core/browser/password_manager_util.h"
 #include "url/origin.h"
 
 using autofill::PasswordForm;
 using base::UTF8ToUTF16;
@@ skipping 112 matching lines @@
     return uint32_t();
   uint32_t result;
   bool value_ok = base::StringToUint(static_cast<char*>(value), &result);
   DCHECK(value_ok);
   return result;
 }
 
 // Convert the attributes into a new PasswordForm.
 // Note: does *not* get the actual password, as that is not a key attribute!
 // Returns nullptr if the attributes are for the wrong application.
-scoped_ptr<PasswordForm> FormOutOfAttributes(GHashTable* attrs) {
+std::unique_ptr<PasswordForm> FormOutOfAttributes(GHashTable* attrs) {
   base::StringPiece app_value = GetStringFromAttributes(attrs, "application");
   if (!app_value.starts_with(kLibsecretAppString))
-    return scoped_ptr<PasswordForm>();
+    return std::unique_ptr<PasswordForm>();
 
-  scoped_ptr<PasswordForm> form(new PasswordForm());
+  std::unique_ptr<PasswordForm> form(new PasswordForm());
   form->origin = GURL(GetStringFromAttributes(attrs, "origin_url"));
   form->action = GURL(GetStringFromAttributes(attrs, "action_url"));
   form->username_element =
       UTF8ToUTF16(GetStringFromAttributes(attrs, "username_element"));
   form->username_value =
       UTF8ToUTF16(GetStringFromAttributes(attrs, "username_value"));
   form->password_element =
       UTF8ToUTF16(GetStringFromAttributes(attrs, "password_element"));
   form->submit_element =
       UTF8ToUTF16(GetStringFromAttributes(attrs, "submit_element"));
@@ skipping 474 matching lines @@
        element = g_list_next(element)) {
     SecretItem* secretItem = static_cast<SecretItem*>(element->data);
     LibsecretLoader::secret_item_load_secret_sync(secretItem, nullptr, &error);
     if (error) {
       LOG(ERROR) << "Unable to load secret item" << error->message;
       g_error_free(error);
       error = nullptr;
       continue;
     }
     GHashTable* attrs = secret_item_get_attributes(secretItem);
-    scoped_ptr<PasswordForm> form(FormOutOfAttributes(attrs));
+    std::unique_ptr<PasswordForm> form(FormOutOfAttributes(attrs));
     g_hash_table_unref(attrs);
     if (form) {
       if (lookup_form && form->signon_realm != lookup_form->signon_realm) {
         if (lookup_form->scheme != PasswordForm::SCHEME_HTML ||
             form->scheme != PasswordForm::SCHEME_HTML)
           continue;
         // This is not an exact match, we try PSL matching and federated match.
         if (allow_psl_match &&
             password_manager::IsPublicSuffixDomainMatch(
                 form->signon_realm, lookup_form->signon_realm)) {
@@ skipping 22 matching lines @@
   if (lookup_form) {
     UMA_HISTOGRAM_ENUMERATION("PasswordManager.PslDomainMatchTriggering",
                               allow_psl_match
                                   ? psl_domain_match_metric
                                   : password_manager::PSL_DOMAIN_MATCH_NOT_USED,
                               password_manager::PSL_DOMAIN_MATCH_COUNT);
   }
   g_list_free(found);
   return forms;
 }