components/password_manager: scoped_ptr -> unique_ptr

components/password_manager/content/renderer/credential_manager_client_browsertest.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 <stdint.h>
 
 #include <tuple>
 
 #include "components/password_manager/content/common/credential_manager_messages.h"
 #include "components/password_manager/content/renderer/credential_manager_client.h"
@@ skipping 73 matching lines @@
     sink().ClearMessages();
     return request_id != -1;
   }
 
   bool callback_errored() const { return callback_errored_; }
   void set_callback_errored(bool state) { callback_errored_ = state; }
   bool callback_succeeded() const { return callback_succeeded_; }
   void set_callback_succeeded(bool state) { callback_succeeded_ = state; }
 
  protected:
-  scoped_ptr<CredentialManagerClient> client_;
+  std::unique_ptr<CredentialManagerClient> client_;
 
   // True if a message's callback's 'onSuccess'/'onError' methods were called,
   // false otherwise. We put these on the test object rather than on the
   // Test*Callbacks objects because ownership of those objects passes into the
   // client, which destroys the callbacks after calling them to resolve the
   // pending Blink-side Promise.
   bool callback_errored_;
   bool callback_succeeded_;
 
-  scoped_ptr<blink::WebPasswordCredential> credential_;
+  std::unique_ptr<blink::WebPasswordCredential> credential_;
 };
 
 class TestNotificationCallbacks
     : public blink::WebCredentialManagerClient::NotificationCallbacks {
  public:
   explicit TestNotificationCallbacks(CredentialManagerClientTest* test)
       : test_(test) {}
 
   ~TestNotificationCallbacks() override {}
 
@@ skipping 27 matching lines @@
   CredentialManagerClientTest* test_;
 };
 
 }  // namespace
 
 TEST_F(CredentialManagerClientTest, SendStore) {
   int request_id;
   EXPECT_FALSE(
       ExtractRequestId(CredentialManagerHostMsg_Store::ID, request_id));
 
-  scoped_ptr<TestNotificationCallbacks> callbacks(
+  std::unique_ptr<TestNotificationCallbacks> callbacks(
       new TestNotificationCallbacks(this));
   client_->dispatchStore(*credential(), callbacks.release());
 
   EXPECT_TRUE(ExtractRequestId(CredentialManagerHostMsg_Store::ID, request_id));
 
   client_->OnAcknowledgeStore(request_id);
   EXPECT_TRUE(callback_succeeded());
   EXPECT_FALSE(callback_errored());
 }
 
 TEST_F(CredentialManagerClientTest, SendRequestUserMediation) {
   int request_id;
   EXPECT_FALSE(ExtractRequestId(
       CredentialManagerHostMsg_RequireUserMediation::ID, request_id));
 
-  scoped_ptr<TestNotificationCallbacks> callbacks(
+  std::unique_ptr<TestNotificationCallbacks> callbacks(
       new TestNotificationCallbacks(this));
   client_->dispatchRequireUserMediation(callbacks.release());
 
   EXPECT_TRUE(ExtractRequestId(
       CredentialManagerHostMsg_RequireUserMediation::ID, request_id));
 
   client_->OnAcknowledgeRequireUserMediation(request_id);
   EXPECT_TRUE(callback_succeeded());
   EXPECT_FALSE(callback_errored());
 }
 
 TEST_F(CredentialManagerClientTest, SendRequestCredential) {
   int request_id;
   EXPECT_FALSE(ExtractRequestId(CredentialManagerHostMsg_RequestCredential::ID,
                                 request_id));
 
-  scoped_ptr<TestRequestCallbacks> callbacks(new TestRequestCallbacks(this));
+  std::unique_ptr<TestRequestCallbacks> callbacks(
+      new TestRequestCallbacks(this));
   std::vector<GURL> federations;
   client_->dispatchGet(false, true, federations, callbacks.release());
 
   EXPECT_TRUE(ExtractRequestId(CredentialManagerHostMsg_RequestCredential::ID,
                                request_id));
 
   CredentialInfo info;
   info.type = CredentialType::CREDENTIAL_TYPE_PASSWORD;
   client_->OnSendCredential(request_id, info);
   EXPECT_TRUE(callback_succeeded());
   EXPECT_FALSE(callback_errored());
 }
 
 TEST_F(CredentialManagerClientTest, SendRequestCredentialEmpty) {
   int request_id;
   EXPECT_FALSE(ExtractRequestId(CredentialManagerHostMsg_RequestCredential::ID,
                                 request_id));
 
-  scoped_ptr<TestRequestCallbacks> callbacks(new TestRequestCallbacks(this));
+  std::unique_ptr<TestRequestCallbacks> callbacks(
+      new TestRequestCallbacks(this));
   std::vector<GURL> federations;
   client_->dispatchGet(false, true, federations, callbacks.release());
 
   EXPECT_TRUE(ExtractRequestId(CredentialManagerHostMsg_RequestCredential::ID,
                                request_id));
 
   CredentialInfo info;  // Send an empty credential in response.
   client_->OnSendCredential(request_id, info);
   EXPECT_TRUE(callback_succeeded());
   EXPECT_FALSE(callback_errored());
 }
 
 }  // namespace password_manager