chrome/browser/password_manager: scoped_ptr -> unique_ptr

chrome/browser/password_manager/native_backend_gnome_x.cc

 // Copyright (c) 2012 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_gnome_x.h"
 
 #include <dlfcn.h>
 #include <gnome-keyring.h>
 #include <stddef.h>
 #include <stdint.h>
+
 #include <map>
+#include <memory>
 #include <string>
 #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/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/password_manager/core/browser/password_manager_metrics_util.h"
@@ skipping 74 matching lines @@
 
 #endif  // defined(DLOPEN_GNOME_KEYRING)
 
 namespace {
 
 const char kGnomeKeyringAppString[] = "chrome";
 
 // Convert the attributes of a given keyring entry into a new PasswordForm.
 // Note: does *not* get the actual password, as that is not a key attribute!
 // Returns NULL if the attributes are for the wrong application.
-scoped_ptr<PasswordForm> FormFromAttributes(GnomeKeyringAttributeList* attrs) {
+std::unique_ptr<PasswordForm> FormFromAttributes(
+    GnomeKeyringAttributeList* attrs) {
   // Read the string and int attributes into the appropriate map.
   std::map<std::string, std::string> string_attr_map;
   std::map<std::string, uint32_t> uint_attr_map;
   for (guint i = 0; i < attrs->len; ++i) {
     GnomeKeyringAttribute attr = gnome_keyring_attribute_list_index(attrs, i);
     if (attr.type == GNOME_KEYRING_ATTRIBUTE_TYPE_STRING)
       string_attr_map[attr.name] = attr.value.string;
     else if (attr.type == GNOME_KEYRING_ATTRIBUTE_TYPE_UINT32)
       uint_attr_map[attr.name] = attr.value.integer;
   }
   // Check to make sure this is a password we care about.
   const std::string& app_value = string_attr_map["application"];
   if (!base::StringPiece(app_value).starts_with(kGnomeKeyringAppString))
-    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(string_attr_map["origin_url"]);
   form->action = GURL(string_attr_map["action_url"]);
   form->username_element = UTF8ToUTF16(string_attr_map["username_element"]);
   form->username_value = UTF8ToUTF16(string_attr_map["username_value"]);
   form->password_element = UTF8ToUTF16(string_attr_map["password_element"]);
   form->submit_element = UTF8ToUTF16(string_attr_map["submit_element"]);
   form->signon_realm = string_attr_map["signon_realm"];
   form->ssl_valid = uint_attr_map["ssl_valid"];
   form->preferred = uint_attr_map["preferred"];
   int64_t date_created = 0;
@@ skipping 48 matching lines @@
       password_manager::PSL_DOMAIN_MATCH_NONE;
   const bool allow_psl_match =
       lookup_form && password_manager::ShouldPSLDomainMatchingApply(
                          password_manager::GetRegistryControlledDomain(
                              GURL(lookup_form->signon_realm)));
   for (GList* element = g_list_first(found); element;
        element = g_list_next(element)) {
     GnomeKeyringFound* data = static_cast<GnomeKeyringFound*>(element->data);
     GnomeKeyringAttributeList* attrs = data->attributes;
 
-    scoped_ptr<PasswordForm> form(FormFromAttributes(attrs));
+    std::unique_ptr<PasswordForm> form(FormFromAttributes(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;  // Ignore non-HTML matches.
         // 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)) {
           psl_domain_match_metric = password_manager::PSL_DOMAIN_MATCH_FOUND;
@@ skipping 90 matching lines @@
   GnomeKeyringResult WaitResult(ScopedVector<PasswordForm>* forms);
 
  private:
   struct GnomeKeyringAttributeListFreeDeleter {
     inline void operator()(void* list) const {
       gnome_keyring_attribute_list_free(
           static_cast<GnomeKeyringAttributeList*>(list));
     }
   };
 
-  typedef scoped_ptr<GnomeKeyringAttributeList,
-                     GnomeKeyringAttributeListFreeDeleter> ScopedAttributeList;
+  typedef std::unique_ptr<GnomeKeyringAttributeList,
+                          GnomeKeyringAttributeListFreeDeleter>
+      ScopedAttributeList;
 
   // Helper methods to abbreviate Gnome Keyring long API names.
   static void AppendString(ScopedAttributeList* list,
                            const char* name,
                            const char* value);
   static void AppendString(ScopedAttributeList* list,
                            const char* name,
                            const std::string& value);
   static void AppendUint32(ScopedAttributeList* list,
                            const char* name,
@@ skipping 11 matching lines @@
   base::WaitableEvent event_;
   GnomeKeyringResult result_;
   ScopedVector<PasswordForm> forms_;
   // If the credential search is specified by a single form and needs to use PSL
   // matching, then the specifying form is stored in |lookup_form_|. If PSL
   // matching is used to find a result, then the results signon realm, origin
   // and action are stored are replaced by those of |lookup_form_|.
   // Additionally, |lookup_form_->signon_realm| is also used to narrow down the
   // found logins to those which indeed PSL-match the look-up. And finally,
   // |lookup_form_| set to NULL means that PSL matching is not required.
-  scoped_ptr<PasswordForm> lookup_form_;
+  std::unique_ptr<PasswordForm> lookup_form_;
 };
 
 void GKRMethod::AddLogin(const PasswordForm& form, const char* app_string) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   int64_t date_created = form.date_created.ToInternalValue();
   // If we are asked to save a password with 0 date, use the current time.
   // We don't want to actually save passwords as though on January 1, 1601.
   if (!date_created)
     date_created = base::Time::Now().ToInternalValue();
   int64_t date_synced = form.date_synced.ToInternalValue();
@@ skipping 481 matching lines @@
   ScopedVector<PasswordForm> forms;
   if (!GetLoginsBetween(get_begin, get_end, date_to_compare, &forms))
     return false;
 
   for (size_t i = 0; i < forms.size(); ++i) {
     if (!RemoveLogin(*forms[i], changes))
       return false;
   }
   return true;
 }