Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

chrome/browser/ui/passwords/password_manager_presenter_unittest.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/ui/passwords/password_manager_presenter.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 30 matching lines @@
       : profile_(profile), password_manager_presenter_(this) {
     password_manager_presenter_.Initialize();
   }
   ~MockPasswordUIView() override {}
   Profile* GetProfile() override;
 #if !defined(OS_ANDROID)
   gfx::NativeWindow GetNativeWindow() const override;
 #endif
   MOCK_METHOD4(ShowPassword, void(
       size_t, const std::string&, const std::string&, const base::string16&));
-  MOCK_METHOD1(SetPasswordList,
-               void(const std::vector<scoped_ptr<autofill::PasswordForm>>&));
-  MOCK_METHOD1(SetPasswordExceptionList,
-               void(const std::vector<scoped_ptr<autofill::PasswordForm>>&));
+  MOCK_METHOD1(
+      SetPasswordList,
+      void(const std::vector<std::unique_ptr<autofill::PasswordForm>>&));
+  MOCK_METHOD1(
+      SetPasswordExceptionList,
+      void(const std::vector<std::unique_ptr<autofill::PasswordForm>>&));
   PasswordManagerPresenter* GetPasswordManagerPresenter() {
     return &password_manager_presenter_;
   }
 
  private:
   Profile* profile_;
   PasswordManagerPresenter password_manager_presenter_;
 
   DISALLOW_COPY_AND_ASSIGN(MockPasswordUIView);
 };
