Replace scoped_ptr with std::unique_ptr in //ui

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 <fnmatch.h>
 #include <stdint.h>
 #include <string.h>
+
 #include <algorithm>
 
 #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"
 #include "base/strings/string_util.h"
 #include "base/strings/stringize_macros.h"
 #include "base/strings/stringprintf.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_feedback.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_interpreter_libevdev_cros.h"
 
 // GesturesProp implementation.
@@ skipping 574 matching lines @@
   }
   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, scoped_ptr<GesturesProp>>
+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() {}
@@ skipping 84 matching lines @@
   ~MatchIsTouchscreen() override {}
   bool Match(const DevicePtr device) override;
 };
 
 // Struct for sections in xorg conf files.
 struct ConfigurationSection {
   typedef ui::GesturePropertyProvider::DevicePtr DevicePtr;
   ConfigurationSection() {}
   bool Match(const DevicePtr device);
   std::string identifier;
-  std::vector<scoped_ptr<MatchCriteria>> criterias;
-  std::vector<scoped_ptr<GesturesProp>> properties;
+  std::vector<std::unique_ptr<MatchCriteria>> criterias;
+  std::vector<std::unique_ptr<GesturesProp>> properties;
 };
 
 MatchCriteria::MatchCriteria(const std::string& arg) {
   // TODO(sheckylin): Should we trim all tokens here?
   args_ = base::SplitString(
       arg, "|", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   if (args_.empty()) {
     LOG(ERROR) << "Empty match pattern found, will evaluate to the default "
                   "value (true): \"" << arg << "\"";
   }
@@ skipping 194 matching lines @@
 }
 
 void GesturePropertyProvider::RegisterDevice(const DeviceId id,
                                              const DevicePtr device) {
   DeviceMap::const_iterator it = device_map_.find(id);
   if (it != device_map_.end())
     return;
 
   // Setup data-structures.
   device_map_[id] = device;
-  device_data_map_.set(id,
-                       scoped_ptr<internal::GestureDevicePropertyData>(
-                           new internal::GestureDevicePropertyData));
+  device_data_map_.set(id, std::unique_ptr<internal::GestureDevicePropertyData>(
+                               new 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);
   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,
-                                          scoped_ptr<GesturesProp> property) {
+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));
 }
 
 void GesturePropertyProvider::DeleteProperty(const DeviceId device_id,
@@ skipping 68 matching lines @@
 
   // Break the content into sections, lines and then pieces.
   // Sections are delimited by the "EndSection" keyword.
   // Lines are delimited by "\n".
   // Pieces are delimited by all white-spaces.
   std::vector<std::string> sections;
   base::SplitStringUsingSubstr(content, "EndSection", &sections);
   for (size_t i = 0; i < sections.size(); ++i) {
     // Create a new configuration section.
     configurations_.push_back(
-        make_scoped_ptr(new internal::ConfigurationSection()));
+        base::WrapUnique(new internal::ConfigurationSection()));
     internal::ConfigurationSection* config = configurations_.back().get();
 
     // Break the section into lines.
     base::StringTokenizer lines(sections[i], "\n");
     bool is_input_class_section = true;
     bool has_checked_section_type = false;
     while (is_input_class_section && lines.GetNext()) {
       // Parse the line w.r.t. the xorg-conf format.
       std::string line(lines.token());
 
@@ skipping 52 matching lines @@
             DVLOG(2) << "Identifier: " << arg;
             config->identifier = arg;
             next_is_identifier = false;
             break;
           } else if (next_is_option_name) {
             // TODO(sheckylin): Support option "Ignore".
             option_name = arg;
             next_is_option_value = true;
             next_is_option_name = false;
           } else if (next_is_option_value) {
-            scoped_ptr<GesturesProp> property =
+            std::unique_ptr<GesturesProp> property =
                 CreateDefaultProperty(option_name, arg);
             if (property)
               config->properties.push_back(std::move(property));
             next_is_option_value = false;
             break;
           } else if (next_is_match_criteria) {
             // Skip all match types that are not supported.
             if (IsMatchTypeSupported(match_type)) {
-              scoped_ptr<internal::MatchCriteria> criteria =
+              std::unique_ptr<internal::MatchCriteria> criteria =
                   CreateMatchCriteria(match_type, arg);
               if (criteria)
                 config->criterias.push_back(std::move(criteria));
             }
             next_is_match_criteria = false;
             break;
           }
         } else {
           // If the section type hasn't been decided yet, look for it.
           // Otherwise, look for valid entries according to the spec.
@@ skipping 27 matching lines @@
             LOG(ERROR) << "Error parsing line: " << lines.token();
             has_error = true;
           }
           break;
         }
       }
 
       // The value of a boolean option is skipped (default is true).
       if (!has_error && (next_is_option_value || next_is_match_criteria)) {
         if (next_is_option_value) {
-          scoped_ptr<GesturesProp> property =
+          std::unique_ptr<GesturesProp> property =
               CreateDefaultProperty(option_name, "on");
           if (property)
             config->properties.push_back(std::move(property));
         } else if (IsMatchTypeSupported(match_type) &&
                    IsMatchDeviceType(match_type)) {
-          scoped_ptr<internal::MatchCriteria> criteria =
+          std::unique_ptr<internal::MatchCriteria> criteria =
               CreateMatchCriteria(match_type, "on");
           if (criteria)
             config->criterias.push_back(std::move(criteria));
         }
       }
     }
 
     // Remove useless config sections.
     if (!is_input_class_section ||
         (config->criterias.empty() && config->properties.empty())) {
       configurations_.pop_back();
     }
   }
 }
 
