Remove base::ScopedPtrHashMap from components/nacl/.

components/nacl/renderer/ppb_nacl_private_impl.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 "components/nacl/renderer/ppb_nacl_private.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <numeric>
 #include <string>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
-#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/cpu.h"
 #include "base/files/file.h"
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/process/process_handle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_split.h"
@@ skipping 111 matching lines @@
 
   NexeLoadManager nexe_load_manager;
   std::unique_ptr<JsonManifest> json_manifest;
   std::unique_ptr<InstanceInfo> instance_info;
 
   // When translation is complete, this records the size of the pexe in
   // bytes so that it can be reported in a later load event.
   uint64_t pexe_size;
 };
 
-typedef base::ScopedPtrHashMap<PP_Instance, std::unique_ptr<NaClPluginInstance>>
+typedef std::unordered_map<PP_Instance, std::unique_ptr<NaClPluginInstance>>
     InstanceMap;
 base::LazyInstance<InstanceMap> g_instance_map = LAZY_INSTANCE_INITIALIZER;
 
 NaClPluginInstance* GetNaClPluginInstance(PP_Instance instance) {
   InstanceMap& map = g_instance_map.Get();
-  InstanceMap::iterator iter = map.find(instance);
+  auto iter = map.find(instance);
   if (iter == map.end())
     return NULL;
-  return iter->second;
+  return iter->second.get();
 }
 
 NexeLoadManager* GetNexeLoadManager(PP_Instance instance) {
   NaClPluginInstance* nacl_plugin_instance = GetNaClPluginInstance(instance);
   if (!nacl_plugin_instance)
     return NULL;
   return &nacl_plugin_instance->nexe_load_manager;
 }
 
 JsonManifest* GetJsonManifest(PP_Instance instance) {
@@ skipping 689 matching lines @@
                                      PP_NaClError error,
                                      const char* error_message) {
   NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (load_manager)
     load_manager->ReportLoadError(error, error_message);
 }
 
 // static
 void PPBNaClPrivate::InstanceCreated(PP_Instance instance) {
   InstanceMap& map = g_instance_map.Get();
-  CHECK(!ContainsKey(map, instance));  // Sanity check.
+  CHECK(map.find(instance) == map.end());  // Sanity check.
   std::unique_ptr<NaClPluginInstance> new_instance(
       new NaClPluginInstance(instance));
-  map.add(instance, std::move(new_instance));
+  map[instance] = std::move(new_instance);
 }
 
 // static
 void PPBNaClPrivate::InstanceDestroyed(PP_Instance instance) {
   InstanceMap& map = g_instance_map.Get();
-  InstanceMap::iterator iter = map.find(instance);
+  auto iter = map.find(instance);
   CHECK(iter != map.end());
   // The erase may call NexeLoadManager's destructor prior to removing it from
   // the map. In that case, it is possible for the trusted Plugin to re-enter
   // the NexeLoadManager (e.g., by calling ReportLoadError). Passing out the
   // NexeLoadManager to a local scoped_ptr just ensures that its entry is gone
   // from the map prior to the destructor being invoked.
-  std::unique_ptr<NaClPluginInstance> temp(map.take(instance));
+  std::unique_ptr<NaClPluginInstance> temp = std::move(iter->second);
   map.erase(iter);
 }
 
 // static
 void PPBNaClPrivate::TerminateNaClLoader(PP_Instance instance) {
   auto* load_mgr = GetNexeLoadManager(instance);
   if (load_mgr)
     load_mgr->CloseTrustedPluginChannel();
 }
 
@@ skipping 840 matching lines @@
   // Mark the request as requesting a PNaCl bitcode file,
   // so that component updater can detect this user action.
   url_request.addHTTPHeaderField(
       blink::WebString::fromUTF8("Accept"),
       blink::WebString::fromUTF8("application/x-pnacl, */*"));
   url_request.setRequestContext(blink::WebURLRequest::RequestContextObject);
   downloader->Load(url_request);
 }
 
 }  // namespace nacl