Update usages of std::map to use ScopedPtrMap.

components/password_manager/core/browser/password_form_manager_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 "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
@@ skipping 120 matching lines @@
 class TestPasswordManager : public PasswordManager {
  public:
   explicit TestPasswordManager(TestPasswordManagerClient* client)
       : PasswordManager(client), wait_for_username_(false) {}
 
   void Autofill(password_manager::PasswordManagerDriver* driver,
                 const autofill::PasswordForm& form_for_autofill,
                 const autofill::PasswordFormMap& best_matches,
                 const autofill::PasswordForm& preferred_match,
                 bool wait_for_username) const override {
-    best_matches_ = best_matches;
+    best_matches_ = &best_matches;
     wait_for_username_ = wait_for_username;
   }
 
   const autofill::PasswordFormMap& GetLatestBestMatches() {
-    return best_matches_;
+    return *best_matches_;
   }
 
   bool GetLatestWaitForUsername() { return wait_for_username_; }
 
  private:
+  // Points to a PasswordFormMap owned by PasswordFormManager.
   // Marked mutable to get around constness of Autofill().
   // TODO(vabr): This should be rewritten as a mock of PasswordManager, and the
   // interesting arguments should be saved via GMock actions instead.
-  mutable autofill::PasswordFormMap best_matches_;
+  mutable const autofill::PasswordFormMap* best_matches_;
   mutable bool wait_for_username_;
 };
 
 }  // namespace
 
 class PasswordFormManagerTest : public testing::Test {
  public:
   PasswordFormManagerTest() {}
 
   // Types of possible outcomes of simulated matching, see
@@ skipping 48 matching lines @@
     return &p->pending_credentials_;
   }
 
   void SimulateMatchingPhase(PasswordFormManager* p,
                              ResultOfSimulatedMatching result) {
     // Roll up the state to mock out the matching phase.
     p->state_ = PasswordFormManager::POST_MATCHING_PHASE;
     if (result == RESULT_NO_MATCH)
       return;
 
-    PasswordForm* match = new PasswordForm(saved_match_);
-    // Heap-allocated form is owned by p.
-    p->best_matches_[match->username_value] = match;
-    p->preferred_match_ = match;
+    scoped_ptr<PasswordForm> match(new PasswordForm(saved_match_));
+    p->preferred_match_ = match.get();
+    base::string16 username = match->username_value;
+    p->best_matches_.insert(username, match.Pass());
   }
 
   void SanitizePossibleUsernames(PasswordFormManager* p, PasswordForm* form) {
     p->SanitizePossibleUsernames(form);
   }
 
   bool IgnoredResult(PasswordFormManager* p, PasswordForm* form) {
     return p->ShouldIgnoreResult(*form);
   }
 
@@ skipping 1300 matching lines @@
   manager_creds.OnGetPasswordStoreResults(simulated_results.Pass());
   Mock::VerifyAndClearExpectations(client()->mock_driver());
 
   // Check that Autofill message was sent.
   EXPECT_EQ(1u, password_manager.GetLatestBestMatches().size());
   // Check that we suggest, not autofill.
   EXPECT_TRUE(password_manager.GetLatestWaitForUsername());
 }
 
 }  // namespace password_manager