Remove deprecated ScopedVector usage from ui/ozone and ui/events/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 <gestures/gestures.h>
 #include <libevdev/libevdev.h>
 
 #include <fnmatch.h>
@@ skipping 697 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;
-  ScopedVector<MatchCriteria> criterias;
-  ScopedVector<GesturesProp> properties;
+  std::vector<scoped_ptr<MatchCriteria>> criterias;
+  std::vector<scoped_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 213 matching lines @@
 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,
-                                          GesturesProp* property) {
+                                          scoped_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, scoped_ptr<GesturesProp>(property));
+    device_data->properties.set(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);
 }
 
@@ skipping 60 matching lines @@
   //    (e.g., "Non-linearity").
 
   // 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(new internal::ConfigurationSection());
-    internal::ConfigurationSection* config = configurations_.back();
+    configurations_.push_back(
+        make_scoped_ptr(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());
 
       // Skip empty lines.
@@ skipping 51 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) {
-            GesturesProp* property = CreateDefaultProperty(option_name, arg);
+            scoped_ptr<GesturesProp> property =
+                CreateDefaultProperty(option_name, arg);
             if (property)
-              config->properties.push_back(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)) {
-              internal::MatchCriteria* criteria =
+              scoped_ptr<internal::MatchCriteria> criteria =
                   CreateMatchCriteria(match_type, arg);
               if (criteria)
-                config->criterias.push_back(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.
           if (has_checked_section_type) {
             if (piece == "Driver") {
               // "Driver" field is meaningless for non-X11 setup.
@@ skipping 24 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) {
-          GesturesProp* property = CreateDefaultProperty(option_name, "on");
+          scoped_ptr<GesturesProp> property =
+              CreateDefaultProperty(option_name, "on");
           if (property)
-            config->properties.push_back(property);
+            config->properties.push_back(std::move(property));
         } else if (IsMatchTypeSupported(match_type) &&
                    IsMatchDeviceType(match_type)) {
-          internal::MatchCriteria* criteria =
+          scoped_ptr<internal::MatchCriteria> criteria =
               CreateMatchCriteria(match_type, "on");
           if (criteria)
-            config->criterias.push_back(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();
     }
   }
 }
 
-internal::MatchCriteria* GesturePropertyProvider::CreateMatchCriteria(
-    const std::string& match_type,
-    const std::string& arg) {
+scoped_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 new internal::MatchProduct(arg);
+    return make_scoped_ptr(new internal::MatchProduct(arg));
   if (match_type == "MatchDevicePath")
-    return new internal::MatchDevicePath(arg);
+    return make_scoped_ptr(new internal::MatchDevicePath(arg));
   if (match_type == "MatchUSBID")
-    return new internal::MatchUSBID(arg);
+    return make_scoped_ptr(new internal::MatchUSBID(arg));
   if (match_type == "MatchIsPointer")
-    return new internal::MatchIsPointer(arg);
+    return make_scoped_ptr(new internal::MatchIsPointer(arg));
   if (match_type == "MatchIsTouchpad")
-    return new internal::MatchIsTouchpad(arg);
+    return make_scoped_ptr(new internal::MatchIsTouchpad(arg));
   if (match_type == "MatchIsTouchscreen")
-    return new internal::MatchIsTouchscreen(arg);
+    return make_scoped_ptr(new internal::MatchIsTouchscreen(arg));
   NOTREACHED();
   return NULL;
 }
 
-GesturesProp* GesturePropertyProvider::CreateDefaultProperty(
+scoped_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.
-  GesturesProp* property = NULL;
+  scoped_ptr<GesturesProp> property;
   if (is_all_numeric && numbers.size()) {
-    property = new GesturesDoubleProp(
-        name, numbers.size(), NULL, numbers.data(), NULL);
+    property.reset(new GesturesDoubleProp(name, numbers.size(), NULL,
+                                          numbers.data(), NULL));
   } else {
-    property = new GesturesStringProp(name, NULL, value.c_str(), NULL);
+    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.
   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;
-  for (size_t i = 0; i < configurations_.size(); ++i) {
-    if (configurations_[i]->Match(device)) {
-      DVLOG(2) << "Conf section \"" << configurations_[i]->identifier
+  for (const auto& configuration : configurations_) {
+    if (configuration->Match(device)) {
+      DVLOG(2) << "Conf section \"" << configuration->identifier
                << "\" is matched";
-      for (size_t j = 0; j < configurations_[i]->properties.size(); j++) {
-        GesturesProp* property = configurations_[i]->properties[j];
+      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;
+        property_map[property->name()] = property.get();
       }
     }
   }
 }
 
 GesturesProp* GesturesPropFunctionsWrapper::CreateInt(void* device_data,
                                                       const char* name,
                                                       int* value,
                                                       size_t count,
                                                       const int* init) {
@@ skipping 31 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, property);
+  PostCreateProperty(device_data, name, make_scoped_ptr(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, property);
+  PostCreateProperty(device_data, name, make_scoped_ptr(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 11 matching lines @@
     LOG(WARNING) << "Gesture property \"" << name
                  << "\" re-created. This shouldn't happen at the normal usage.";
     Free(device_data, property);
   }
 
   // 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,
-                                                      GesturesProp* property) {
+void GesturesPropFunctionsWrapper::PostCreateProperty(
+    void* device_data,
+    const char* name,
+    scoped_ptr<GesturesProp> 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, property);
+  provider->AddProperty(GetDeviceId(device_data), name, std::move(property));
 
   // Log the creation.
   DVLOG(3) << "Created active prop: " << *property;
 }
 
 GesturesProp* GesturesPropFunctionsWrapper::CreateIntSingle(void* device_data,
                                                             const char* name,
                                                             int* value,
                                                             int init) {
   return CreateInt(device_data, name, value, 1, &init);
@@ skipping 31 matching lines @@
 const GesturesPropProvider kGesturePropProvider = {
     GesturesPropFunctionsWrapper::CreateInt,
     GesturesPropFunctionsWrapper::CreateShort,
     GesturesPropFunctionsWrapper::CreateBool,
     GesturesPropFunctionsWrapper::CreateString,
     GesturesPropFunctionsWrapper::CreateReal,
     GesturesPropFunctionsWrapper::RegisterHandlers,
     GesturesPropFunctionsWrapper::Free};
 
 }  // namespace ui