@@ skipping 21 matching lines @@
   void AddPasswordException(const GURL& origin);
   void UpdateLists();
   MockPasswordUIView* GetUIController() { return mock_controller_.get(); }
   void SortAndCheckPositions(const SortEntry test_entries[],
                              size_t number_of_entries,
                              bool username_and_password_in_key);
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
-  scoped_ptr<MockPasswordUIView> mock_controller_;
+  std::unique_ptr<MockPasswordUIView> mock_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(PasswordManagerPresenterTest);
 };
 
 void PasswordManagerPresenterTest::AddPasswordEntry(
     const GURL& origin,
     const std::string& user_name,
     const std::string& password) {
-  scoped_ptr<autofill::PasswordForm> form(new autofill::PasswordForm());
+  std::unique_ptr<autofill::PasswordForm> form(new autofill::PasswordForm());
   form->origin = origin;
   form->username_element = base::ASCIIToUTF16("Email");
   form->username_value = base::ASCIIToUTF16(user_name);
   form->password_element = base::ASCIIToUTF16("Passwd");
   form->password_value = base::ASCIIToUTF16(password);
   mock_controller_->GetPasswordManagerPresenter()->password_list_.push_back(
       std::move(form));
 }
 
 void PasswordManagerPresenterTest::AddPasswordException(const GURL& origin) {
-  scoped_ptr<autofill::PasswordForm> form(new autofill::PasswordForm());
+  std::unique_ptr<autofill::PasswordForm> form(new autofill::PasswordForm());
   form->origin = origin;
   mock_controller_->GetPasswordManagerPresenter()
       ->password_exception_list_.push_back(std::move(form));
 }
 
 void PasswordManagerPresenterTest::UpdateLists() {
   mock_controller_->GetPasswordManagerPresenter()->SetPasswordList();
   mock_controller_->GetPasswordManagerPresenter()->SetPasswordExceptionList();
 }
 
 void PasswordManagerPresenterTest::SortAndCheckPositions(
     const SortEntry test_entries[],
     size_t number_of_entries,
     bool username_and_password_in_key) {
-  std::vector<scoped_ptr<autofill::PasswordForm>> list;
+  std::vector<std::unique_ptr<autofill::PasswordForm>> list;
   size_t expected_number_of_unique_entries = 0;
   for (size_t i = 0; i < number_of_entries; i++) {
     const SortEntry& entry = test_entries[i];
-    scoped_ptr<autofill::PasswordForm> form(new autofill::PasswordForm());
+    std::unique_ptr<autofill::PasswordForm> form(new autofill::PasswordForm());
     form->signon_realm = entry.origin;
     form->origin = GURL(base::ASCIIToUTF16(entry.origin));
     if (username_and_password_in_key) {
       form->username_value = base::ASCIIToUTF16(entry.username);
       form->password_value = base::ASCIIToUTF16(entry.password);
     }
     if (entry.affiliated_web_realm)
       form->affiliated_web_realm = entry.affiliated_web_realm;
     list.push_back(std::move(form));
     if (entry.expected_position >= 0)
@@ skipping 20 matching lines @@
         EXPECT_EQ(base::ASCIIToUTF16(entry.password),
                   list[entry.expected_position]->password_value);
       }
     }
   }
 }
 
 namespace {
 
 TEST_F(PasswordManagerPresenterTest, UIControllerIsCalled) {
-  EXPECT_CALL(
-      *GetUIController(),
-      SetPasswordList(Property(
-          &std::vector<scoped_ptr<autofill::PasswordForm>>::size, Eq(0u))));
-  EXPECT_CALL(
-      *GetUIController(),
-      SetPasswordExceptionList(Property(
-          &std::vector<scoped_ptr<autofill::PasswordForm>>::size, Eq(0u))));
+  EXPECT_CALL(*GetUIController(),
+              SetPasswordList(Property(
+                  &std::vector<std::unique_ptr<autofill::PasswordForm>>::size,
+                  Eq(0u))));
+  EXPECT_CALL(*GetUIController(),
+              SetPasswordExceptionList(Property(
+                  &std::vector<std::unique_ptr<autofill::PasswordForm>>::size,
+                  Eq(0u))));
   UpdateLists();
   GURL pass_origin("http://abc1.com");
   AddPasswordEntry(pass_origin, "test@gmail.com", "test");
-  EXPECT_CALL(
-      *GetUIController(),
-      SetPasswordList(Property(
-          &std::vector<scoped_ptr<autofill::PasswordForm>>::size, Eq(1u))));
-  EXPECT_CALL(
-      *GetUIController(),
-      SetPasswordExceptionList(Property(
-          &std::vector<scoped_ptr<autofill::PasswordForm>>::size, Eq(0u))));
+  EXPECT_CALL(*GetUIController(),
+              SetPasswordList(Property(
+                  &std::vector<std::unique_ptr<autofill::PasswordForm>>::size,
+                  Eq(1u))));
+  EXPECT_CALL(*GetUIController(),
+              SetPasswordExceptionList(Property(
+                  &std::vector<std::unique_ptr<autofill::PasswordForm>>::size,
+                  Eq(0u))));
   UpdateLists();
   GURL except_origin("http://abc2.com");
   AddPasswordException(except_origin);
-  EXPECT_CALL(
-      *GetUIController(),
-      SetPasswordList(Property(
-          &std::vector<scoped_ptr<autofill::PasswordForm>>::size, Eq(1u))));
-  EXPECT_CALL(
-      *GetUIController(),
-      SetPasswordExceptionList(Property(
-          &std::vector<scoped_ptr<autofill::PasswordForm>>::size, Eq(1u))));
+  EXPECT_CALL(*GetUIController(),
+              SetPasswordList(Property(
+                  &std::vector<std::unique_ptr<autofill::PasswordForm>>::size,
+                  Eq(1u))));
+  EXPECT_CALL(*GetUIController(),
+              SetPasswordExceptionList(Property(
+                  &std::vector<std::unique_ptr<autofill::PasswordForm>>::size,
+                  Eq(1u))));
   UpdateLists();
   GURL pass_origin2("http://example.com");
   AddPasswordEntry(pass_origin2, "test@gmail.com", "test");
-  EXPECT_CALL(
-      *GetUIController(),
-      SetPasswordList(Property(
-          &std::vector<scoped_ptr<autofill::PasswordForm>>::size, Eq(2u))));
-  EXPECT_CALL(
-      *GetUIController(),
-      SetPasswordExceptionList(Property(
-          &std::vector<scoped_ptr<autofill::PasswordForm>>::size, Eq(1u))));
+  EXPECT_CALL(*GetUIController(),
+              SetPasswordList(Property(
+                  &std::vector<std::unique_ptr<autofill::PasswordForm>>::size,
+                  Eq(2u))));
+  EXPECT_CALL(*GetUIController(),
+              SetPasswordExceptionList(Property(
+                  &std::vector<std::unique_ptr<autofill::PasswordForm>>::size,
+                  Eq(1u))));
   UpdateLists();
 }
 
 TEST_F(PasswordManagerPresenterTest, Sorting_DifferentOrigins) {
   const SortEntry test_cases[] = {
       {"http://example-b.com", "user_a", "pwd", nullptr, 2},
       {"http://example-a.com", "user_a1", "pwd", nullptr, 0},
       {"http://example-a.com", "user_a2", "pwd", nullptr, 1},
       {"http://example-c.com", "user_a", "pwd", nullptr, 3}};
   SortAndCheckPositions(test_cases, arraysize(test_cases), true);
@@ skipping 45 matching lines @@
       {"android://hash@com.alpha", "user", "secret", "https://alpha.com", -1},
       {"android://hash@com.alpha", "user", "secret", nullptr, 2},
 
       {"android://hash@com.betta.android", "user", "secret",
        "https://betta.com", 3},
       {"android://hash@com.betta.android", "user", "secret", nullptr, 4}};
   SortAndCheckPositions(test_cases, arraysize(test_cases), true);
 }
 
 }  // namespace