Update usages of std::map to use ScopedPtrMap.

sync/engine/directory_update_handler_unittest.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 "sync/engine/directory_update_handler.h"
 
 #include "base/compiler_specific.h"
+#include "base/containers/scoped_ptr_map.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
-#include "base/stl_util.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/internal_api/public/base/attachment_id_proto.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/test/test_entry_factory.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/sessions/directory_type_debug_info_emitter.h"
 #include "sync/sessions/status_controller.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/mutable_entry.h"
@@ skipping 429 matching lines @@
 // using FakeModelWorkers, so there's not much difference between the two test
 // harnesses.
 class DirectoryUpdateHandlerApplyUpdateTest : public ::testing::Test {
  public:
   DirectoryUpdateHandlerApplyUpdateTest()
       : ui_worker_(new FakeModelWorker(GROUP_UI)),
         password_worker_(new FakeModelWorker(GROUP_PASSWORD)),
         passive_worker_(new FakeModelWorker(GROUP_PASSIVE)),
         bookmarks_emitter_(BOOKMARKS, &type_observers_),
         passwords_emitter_(PASSWORDS, &type_observers_),
-        articles_emitter_(ARTICLES, &type_observers_),
-        update_handler_map_deleter_(&update_handler_map_) {}
+        articles_emitter_(ARTICLES, &type_observers_) {}
 
   void SetUp() override {
     dir_maker_.SetUp();
     entry_factory_.reset(new TestEntryFactory(directory()));
 
-    update_handler_map_.insert(std::make_pair(
+    update_handler_map_.insert(
         BOOKMARKS,
-        new DirectoryUpdateHandler(directory(), BOOKMARKS,
-                                   ui_worker_, &bookmarks_emitter_)));
-    update_handler_map_.insert(std::make_pair(
+        make_scoped_ptr(new DirectoryUpdateHandler(
+            directory(), BOOKMARKS, ui_worker_, &bookmarks_emitter_)));
+    update_handler_map_.insert(
         PASSWORDS,
-        new DirectoryUpdateHandler(directory(),
-                                   PASSWORDS,
-                                   password_worker_,
-                                   &passwords_emitter_)));
-    update_handler_map_.insert(std::make_pair(
-        ARTICLES,
-        new DirectoryUpdateHandler(
-            directory(), ARTICLES, ui_worker_, &articles_emitter_)));
+        make_scoped_ptr(new DirectoryUpdateHandler(
+            directory(), PASSWORDS, password_worker_, &passwords_emitter_)));
+    update_handler_map_.insert(
+        ARTICLES, make_scoped_ptr(new DirectoryUpdateHandler(
+                      directory(), ARTICLES, ui_worker_, &articles_emitter_)));
   }
 
   void TearDown() override { dir_maker_.TearDown(); }
 
   const UpdateCounters& GetBookmarksUpdateCounters() {
     return bookmarks_emitter_.GetUpdateCounters();
   }
 
   const UpdateCounters& GetPasswordsUpdateCounters() {
     return passwords_emitter_.GetUpdateCounters();
   }
 
   const UpdateCounters& GetArticlesUpdateCounters() {
     return articles_emitter_.GetUpdateCounters();
   }
 
  protected:
   void ApplyBookmarkUpdates(sessions::StatusController* status) {
-    update_handler_map_[BOOKMARKS]->ApplyUpdates(status);
+    update_handler_map_.find(BOOKMARKS)->second->ApplyUpdates(status);
   }
 
   void ApplyPasswordUpdates(sessions::StatusController* status) {
-    update_handler_map_[PASSWORDS]->ApplyUpdates(status);
+    update_handler_map_.find(PASSWORDS)->second->ApplyUpdates(status);
   }
 
   void ApplyArticlesUpdates(sessions::StatusController* status) {
-    update_handler_map_[ARTICLES]->ApplyUpdates(status);
+    update_handler_map_.find(ARTICLES)->second->ApplyUpdates(status);
   }
 
   TestEntryFactory* entry_factory() {
     return entry_factory_.get();
   }
 
   syncable::Directory* directory() {
     return dir_maker_.directory();
   }
 
  private:
-  typedef std::map<ModelType, UpdateHandler*> UpdateHandlerMap;
-
   base::MessageLoop loop_;  // Needed to initialize the directory.
   TestDirectorySetterUpper dir_maker_;
   scoped_ptr<TestEntryFactory> entry_factory_;
 
   scoped_refptr<FakeModelWorker> ui_worker_;
   scoped_refptr<FakeModelWorker> password_worker_;
   scoped_refptr<FakeModelWorker> passive_worker_;
 
   base::ObserverList<TypeDebugInfoObserver> type_observers_;
   DirectoryTypeDebugInfoEmitter bookmarks_emitter_;
   DirectoryTypeDebugInfoEmitter passwords_emitter_;
   DirectoryTypeDebugInfoEmitter articles_emitter_;
 
-  UpdateHandlerMap update_handler_map_;
-  STLValueDeleter<UpdateHandlerMap> update_handler_map_deleter_;
+  base::ScopedPtrMap<ModelType, scoped_ptr<UpdateHandler>> update_handler_map_;
 };
 
 namespace {
 sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
   sync_pb::EntitySpecifics result;
   AddDefaultFieldValue(BOOKMARKS, &result);
   return result;
 }
 } // namespace
 
@@ skipping 611 matching lines @@
   const UpdateCounters& counters = GetArticlesUpdateCounters();
   EXPECT_EQ(1, counters.num_updates_applied);
   EXPECT_EQ(1, counters.num_local_overwrites);
   EXPECT_EQ(0, counters.num_server_overwrites);
   local_metadata = entry_factory()->GetLocalAttachmentMetadataForItem(handle);
   EXPECT_EQ(server_metadata.SerializeAsString(),
             local_metadata.SerializeAsString());
 }
 
 }  // namespace syncer