-scoped_ptr<internal::MatchCriteria>
+std::unique_ptr<internal::MatchCriteria>
 GesturePropertyProvider::CreateMatchCriteria(const std::string& match_type,
                                              const std::string& arg) {
   DVLOG(2) << "Creating match criteria: (" << match_type << ", " << arg << ")";
   if (match_type == "MatchProduct")
-    return make_scoped_ptr(new internal::MatchProduct(arg));
+    return base::WrapUnique(new internal::MatchProduct(arg));
   if (match_type == "MatchDevicePath")
-    return make_scoped_ptr(new internal::MatchDevicePath(arg));
+    return base::WrapUnique(new internal::MatchDevicePath(arg));
   if (match_type == "MatchUSBID")
-    return make_scoped_ptr(new internal::MatchUSBID(arg));
+    return base::WrapUnique(new internal::MatchUSBID(arg));
   if (match_type == "MatchIsPointer")
-    return make_scoped_ptr(new internal::MatchIsPointer(arg));
+    return base::WrapUnique(new internal::MatchIsPointer(arg));
   if (match_type == "MatchIsTouchpad")
-    return make_scoped_ptr(new internal::MatchIsTouchpad(arg));
+    return base::WrapUnique(new internal::MatchIsTouchpad(arg));
   if (match_type == "MatchIsTouchscreen")
-    return make_scoped_ptr(new internal::MatchIsTouchscreen(arg));
+    return base::WrapUnique(new internal::MatchIsTouchscreen(arg));
   NOTREACHED();
   return NULL;
 }
 
