Fix a memory leak in PasswordStoreMac

chrome/browser/password_manager/password_store_mac_unittest.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/password_store_mac.h"
 
 #include "base/basictypes.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_vector.h"
 #include "base/path_service.h"
@@ skipping 484 matching lines @@
     { PasswordForm::SCHEME_DIGEST, "https://some.domain.com/high_security",
       "https://some.domain.com",
       NULL, NULL, NULL, NULL, L"digest_auth_user", NULL, true, true, 0 },
   };
 
   for (unsigned int i = 0; i < arraysize(base_form_data); ++i) {
     // Create a base form and make sure we find a match.
     scoped_ptr<PasswordForm> base_form(CreatePasswordFormFromData(
         base_form_data[i]));
     EXPECT_TRUE(keychain_adapter.HasPasswordsMergeableWithForm(*base_form));
-    PasswordForm* match =
-        keychain_adapter.PasswordExactlyMatchingForm(*base_form);
-    EXPECT_TRUE(match != NULL);
-    if (match) {
-      EXPECT_EQ(base_form->scheme, match->scheme);
-      EXPECT_EQ(base_form->origin, match->origin);
-      EXPECT_EQ(base_form->username_value, match->username_value);
-      delete match;
-    }
+    EXPECT_TRUE(keychain_adapter.HasPasswordExactlyMatchingForm(*base_form));
 
     // Make sure that the matching isn't looser than it should be by checking
     // that slightly altered forms don't match.
     std::vector<PasswordForm*> modified_forms;
 
     modified_forms.push_back(new PasswordForm(*base_form));
     modified_forms.back()->username_value = ASCIIToUTF16("wrong_user");
 
     modified_forms.push_back(new PasswordForm(*base_form));
     SetPasswordFormPath(modified_forms.back(), "elsewhere.html");
 
     modified_forms.push_back(new PasswordForm(*base_form));
     modified_forms.back()->scheme = PasswordForm::SCHEME_OTHER;
 
     modified_forms.push_back(new PasswordForm(*base_form));
     SetPasswordFormPort(modified_forms.back(), "1234");
 
     modified_forms.push_back(new PasswordForm(*base_form));
     modified_forms.back()->blacklisted_by_user = true;
 
     if (base_form->scheme == PasswordForm::SCHEME_BASIC ||
         base_form->scheme == PasswordForm::SCHEME_DIGEST) {
       modified_forms.push_back(new PasswordForm(*base_form));
       SetPasswordFormRealm(modified_forms.back(), "incorrect");
     }
 
     for (unsigned int j = 0; j < modified_forms.size(); ++j) {
-      PasswordForm* match =
-          keychain_adapter.PasswordExactlyMatchingForm(*modified_forms[j]);
-      EXPECT_EQ(NULL, match) << "In modified version " << j << " of base form "
-                             << i;
+      bool match = keychain_adapter.HasPasswordExactlyMatchingForm(
+          *modified_forms[j]);
+      EXPECT_FALSE(match) << "In modified version " << j
+          << " of base form " << i;
     }
     STLDeleteElements(&modified_forms);
   }
 }
 
 TEST_F(PasswordStoreMacInternalsTest, TestKeychainAdd) {
   struct TestDataAndExpectation {
     PasswordFormData data;
     bool should_succeed;
   };
@@ skipping 27 matching lines @@
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
 
   for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     scoped_ptr<PasswordForm> in_form(
         CreatePasswordFormFromData(test_data[i].data));
     bool add_succeeded = owned_keychain_adapter.AddPassword(*in_form);
     EXPECT_EQ(test_data[i].should_succeed, add_succeeded);
     if (add_succeeded) {
       EXPECT_TRUE(owned_keychain_adapter.HasPasswordsMergeableWithForm(
           *in_form));
-      scoped_ptr<PasswordForm> out_form(
-          owned_keychain_adapter.PasswordExactlyMatchingForm(*in_form));
-      EXPECT_TRUE(out_form.get() != NULL);
-      EXPECT_EQ(out_form->scheme, in_form->scheme);
-      EXPECT_EQ(out_form->signon_realm, in_form->signon_realm);
-      EXPECT_EQ(out_form->origin, in_form->origin);
-      EXPECT_EQ(out_form->username_value, in_form->username_value);
-      EXPECT_EQ(out_form->password_value, in_form->password_value);
+      EXPECT_TRUE(owned_keychain_adapter.HasPasswordExactlyMatchingForm(
+          *in_form));
     }
   }
 
   // Test that adding duplicate item updates the existing item.
   {
     PasswordFormData data = {
       PasswordForm::SCHEME_HTML, "http://some.domain.com",
       "http://some.domain.com/insecure.html", NULL,
       NULL, NULL, NULL, L"joe_user", L"updated_password", false, false, 0
     };
@@ skipping 34 matching lines @@
   EXPECT_TRUE(owned_keychain_adapter.AddPassword(*add_form));
   delete add_form;
 
   for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     scoped_ptr<PasswordForm> form(CreatePasswordFormFromData(
         test_data[i].data));
     EXPECT_EQ(test_data[i].should_succeed,
               owned_keychain_adapter.RemovePassword(*form));
 
     MacKeychainPasswordFormAdapter keychain_adapter(keychain_);
-    PasswordForm* match = keychain_adapter.PasswordExactlyMatchingForm(*form);
-    EXPECT_EQ(test_data[i].should_succeed, match == NULL);
-    if (match) {
-      delete match;
-    }
+    bool match = keychain_adapter.HasPasswordExactlyMatchingForm(*form);
+    EXPECT_EQ(test_data[i].should_succeed, !match);
   }
 }
 
 TEST_F(PasswordStoreMacInternalsTest, TestFormMatch) {
   PasswordForm base_form;
   base_form.signon_realm = std::string("http://some.domain.com/");
   base_form.origin = GURL("http://some.domain.com/page.html");
   base_form.username_value = ASCIIToUTF16("joe_user");
 
   {
@@ skipping 775 matching lines @@
   ASSERT_EQ(1u, matching_items.size());
   EXPECT_EQ(ASCIIToUTF16("joe_user"), matching_items[0]->username_value);
   matching_items.clear();
 
   // Check the third-party password is still there.
   owned_keychain_adapter.SetFindsOnlyOwnedItems(false);
   matching_items.get() = owned_keychain_adapter.PasswordsFillingForm(
       "http://some.domain.com/insecure.html", PasswordForm::SCHEME_HTML);
   ASSERT_EQ(1u, matching_items.size());
 }