Remove base::ScopedPtrHashMap from ozone.

ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.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 "ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.h"
 
 #include <fnmatch.h>
 #include <gestures/gestures.h>
 #include <libevdev/libevdev.h>
 #include <stdint.h>
 #include <string.h>
 
 #include <algorithm>
+#include <unordered_map>
 
 #include "base/containers/hash_tables.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
@@ skipping 578 matching lines @@
       LOG(ERROR) << "Unknown gesture property type: " << property->type();
       NOTREACHED();
       break;
   }
   return os;
 }
 
 namespace ui {
 namespace internal {
 
-// Mapping table from a property name to its corresponding GesturesProp
-// object pointer.
-typedef base::hash_map<std::string, GesturesProp*> PropertiesMap;
-typedef base::ScopedPtrHashMap<std::string, std::unique_ptr<GesturesProp>>
-    ScopedPropertiesMap;
-
 // Struct holding properties of a device.
 //
 // Note that we can't define it in GesturePropertyProvider as a nested class
 // because ScopedPtrHashMap will require us to expose the GestureProp's
 // destructor so that it can instantiate the object. This is something we
 // don't want to do.
 struct GestureDevicePropertyData {
   GestureDevicePropertyData() {}
 
   // Properties owned and being used by the device.
-  ScopedPropertiesMap properties;
+  std::unordered_map<std::string, std::unique_ptr<GesturesProp>> properties;
 
   // Unowned default properties (owned by the configuration file). Their values
   // will be applied when a property of the same name is created. These are
   // usually only a small portion of all properties in use.
-  PropertiesMap default_properties;
+  base::hash_map<std::string, GesturesProp*> default_properties;
 };
 
 // Base class for device match criterias in conf files.
 // Check the xorg-conf spec for more detailed information.
 class MatchCriteria {
  public:
   typedef ui::GesturePropertyProvider::DevicePtr DevicePtr;
   explicit MatchCriteria(const std::string& arg);
   virtual ~MatchCriteria() {}
   virtual bool Match(const DevicePtr device) = 0;
@@ skipping 224 matching lines @@
   LoadDeviceConfigurations();
 }
 
 GesturePropertyProvider::~GesturePropertyProvider() {
 }
 
 bool GesturePropertyProvider::GetDeviceIdsByType(
     const EventDeviceType type,
     std::vector<DeviceId>* device_ids) {
   bool exists = false;
-  DeviceMap::const_iterator it = device_map_.begin();
-  for (; it != device_map_.end(); ++it) {
+  for (auto it = device_map_.begin(); it != device_map_.end(); ++it) {
     if (IsDeviceIdOfType(it->first, type)) {
       exists = true;
       if (device_ids)
         device_ids->push_back(it->first);
     }
   }
   return exists;
 }
 
 bool GesturePropertyProvider::IsDeviceIdOfType(const DeviceId device_id,
                                                const EventDeviceType type) {
-  DeviceMap::const_iterator it = device_map_.find(device_id);
+  auto it = device_map_.find(device_id);
   if (it == device_map_.end())
     return false;
   return IsDeviceOfType(it->second, type,
                         GetProperty(device_id, "Device Mouse"),
                         GetProperty(device_id, "Device Touchpad"));
 }
 
 GesturesProp* GesturePropertyProvider::GetProperty(const DeviceId device_id,
                                                    const std::string& name) {
   return FindProperty(device_id, name);
 }
 
 std::vector<std::string> GesturePropertyProvider::GetPropertyNamesById(
     const DeviceId device_id) {
-  internal::GestureDevicePropertyData* device_data =
-      device_data_map_.get(device_id);
-  if (!device_data)
+  auto it = device_data_map_.find(device_id);
+  if (it == device_data_map_.end())
     return std::vector<std::string>();
 
+  internal::GestureDevicePropertyData* device_data = it->second.get();
+
   // Dump all property names of the device.
   std::vector<std::string> names;
-  for (internal::ScopedPropertiesMap::const_iterator it =
-           device_data->properties.begin();
+  for (auto it = device_data->properties.begin();
        it != device_data->properties.end(); ++it)
     names.push_back(it->first);
   return names;
 }
 
 std::string GesturePropertyProvider::GetDeviceNameById(
     const DeviceId device_id) {
-  DeviceMap::const_iterator it = device_map_.find(device_id);
+  auto it = device_map_.find(device_id);
   if (it == device_map_.end())
     return std::string();
   return std::string(it->second->info.name);
 }
 
 void GesturePropertyProvider::RegisterDevice(const DeviceId id,
                                              const DevicePtr device) {
-  DeviceMap::const_iterator it = device_map_.find(id);
+  auto it = device_map_.find(id);
   if (it != device_map_.end())
     return;
 
   // Setup data-structures.
   device_map_[id] = device;
-  device_data_map_.set(id, std::unique_ptr<internal::GestureDevicePropertyData>(
-                               new internal::GestureDevicePropertyData));
+  device_data_map_[id] =
+      base::MakeUnique<internal::GestureDevicePropertyData>();
 
   // Gather default property values for the device from the parsed conf files.
   SetupDefaultProperties(id, device);
   return;
 }
 
 void GesturePropertyProvider::UnregisterDevice(const DeviceId id) {
-  DeviceMap::const_iterator it = device_map_.find(id);
+  auto it = device_map_.find(id);
   if (it == device_map_.end())
     return;
   device_data_map_.erase(id);
   device_map_.erase(it);
 }
 
 void GesturePropertyProvider::AddProperty(
     const DeviceId device_id,
     const std::string& name,
     std::unique_ptr<GesturesProp> property) {
   // The look-up should never fail because ideally a property can only be
   // created with GesturesPropCreate* functions from the gesture lib side.
   // Therefore, we simply return on failure.
-  internal::GestureDevicePropertyData* device_data =
-      device_data_map_.get(device_id);
-  if (device_data)
-    device_data->properties.set(name, std::move(property));
+  auto it = device_data_map_.find(device_id);
+  if (it != device_data_map_.end())
+    it->second->properties[name] = std::move(property);
 }
 
 void GesturePropertyProvider::DeleteProperty(const DeviceId device_id,
                                              const std::string& name) {
-  internal::GestureDevicePropertyData* device_data =
-      device_data_map_.get(device_id);
-  if (device_data)
-    device_data->properties.erase(name);
+  auto it = device_data_map_.find(device_id);
+  if (it != device_data_map_.end())
+    it->second->properties.erase(name);
 }
 
 GesturesProp* GesturePropertyProvider::FindProperty(const DeviceId device_id,
                                                     const std::string& name) {
-  internal::GestureDevicePropertyData* device_data =
-      device_data_map_.get(device_id);
-  if (!device_data)
-    return NULL;
-  return device_data->properties.get(name);
+  auto it = device_data_map_.find(device_id);
+  if (it == device_data_map_.end())
+    return nullptr;
+
+  auto it2 = it->second->properties.find(name);
+  if (it2 == it->second->properties.end())
+    return nullptr;
+
+  return it2->second.get();
 }
 
 GesturesProp* GesturePropertyProvider::GetDefaultProperty(
     const DeviceId device_id,
     const std::string& name) {
-  internal::GestureDevicePropertyData* device_data =
-      device_data_map_.get(device_id);
-  if (!device_data)
-    return NULL;
-  internal::PropertiesMap::const_iterator ib =
-      device_data->default_properties.find(name);
-  if (ib == device_data->default_properties.end())
-    return NULL;
-  return ib->second;
+  auto it = device_data_map_.find(device_id);
+  if (it == device_data_map_.end())
+    return nullptr;
+
+  auto it2 = it->second->default_properties.find(name);
+  if (it2 == it->second->default_properties.end())
+    return nullptr;
+
+  return it2->second;
 }
 
 void GesturePropertyProvider::LoadDeviceConfigurations() {
   // Enumerate conf files and sort them lexicographically.
   std::set<base::FilePath> files;
   base::FileEnumerator file_enum(base::FilePath(kConfigurationFilePath),
                                  false,
                                  base::FileEnumerator::FILES,
                                  "*.conf");
   for (base::FilePath path = file_enum.Next(); !path.empty();
        path = file_enum.Next()) {
     files.insert(path);
   }
   DVLOG(2) << files.size() << " conf files were found";
 
   // Parse conf files one-by-one.
-  for (std::set<base::FilePath>::iterator file_iter = files.begin();
-       file_iter != files.end();
-       ++file_iter) {
+  for (auto file_iter = files.begin(); file_iter != files.end(); ++file_iter) {
     DVLOG(2) << "Parsing conf file: " << (*file_iter).value();
     std::string content;
     if (!base::ReadFileToString(*file_iter, &content)) {
       LOG(ERROR) << "Can't loading gestures conf file: "
                  << (*file_iter).value();
       continue;
     }
     ParseXorgConfFile(content);
   }
 }
@@ skipping 249 matching lines @@
   // specify some name or args as invalid.
   return property;
 }
 
 void GesturePropertyProvider::SetupDefaultProperties(const DeviceId device_id,
                                                      const DevicePtr device) {
   DVLOG(2) << "Setting up default properties for (" << device << ", "
            << device_id << ", " << device->info.name << ")";
 
   // Go through all parsed sections.
-  internal::PropertiesMap& property_map =
-      device_data_map_.get(device_id)->default_properties;
+  auto& property_map = device_data_map_[device_id]->default_properties;
   for (const auto& configuration : configurations_) {
     if (configuration->Match(device)) {
       DVLOG(2) << "Conf section \"" << configuration->identifier
                << "\" is matched";
       for (const auto& property : configuration->properties) {
         // We can't use insert here because a property may be set for several
         // times along the way.
         property_map[property->name()] = property.get();
       }
     }
@@ skipping 252 matching lines @@
 const GesturesPropProvider kGesturePropProvider = {
     GesturesPropFunctionsWrapper::CreateInt,
     GesturesPropFunctionsWrapper::CreateShort,
     GesturesPropFunctionsWrapper::CreateBool,
     GesturesPropFunctionsWrapper::CreateString,
     GesturesPropFunctionsWrapper::CreateReal,
     GesturesPropFunctionsWrapper::RegisterHandlers,
     GesturesPropFunctionsWrapper::Free};
 
 }  // namespace ui