chrome/browser/password_manager: scoped_ptr -> unique_ptr

chrome/browser/password_manager/native_backend_kwallet_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_kwallet_x.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 150 matching lines @@
                  << "(" << count << "; realm: " << signon_realm << ")";
     }
     return false;
   }
 
   // We'll swap |converted_forms| with |*forms| on success, to make sure we
   // don't return partial results on failure.
   ScopedVector<autofill::PasswordForm> converted_forms;
   converted_forms.reserve(count);
   for (size_t i = 0; i < count; ++i) {
-    scoped_ptr<PasswordForm> form(new PasswordForm());
+    std::unique_ptr<PasswordForm> form(new PasswordForm());
     form->signon_realm.assign(signon_realm);
 
     int scheme = 0;
     int64_t date_created = 0;
     int type = 0;
     int generation_upload_status = 0;
     // Note that these will be read back in the order listed due to
     // short-circuit evaluation. This is important.
     if (!iter.ReadInt(&scheme) ||
         !ReadGURL(&iter, warn_only, &form->origin) ||
@@ skipping 213 matching lines @@
 
   dbus::MethodCall method_call(kKLauncherInterface,
                                "start_service_by_desktop_name");
   dbus::MessageWriter builder(&method_call);
   std::vector<std::string> empty;
   builder.AppendString(kwalletd_name_);  // serviceName
   builder.AppendArrayOfStrings(empty);   // urls
   builder.AppendArrayOfStrings(empty);   // envs
   builder.AppendString(std::string());   // startup_id
   builder.AppendBool(false);             // blind
-  scoped_ptr<dbus::Response> response(
-      klauncher->CallMethodAndBlock(
-          &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  std::unique_ptr<dbus::Response> response(klauncher->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
   if (!response.get()) {
     LOG(ERROR) << "Error contacting klauncher to start " << kwalletd_name_;
     return false;
   }
   dbus::MessageReader reader(response.get());
   int32_t ret = -1;
   std::string dbus_name;
   std::string error;
   int32_t pid = -1;
   if (!reader.PopInt32(&ret) || !reader.PopString(&dbus_name) ||
       !reader.PopString(&error) || !reader.PopInt32(&pid)) {
     LOG(ERROR) << "Error reading response from klauncher to start "
                << kwalletd_name_ << ": " << response->ToString();
     return false;
   }
   if (!error.empty() || ret) {
     LOG(ERROR) << "Error launching " << kwalletd_name_ << ": error '" << error
                << "' (code " << ret << ")";
     return false;
   }
 
   return true;
 }
 
 NativeBackendKWallet::InitResult NativeBackendKWallet::InitWallet() {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   {
     // Check that KWallet is enabled.
     dbus::MethodCall method_call(kKWalletInterface, "isEnabled");
-    scoped_ptr<dbus::Response> response(
-        kwallet_proxy_->CallMethodAndBlock(
-            &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+    std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
       LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (isEnabled)";
       return TEMPORARY_FAIL;
     }
     dbus::MessageReader reader(response.get());
     bool enabled = false;
     if (!reader.PopBool(&enabled)) {
       LOG(ERROR) << "Error reading response from " << kwalletd_name_
                  << " (isEnabled): " << response->ToString();
       return PERMANENT_FAIL;
     }
     // Not enabled? Don't use KWallet. But also don't warn here.
     if (!enabled) {
       VLOG(1) << kwalletd_name_ << " reports that KWallet is not enabled.";
       return PERMANENT_FAIL;
     }
   }
 
   {
     // Get the wallet name.
     dbus::MethodCall method_call(kKWalletInterface, "networkWallet");
-    scoped_ptr<dbus::Response> response(
-        kwallet_proxy_->CallMethodAndBlock(
-            &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+    std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
       LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (networkWallet)";
       return TEMPORARY_FAIL;
     }
     dbus::MessageReader reader(response.get());
     if (!reader.PopString(&wallet_name_)) {
       LOG(ERROR) << "Error reading response from " << kwalletd_name_
                  << " (networkWallet): " << response->ToString();
       return PERMANENT_FAIL;
     }
@@ skipping 166 matching lines @@
     ScopedVector<autofill::PasswordForm>* forms) {
   forms->clear();
   // Is there an entry in the wallet?
   {
     dbus::MethodCall method_call(kKWalletInterface, "hasEntry");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(wallet_handle);  // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(signon_realm);  // key
     builder.AppendString(app_name_);     // appid
-    scoped_ptr<dbus::Response> response(
-        kwallet_proxy_->CallMethodAndBlock(
-            &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+    std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
       LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (hasEntry)";
       return false;
     }
     dbus::MessageReader reader(response.get());
     bool has_entry = false;
     if (!reader.PopBool(&has_entry)) {
       LOG(ERROR) << "Error reading response from " << kwalletd_name_
                  << " (hasEntry): " << response->ToString();
       return false;
     }
     if (!has_entry) {
       // This is not an error. There just isn't a matching entry.
       return true;
     }
   }
 
   {
     dbus::MethodCall method_call(kKWalletInterface, "readEntry");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(wallet_handle);  // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(signon_realm);  // key
     builder.AppendString(app_name_);     // appid
-    scoped_ptr<dbus::Response> response(
-        kwallet_proxy_->CallMethodAndBlock(
-            &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+    std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
       LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (readEntry)";
       return false;
     }
     dbus::MessageReader reader(response.get());
     const uint8_t* bytes = nullptr;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&bytes, &length)) {
       LOG(ERROR) << "Error reading response from " << kwalletd_name_
                  << " (readEntry): " << response->ToString();
@@ skipping 67 matching lines @@
     int wallet_handle,
     ScopedVector<autofill::PasswordForm>* forms) {
   // We could probably also use readEntryList here.
   std::vector<std::string> realm_list;
   {
     dbus::MethodCall method_call(kKWalletInterface, "entryList");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(wallet_handle);  // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(app_name_);     // appid
-    scoped_ptr<dbus::Response> response(
-        kwallet_proxy_->CallMethodAndBlock(
-            &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+    std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
       LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (entryList)";
       return false;
     }
     dbus::MessageReader reader(response.get());
     if (!reader.PopArrayOfStrings(&realm_list)) {
       LOG(ERROR) << "Error reading response from " << kwalletd_name_
                  << "(entryList): " << response->ToString();
       return false;
     }
   }
 
   forms->clear();
   for (const std::string& signon_realm : realm_list) {
     dbus::MethodCall method_call(kKWalletInterface, "readEntry");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(wallet_handle);  // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(signon_realm);  // key
     builder.AppendString(app_name_);     // appid
-    scoped_ptr<dbus::Response> response(
-        kwallet_proxy_->CallMethodAndBlock(
-            &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+    std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
       LOG(ERROR) << "Error contacting " << kwalletd_name_ << "(readEntry)";
       return false;
     }
     dbus::MessageReader reader(response.get());
     const uint8_t* bytes = nullptr;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&bytes, &length)) {
       LOG(ERROR) << "Error reading response from " << kwalletd_name_
                  << " (readEntry): " << response->ToString();
@@ skipping 14 matching lines @@
     const std::string& signon_realm,
     int wallet_handle) {
   if (forms.empty()) {
     // No items left? Remove the entry from the wallet.
     dbus::MethodCall method_call(kKWalletInterface, "removeEntry");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(wallet_handle);  // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(signon_realm);  // key
     builder.AppendString(app_name_);     // appid
-    scoped_ptr<dbus::Response> response(
-        kwallet_proxy_->CallMethodAndBlock(
-            &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+    std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
       LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (removeEntry)";
       return kInvalidKWalletHandle;
     }
     dbus::MessageReader reader(response.get());
     int ret = 0;
     if (!reader.PopInt32(&ret)) {
       LOG(ERROR) << "Error reading response from " << kwalletd_name_
                  << " (removeEntry): " << response->ToString();
       return false;
     }
     if (ret != 0)
       LOG(ERROR) << "Bad return code " << ret << " from KWallet removeEntry";
     return ret == 0;
   }
 
   base::Pickle value;
   SerializeValue(forms, &value);
 
   dbus::MethodCall method_call(kKWalletInterface, "writeEntry");
   dbus::MessageWriter builder(&method_call);
   builder.AppendInt32(wallet_handle);  // handle
   builder.AppendString(folder_name_);  // folder
   builder.AppendString(signon_realm);  // key
   builder.AppendArrayOfBytes(static_cast<const uint8_t*>(value.data()),
                              value.size());  // value
   builder.AppendString(app_name_);     // appid
-  scoped_ptr<dbus::Response> response(
-      kwallet_proxy_->CallMethodAndBlock(
-          &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
   if (!response.get()) {
     LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (writeEntry)";
     return kInvalidKWalletHandle;
   }
   dbus::MessageReader reader(response.get());
   int ret = 0;
   if (!reader.PopInt32(&ret)) {
     LOG(ERROR) << "Error reading response from " << kwalletd_name_
                << " (writeEntry): " << response->ToString();
     return false;
@@ skipping 15 matching lines @@
     return false;
 
   // We could probably also use readEntryList here.
   std::vector<std::string> realm_list;
   {
     dbus::MethodCall method_call(kKWalletInterface, "entryList");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(wallet_handle);  // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(app_name_);     // appid
-    scoped_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+    std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
       LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (entryList)";
       return false;
     }
     dbus::MessageReader reader(response.get());
     dbus::MessageReader array(response.get());
     if (!reader.PopArray(&array)) {
       LOG(ERROR) << "Error reading response from " << kwalletd_name_
                  << " (entryList): " << response->ToString();
@@ skipping 12 matching lines @@
 
   bool ok = true;
   for (size_t i = 0; i < realm_list.size(); ++i) {
     const std::string& signon_realm = realm_list[i];
     dbus::MethodCall method_call(kKWalletInterface, "readEntry");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(wallet_handle);  // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(signon_realm);  // key
     builder.AppendString(app_name_);     // appid
-    scoped_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+    std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
       LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (readEntry)";
       continue;
     }
     dbus::MessageReader reader(response.get());
     const uint8_t* bytes = nullptr;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&bytes, &length)) {
       LOG(ERROR) << "Error reading response from " << kwalletd_name_
@@ skipping 76 matching lines @@
 
   // Open the wallet.
   // TODO(mdm): Are we leaking these handles? Find out.
   int32_t handle = kInvalidKWalletHandle;
   {
     dbus::MethodCall method_call(kKWalletInterface, "open");
     dbus::MessageWriter builder(&method_call);
     builder.AppendString(wallet_name_);  // wallet
     builder.AppendInt64(0);              // wid
     builder.AppendString(app_name_);     // appid
-    scoped_ptr<dbus::Response> response(
-        kwallet_proxy_->CallMethodAndBlock(
-            &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+    std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
       LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (open)";
       return kInvalidKWalletHandle;
     }
     dbus::MessageReader reader(response.get());
     if (!reader.PopInt32(&handle)) {
       LOG(ERROR) << "Error reading response from " << kwalletd_name_
                  << " (open): " << response->ToString();
       return kInvalidKWalletHandle;
     }
     if (handle == kInvalidKWalletHandle) {
       LOG(ERROR) << "Error obtaining KWallet handle";
       return kInvalidKWalletHandle;
     }
   }
 
   // Check if our folder exists.
   bool has_folder = false;
   {
     dbus::MethodCall method_call(kKWalletInterface, "hasFolder");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(handle);         // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(app_name_);     // appid
-    scoped_ptr<dbus::Response> response(
-        kwallet_proxy_->CallMethodAndBlock(
-            &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+    std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
       LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (hasFolder)";
       return kInvalidKWalletHandle;
     }
     dbus::MessageReader reader(response.get());
     if (!reader.PopBool(&has_folder)) {
       LOG(ERROR) << "Error reading response from " << kwalletd_name_
                  << " (hasFolder): " << response->ToString();
       return kInvalidKWalletHandle;
     }
   }
 
   // Create it if it didn't.
   if (!has_folder) {
     dbus::MethodCall method_call(kKWalletInterface, "createFolder");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(handle);         // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(app_name_);     // appid
-    scoped_ptr<dbus::Response> response(
-        kwallet_proxy_->CallMethodAndBlock(
-            &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+    std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
       LOG(ERROR) << "Error contacting << " << kwalletd_name_
                  << " (createFolder)";
       return kInvalidKWalletHandle;
     }
     dbus::MessageReader reader(response.get());
     bool success = false;
     if (!reader.PopBool(&success)) {
       LOG(ERROR) << "Error reading response from " << kwalletd_name_
                  << " (createFolder): " << response->ToString();
       return kInvalidKWalletHandle;
     }
     if (!success) {
       LOG(ERROR) << "Error creating KWallet folder";
       return kInvalidKWalletHandle;
     }
   }
 
   return handle;
 }
 
 std::string NativeBackendKWallet::GetProfileSpecificFolderName() const {
   // Originally, the folder name was always just "Chrome Form Data".
   // Now we use it to distinguish passwords for different profiles.
   return base::StringPrintf("%s (%d)", kKWalletFolder, profile_id_);
 }