Remove deprecated ScopedVector usage from ui/ozone and ui/events/ozone

ui/ozone/platform/drm/gpu/drm_gpu_display_manager.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/ozone/platform/drm/gpu/drm_gpu_display_manager.h"
 
 #include "ui/display/types/gamma_ramp_rgb_entry.h"
 #include "ui/ozone/common/display_util.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
@@ skipping 10 matching lines @@
   explicit DisplayComparator(const DrmDisplay* display)
       : drm_(display->drm()),
         crtc_(display->crtc()),
         connector_(display->connector()) {}
 
   DisplayComparator(const scoped_refptr<DrmDevice>& drm,
                     uint32_t crtc,
                     uint32_t connector)
       : drm_(drm), crtc_(crtc), connector_(connector) {}
 
-  bool operator()(const DrmDisplay* other) const {
+  bool operator()(const scoped_ptr<DrmDisplay>& other) const {
     return drm_ == other->drm() && connector_ == other->connector() &&
            crtc_ == other->crtc();
   }
 
  private:
   scoped_refptr<DrmDevice> drm_;
   uint32_t crtc_;
   uint32_t connector_;
 };
 
@@ skipping 17 matching lines @@
 
 DrmGpuDisplayManager::DrmGpuDisplayManager(ScreenManager* screen_manager,
                                            DrmDeviceManager* drm_device_manager)
     : screen_manager_(screen_manager), drm_device_manager_(drm_device_manager) {
 }
 
 DrmGpuDisplayManager::~DrmGpuDisplayManager() {
 }
 
 std::vector<DisplaySnapshot_Params> DrmGpuDisplayManager::GetDisplays() {
-  ScopedVector<DrmDisplay> old_displays(displays_.Pass());
+  std::vector<scoped_ptr<DrmDisplay>> old_displays;
+  old_displays.swap(displays_);
   std::vector<DisplaySnapshot_Params> params_list;
 
   const DrmDeviceVector& devices = drm_device_manager_->GetDrmDevices();
   size_t device_index = 0;
   for (const auto& drm : devices) {
     ScopedVector<HardwareDisplayControllerInfo> display_infos =
         GetAvailableDisplayControllerInfos(drm->get_fd());
     for (auto* display_info : display_infos) {
       auto it = std::find_if(
           old_displays.begin(), old_displays.end(),
           DisplayComparator(drm, display_info->crtc()->crtc_id,
                             display_info->connector()->connector_id));
       if (it != old_displays.end()) {
-        displays_.push_back(*it);
-        old_displays.weak_erase(it);
+        displays_.push_back(std::move(*it));
+        old_displays.erase(it);
       } else {
-        displays_.push_back(new DrmDisplay(screen_manager_, drm));
+        displays_.push_back(
+            make_scoped_ptr(new DrmDisplay(screen_manager_, drm)));
       }
       params_list.push_back(
           displays_.back()->Update(display_info, device_index));
     }
     device_index++;
   }
 
-  NotifyScreenManager(displays_.get(), old_displays.get());
+  NotifyScreenManager(displays_, old_displays);
   return params_list;
 }
 
 bool DrmGpuDisplayManager::TakeDisplayControl() {
   const DrmDeviceVector& devices = drm_device_manager_->GetDrmDevices();
   bool status = true;
   for (const auto& drm : devices)
     status &= drm->SetMaster();
 
   // Roll-back any successful operation.
@@ skipping 21 matching lines @@
     return false;
   }
 
   drmModeModeInfo mode;
   bool mode_found = FindMatchingMode(display->modes(), mode_param, &mode);
   if (!mode_found) {
     // If the display doesn't have the mode natively, then lookup the mode from
     // other displays and try using it on the current display (some displays
     // support panel fitting and they can use different modes even if the mode
     // isn't explicitly declared).
-    for (DrmDisplay* other : displays_) {
-      mode_found = FindMatchingMode(other->modes(), mode_param, &mode);
+    for (const auto& other_display : displays_) {
+      mode_found = FindMatchingMode(other_display->modes(), mode_param, &mode);
       if (mode_found)
         break;
     }
   }
 
   if (!mode_found) {
     LOG(ERROR) << "Failed to find mode: size=" << mode_param.size.ToString()
                << " is_interlaced=" << mode_param.is_interlaced
                << " refresh_rate=" << mode_param.refresh_rate;
     return false;
@@ skipping 38 matching lines @@
   DrmDisplay* display = FindDisplay(display_id);
   if (!display) {
     LOG(ERROR) << "There is no display with ID " << display_id;
     return;
   }
 
   display->SetGammaRamp(lut);
 }
 
 DrmDisplay* DrmGpuDisplayManager::FindDisplay(int64_t display_id) {
-  for (DrmDisplay* display : displays_)
+  for (const auto& display : displays_) {
     if (display->display_id() == display_id)
-      return display;
+      return display.get();
+  }
 
   return nullptr;
 }
 
 void DrmGpuDisplayManager::NotifyScreenManager(
-    const std::vector<DrmDisplay*>& new_displays,
-    const std::vector<DrmDisplay*>& old_displays) const {
-  for (size_t i = 0; i < old_displays.size(); ++i) {
-    const std::vector<DrmDisplay*>::const_iterator it =
-        std::find_if(new_displays.begin(), new_displays.end(),
-                     DisplayComparator(old_displays[i]));
+    const std::vector<scoped_ptr<DrmDisplay>>& new_displays,
+    const std::vector<scoped_ptr<DrmDisplay>>& old_displays) const {
+  for (const auto& old_display : old_displays) {
+    auto it = std::find_if(new_displays.begin(), new_displays.end(),
+                           DisplayComparator(old_display.get()));
 
     if (it == new_displays.end()) {
-      screen_manager_->RemoveDisplayController(old_displays[i]->drm(),
-                                               old_displays[i]->crtc());
+      screen_manager_->RemoveDisplayController(old_display->drm(),
+                                               old_display->crtc());
     }
   }
 
-  for (size_t i = 0; i < new_displays.size(); ++i) {
-    const std::vector<DrmDisplay*>::const_iterator it =
-        std::find_if(old_displays.begin(), old_displays.end(),
-                     DisplayComparator(new_displays[i]));
+  for (const auto& new_display : new_displays) {
+    auto it = std::find_if(old_displays.begin(), old_displays.end(),
+                           DisplayComparator(new_display.get()));
 
     if (it == old_displays.end()) {
-      screen_manager_->AddDisplayController(new_displays[i]->drm(),
-                                            new_displays[i]->crtc(),
-                                            new_displays[i]->connector());
+      screen_manager_->AddDisplayController(
+          new_display->drm(), new_display->crtc(), new_display->connector());
     }
   }
 }
 
 }  // namespace ui