Update usages of std::map to use ScopedPtrMap.

components/password_manager/core/browser/password_form_manager.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 "components/password_manager/core/browser/password_form_manager.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/metrics/histogram_macros.h"
@@ skipping 73 matching lines @@
 }
 
 }  // namespace
 
 PasswordFormManager::PasswordFormManager(
     PasswordManager* password_manager,
     PasswordManagerClient* client,
     const base::WeakPtr<PasswordManagerDriver>& driver,
     const PasswordForm& observed_form,
     bool ssl_valid)
-    : best_matches_deleter_(&best_matches_),
-      observed_form_(CopyAndModifySSLValidity(observed_form, ssl_valid)),
+    : observed_form_(CopyAndModifySSLValidity(observed_form, ssl_valid)),
       provisionally_saved_form_(nullptr),
       other_possible_username_action_(
           PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES),
       is_new_login_(true),
       has_generated_password_(false),
       password_manager_(password_manager),
       preferred_match_(nullptr),
       is_ignorable_change_password_form_(false),
       state_(PRE_MATCHING_PHASE),
       client_(client),
@@ skipping 229 matching lines @@
   } else if (no_username) {
     form_type_ = kFormTypeLoginNoUsername;
   } else {
     form_type_ = kFormTypeLogin;
   }
 }
 
 void PasswordFormManager::OnRequestDone(
     ScopedVector<PasswordForm> logins_result) {
   preferred_match_ = nullptr;
-  STLDeleteValues(&best_matches_);
+  best_matches_.clear();
   const size_t logins_result_size = logins_result.size();
 
   scoped_ptr<BrowserSavePasswordProgressLogger> logger;
   if (client_->IsLoggingActive()) {
     logger.reset(new BrowserSavePasswordProgressLogger(client_));
     logger->LogMessage(Logger::STRING_ON_REQUEST_DONE_METHOD);
   }
 
   // First, compute scores for credentials in |login_result|.
   std::vector<int> credential_scores;
@@ skipping 47 matching lines @@
       is_credential_protected |= login->type == PasswordForm::TYPE_GENERATED;
 
       if (is_credential_protected)
         protected_credentials.push_back(login.Pass());
       continue;
     }
 
     // If there is another best-score match for the same username, replace it.
     // TODO(vabr): Spare the replacing and keep the first instead of the last
     // candidate.
-    PasswordForm*& best_match = best_matches_[login->username_value];
-    if (best_match == preferred_match_)
+    const base::string16& username = login->username_value;
+    auto best_match_username = best_matches_.find(username);
+    if (best_match_username != best_matches_.end() &&
+        best_match_username->second == preferred_match_) {
       preferred_match_ = nullptr;
-    delete best_match;
+    }
     // Transfer ownership into the map.
-    best_match = login.release();
+    const PasswordForm* best_match = login.get();
+    // TODO(mgiuca): Directly assign to |best_match_username|, instead of doing
+    // a second map traversal. This will only be possible once we have C++11
+    // library support (then |best_matches_| can be a map of scoped_ptrs instead
+    // of a ScopedPtrMap).
+    best_matches_.set(username, login.Pass());
     if (best_match->preferred)
       preferred_match_ = best_match;
   }
 
   // Add the protected results if we don't already have a result with the same
   // username.
   for (ScopedVector<PasswordForm>::iterator it = protected_credentials.begin();
        it != protected_credentials.end(); ++it) {
     // Take ownership of the PasswordForm from the ScopedVector.
     scoped_ptr<PasswordForm> protege(*it);
     *it = nullptr;
-
-    PasswordForm*& corresponding_best_match =
-        best_matches_[protege->username_value];
-    if (!corresponding_best_match)
-      corresponding_best_match = protege.release();
+    const base::string16& username = protege->username_value;
+    best_matches_.insert(username, protege.Pass());
   }
 
   client_->AutofillResultsComputed();
 
   UMA_HISTOGRAM_COUNTS("PasswordManager.NumPasswordsNotShown",
                        logins_result_size - best_matches_.size());
 
   // It is possible we have at least one match but have no preferred_match_,
   // because a user may have chosen to 'Forget' the preferred match. So we
   // just pick the first one and whichever the user selects for submit will
@@ skipping 122 matching lines @@
   if (reset_preferred_login) {
     UpdatePreferredLoginState(password_store);
   }
 }
 
 void PasswordFormManager::SanitizePossibleUsernames(PasswordForm* form) {
   // Remove any possible usernames that could be credit cards or SSN for privacy
   // reasons. Also remove duplicates, both in other_possible_usernames and
   // between other_possible_usernames and username_value.
   std::set<base::string16> set;
-  for (std::vector<base::string16>::iterator it =
+  for (std::vector<base::string16>::const_iterator it =
            form->other_possible_usernames.begin();
        it != form->other_possible_usernames.end(); ++it) {
     if (!autofill::IsValidCreditCardNumber(*it) && !autofill::IsSSN(*it))
       set.insert(*it);
   }
   set.erase(form->username_value);
   std::vector<base::string16> temp(set.begin(), set.end());
   form->other_possible_usernames.swap(temp);
 }
 
 void PasswordFormManager::UpdatePreferredLoginState(
     PasswordStore* password_store) {
   DCHECK(password_store);
-  PasswordFormMap::iterator iter;
+  PasswordFormMap::const_iterator iter;
   for (iter = best_matches_.begin(); iter != best_matches_.end(); iter++) {
     if (iter->second->username_value != pending_credentials_.username_value &&
         iter->second->preferred) {
       // This wasn't the selected login but it used to be preferred.
       iter->second->preferred = false;
       if (user_action_ == kUserActionNone)
         user_action_ = kUserActionChoose;
       password_store->UpdateLogin(*iter->second);
     }
   }
@@ skipping 339 matching lines @@
     LogPasswordGenerationSubmissionEvent(PASSWORD_SUBMITTED);
 }
 
 void PasswordFormManager::SubmitFailed() {
   submit_result_ = kSubmitResultFailed;
   if (has_generated_password_)
     LogPasswordGenerationSubmissionEvent(PASSWORD_SUBMISSION_FAILED);
 }
 
 }  // namespace password_manager