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

ui/ozone/platform/drm/host/drm_display_host_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/host/drm_display_host_manager.h"
 
 #include <fcntl.h>
 #include <xf86drm.h>
 
 #include "base/files/file_enumerator.h"
@@ skipping 80 matching lines @@
   }
   DVLOG(1) << "Don't support VGEM";
   return base::FilePath();
 }
 
 class FindDrmDisplayHostById {
  public:
   explicit FindDrmDisplayHostById(int64_t display_id)
       : display_id_(display_id) {}
 
-  bool operator()(const DrmDisplayHost* display) const {
+  bool operator()(const scoped_ptr<DrmDisplayHost>& display) const {
     return display->snapshot()->display_id() == display_id_;
   }
 
  private:
   int64_t display_id_;
 };
 
 }  // namespace
 
 DrmDisplayHostManager::DrmDisplayHostManager(
@@ skipping 16 matching lines @@
       return;
     }
     drm_devices_.insert(primary_graphics_card_path_);
 
     vgem_card_path_ = GetVgemCardPath();
   }
 
   device_manager_->AddObserver(this);
   proxy_->RegisterHandler(this);
 
-  ScopedVector<HardwareDisplayControllerInfo> display_infos =
+  std::vector<HardwareDisplayControllerInfo> display_infos =
       GetAvailableDisplayControllerInfos(primary_drm_device_handle_->fd());
   has_dummy_display_ = !display_infos.empty();
   for (size_t i = 0; i < display_infos.size(); ++i) {
-    displays_.push_back(new DrmDisplayHost(
+    displays_.push_back(make_scoped_ptr(new DrmDisplayHost(
         proxy_, CreateDisplaySnapshotParams(display_infos[i],
                                             primary_drm_device_handle_->fd(), 0,
                                             gfx::Point()),
-        true /* is_dummy */));
+        true /* is_dummy */)));
   }
 }
 
 DrmDisplayHostManager::~DrmDisplayHostManager() {
   device_manager_->RemoveObserver(this);
   proxy_->UnregisterHandler(this);
 }
 
 DrmDisplayHost* DrmDisplayHostManager::GetDisplay(int64_t display_id) {
   auto it = std::find_if(displays_.begin(), displays_.end(),
                          FindDrmDisplayHostById(display_id));
   if (it == displays_.end())
     return nullptr;
 
-  return *it;
+  return it->get();
 }
 
 void DrmDisplayHostManager::AddDelegate(DrmNativeDisplayDelegate* delegate) {
   DCHECK(!delegate_);
   delegate_ = delegate;
 }
 
 void DrmDisplayHostManager::RemoveDelegate(DrmNativeDisplayDelegate* delegate) {
   DCHECK_EQ(delegate_, delegate);
   delegate_ = nullptr;
@@ skipping 188 matching lines @@
   IPC_MESSAGE_HANDLER(OzoneHostMsg_DisplayControlRelinquished,
                       OnRelinquishDisplayControl)
   IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void DrmDisplayHostManager::OnUpdateNativeDisplays(
     const std::vector<DisplaySnapshot_Params>& params) {
-  ScopedVector<DrmDisplayHost> old_displays(displays_.Pass());
+  std::vector<scoped_ptr<DrmDisplayHost>> old_displays;
+  displays_.swap(old_displays);
   for (size_t i = 0; i < params.size(); ++i) {
     auto it = std::find_if(old_displays.begin(), old_displays.end(),
                            FindDrmDisplayHostById(params[i].display_id));
     if (it == old_displays.end()) {
-      displays_.push_back(
-          new DrmDisplayHost(proxy_, params[i], false /* is_dummy */));
+      displays_.push_back(make_scoped_ptr(
+          new DrmDisplayHost(proxy_, params[i], false /* is_dummy */)));
     } else {
       (*it)->UpdateDisplaySnapshot(params[i]);
-      displays_.push_back(*it);
-      old_displays.weak_erase(it);
+      displays_.push_back(it->Pass());
+      old_displays.erase(it);
     }
   }
 
   if (!get_displays_callback_.is_null()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&DrmDisplayHostManager::RunUpdateDisplaysCallback,
                    weak_ptr_factory_.GetWeakPtr(), get_displays_callback_));
     get_displays_callback_.Reset();
   }
@@ skipping 63 matching lines @@
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(relinquish_display_control_callback_, status));
   relinquish_display_control_callback_.Reset();
   display_control_change_pending_ = false;
 }
 
 void DrmDisplayHostManager::RunUpdateDisplaysCallback(
     const GetDisplaysCallback& callback) const {
   std::vector<DisplaySnapshot*> snapshots;
-  for (auto* display : displays_)
+  for (const auto& display : displays_)
     snapshots.push_back(display->snapshot());
 
   callback.Run(snapshots);
 }
 
 void DrmDisplayHostManager::NotifyDisplayDelegate() const {
   if (delegate_)
     delegate_->OnConfigurationChanged();
 }
 
 }  // namespace ui