-scoped_ptr<GesturesProp> GesturePropertyProvider::CreateDefaultProperty(
+std::unique_ptr<GesturesProp> GesturePropertyProvider::CreateDefaultProperty(
     const std::string& name,
     const std::string& value) {
   // Our parsing rule:
   // 1. No hex or oct number is accepted.
   // 2. All numbers will be stored as double.
   // 3. Array elements can be separated by both white-spaces or commas.
   // 4. A token is treated as numeric either if it is one of the special
   //    keywords for boolean values (on, true, yes, off, false, no) or if
   //    base::StringToDouble succeeds.
   // 5. The property is treated as numeric if and only if all of its elements
@@ skipping 25 matching lines @@
     bool success = base::StringToDouble(token, &real_result);
     if (!success) {
       is_all_numeric = false;
       break;
     }
     numbers.push_back(real_result);
   }
 
   // Create the GesturesProp. Array properties need to contain at least one
   // number and may contain numbers only.
-  scoped_ptr<GesturesProp> property;
+  std::unique_ptr<GesturesProp> property;
   if (is_all_numeric && numbers.size()) {
     property.reset(new GesturesDoubleProp(name, numbers.size(), NULL,
                                           numbers.data(), NULL));
   } else {
     property.reset(new GesturesStringProp(name, NULL, value.c_str(), NULL));
   }
 
   DVLOG(2) << "Prop: " << *property;
   // The function will always succeed for now but it may change later if we
   // specify some name or args as invalid.
@@ skipping 60 matching lines @@
 
 GesturesProp* GesturesPropFunctionsWrapper::CreateString(void* device_data,
                                                          const char* name,
                                                          const char** value,
                                                          const char* init) {
   GesturesProp* default_property = NULL;
   if (!PreCreateProperty(device_data, name, &default_property))
     return NULL;
   GesturesProp* property =
       new GesturesStringProp(name, value, init, default_property);
-  PostCreateProperty(device_data, name, make_scoped_ptr(property));
+  PostCreateProperty(device_data, name, base::WrapUnique(property));
   return property;
 }
 
 void GesturesPropFunctionsWrapper::RegisterHandlers(
     void* device_data,
     GesturesProp* property,
     void* handler_data,
     GesturesPropGetHandler get,
     GesturesPropSetHandler set) {
   // Sanity checks
@@ skipping 101 matching lines @@
                                                            size_t count,
                                                            const T* init) {
   // Create the property. Use the default property value if possible.
   GesturesProp* default_property = NULL;
   if (!PreCreateProperty(device_data, name, &default_property))
     return NULL;
   GesturesProp* property =
       new PROPTYPE(name, count, value, init, default_property);
 
   // Start tracking the property in the provider.
-  PostCreateProperty(device_data, name, make_scoped_ptr(property));
+  PostCreateProperty(device_data, name, base::WrapUnique(property));
   return property;
 }
 
 bool GesturesPropFunctionsWrapper::PreCreateProperty(
     void* device_data,
     const char* name,
     GesturesProp** default_property) {
   GesturePropertyProvider* provider = GetPropertyProvider(device_data);
   GesturePropertyProvider::DeviceId device_id = GetDeviceId(device_data);
 
@@ skipping 14 matching lines @@
   }
 
   // Return the found default property from conf files (could be NULL).
   *default_property = provider->GetDefaultProperty(device_id, name);
   return true;
 }
 
 void GesturesPropFunctionsWrapper::PostCreateProperty(
     void* device_data,
     const char* name,
-    scoped_ptr<GesturesProp> property) {
+    std::unique_ptr<GesturesProp> property) {
   // Log the creation.
   DVLOG(3) << "Created active prop: " << *property;
 
   // Add the property to the gesture property provider. The gesture property
   // provider will own it from now on.
   GesturePropertyProvider* provider = GetPropertyProvider(device_data);
   provider->AddProperty(GetDeviceId(device_data), name, std::move(property));
 }
 
 GesturesProp* GesturesPropFunctionsWrapper::CreateIntSingle(void* device_data,
@@ skipping 35 matching lines @@
 const GesturesPropProvider kGesturePropProvider = {
     GesturesPropFunctionsWrapper::CreateInt,
     GesturesPropFunctionsWrapper::CreateShort,
     GesturesPropFunctionsWrapper::CreateBool,
     GesturesPropFunctionsWrapper::CreateString,
     GesturesPropFunctionsWrapper::CreateReal,
     GesturesPropFunctionsWrapper::RegisterHandlers,
     GesturesPropFunctionsWrapper::Free};
 
 }  // namespace ui