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

ui/ozone/platform/drm/common/drm_util.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/common/drm_util.h"
 
 #include <drm_fourcc.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <xf86drmMode.h>
 
 #include "ui/display/util/edid_parser.h"
 
 #if !defined(DRM_MODE_CONNECTOR_DSI)
 #define DRM_MODE_CONNECTOR_DSI 16
 #endif
 
 namespace ui {
 
 namespace {
 
 bool IsCrtcInUse(uint32_t crtc,
-                 const ScopedVector<HardwareDisplayControllerInfo>& displays) {
-  for (size_t i = 0; i < displays.size(); ++i) {
-    if (crtc == displays[i]->crtc()->crtc_id)
+                 const std::vector<HardwareDisplayControllerInfo>& displays) {
+  for (const auto& display : displays) {
+    if (crtc == display.crtc()->crtc_id)
       return true;
   }
 
   return false;
 }
 
 uint32_t GetCrtc(int fd,
                  drmModeConnector* connector,
                  drmModeRes* resources,
-                 const ScopedVector<HardwareDisplayControllerInfo>& displays) {
+                 const std::vector<HardwareDisplayControllerInfo>& displays) {
   // If the connector already has an encoder try to re-use.
   if (connector->encoder_id) {
     ScopedDrmEncoderPtr encoder(drmModeGetEncoder(fd, connector->encoder_id));
     if (encoder && encoder->crtc_id && !IsCrtcInUse(encoder->crtc_id, displays))
       return encoder->crtc_id;
   }
 
   // Try to find an encoder for the connector.
   for (int i = 0; i < connector->count_encoders; ++i) {
     ScopedDrmEncoderPtr encoder(drmModeGetEncoder(fd, connector->encoders[i]));
@@ skipping 110 matching lines @@
 }
 
 }  // namespace
 
 HardwareDisplayControllerInfo::HardwareDisplayControllerInfo(
     ScopedDrmConnectorPtr connector,
     ScopedDrmCrtcPtr crtc,
     size_t index)
     : connector_(connector.Pass()), crtc_(crtc.Pass()), index_(index) {}
 
-HardwareDisplayControllerInfo::~HardwareDisplayControllerInfo() {
-}
-
-ScopedVector<HardwareDisplayControllerInfo> GetAvailableDisplayControllerInfos(
+std::vector<HardwareDisplayControllerInfo> GetAvailableDisplayControllerInfos(
     int fd) {
   ScopedDrmResourcesPtr resources(drmModeGetResources(fd));
   DCHECK(resources) << "Failed to get DRM resources";
-  ScopedVector<HardwareDisplayControllerInfo> displays;
+  std::vector<HardwareDisplayControllerInfo> displays;
 
   for (int i = 0; i < resources->count_connectors; ++i) {
     ScopedDrmConnectorPtr connector(
         drmModeGetConnector(fd, resources->connectors[i]));
 
     if (!connector || connector->connection != DRM_MODE_CONNECTED ||
         connector->count_modes == 0)
       continue;
 
     uint32_t crtc_id = GetCrtc(fd, connector.get(), resources.get(), displays);
     if (!crtc_id)
       continue;
 
     ScopedDrmCrtcPtr crtc(drmModeGetCrtc(fd, crtc_id));
     displays.push_back(
-        new HardwareDisplayControllerInfo(connector.Pass(), crtc.Pass(), i));
+        HardwareDisplayControllerInfo(connector.Pass(), crtc.Pass(), i));
   }
 
-  return displays.Pass();
+  return displays;
 }
 
 bool SameMode(const drmModeModeInfo& lhs, const drmModeModeInfo& rhs) {
   return lhs.clock == rhs.clock && lhs.hdisplay == rhs.hdisplay &&
          lhs.vdisplay == rhs.vdisplay && lhs.vrefresh == rhs.vrefresh &&
          lhs.hsync_start == rhs.hsync_start && lhs.hsync_end == rhs.hsync_end &&
          lhs.htotal == rhs.htotal && lhs.hskew == rhs.hskew &&
          lhs.vsync_start == rhs.vsync_start && lhs.vsync_end == rhs.vsync_end &&
          lhs.vtotal == rhs.vtotal && lhs.vscan == rhs.vscan &&
          lhs.flags == rhs.flags && strcmp(lhs.name, rhs.name) == 0;
 }
 
 DisplayMode_Params CreateDisplayModeParams(const drmModeModeInfo& mode) {
   DisplayMode_Params params;
   params.size = gfx::Size(mode.hdisplay, mode.vdisplay);
   params.is_interlaced = mode.flags & DRM_MODE_FLAG_INTERLACE;
   params.refresh_rate = GetRefreshRate(mode);
 
   return params;
 }
 
 DisplaySnapshot_Params CreateDisplaySnapshotParams(
-    HardwareDisplayControllerInfo* info,
+    const HardwareDisplayControllerInfo& info,
     int fd,
     size_t device_index,
     const gfx::Point& origin) {
   DisplaySnapshot_Params params;
-  int64 connector_index = ConnectorIndex(device_index, info->index());
+  int64 connector_index = ConnectorIndex(device_index, info.index());
   params.display_id = connector_index;
   params.origin = origin;
   params.physical_size =
-      gfx::Size(info->connector()->mmWidth, info->connector()->mmHeight);
-  params.type = GetDisplayType(info->connector());
+      gfx::Size(info.connector()->mmWidth, info.connector()->mmHeight);
+  params.type = GetDisplayType(info.connector());
   params.is_aspect_preserving_scaling =
-      IsAspectPreserving(fd, info->connector());
+      IsAspectPreserving(fd, info.connector());
 
   ScopedDrmPropertyBlobPtr edid_blob(
-      GetDrmPropertyBlob(fd, info->connector(), "EDID"));
+      GetDrmPropertyBlob(fd, info.connector(), "EDID"));
 
   if (edid_blob) {
     std::vector<uint8_t> edid(
         static_cast<uint8_t*>(edid_blob->data),
         static_cast<uint8_t*>(edid_blob->data) + edid_blob->length);
 
     GetDisplayIdFromEDID(edid, connector_index, &params.display_id,
                          &params.product_id);
 
     ParseOutputDeviceData(edid, nullptr, nullptr, &params.display_name, nullptr,
                           nullptr);
     ParseOutputOverscanFlag(edid, &params.has_overscan);
   } else {
     VLOG(1) << "Failed to get EDID blob for connector "
-            << info->connector()->connector_id;
+            << info.connector()->connector_id;
   }
 
-  for (int i = 0; i < info->connector()->count_modes; ++i) {
-    const drmModeModeInfo& mode = info->connector()->modes[i];
+  for (int i = 0; i < info.connector()->count_modes; ++i) {
+    const drmModeModeInfo& mode = info.connector()->modes[i];
     params.modes.push_back(CreateDisplayModeParams(mode));
 
-    if (info->crtc()->mode_valid && SameMode(info->crtc()->mode, mode)) {
+    if (info.crtc()->mode_valid && SameMode(info.crtc()->mode, mode)) {
       params.has_current_mode = true;
       params.current_mode = params.modes.back();
     }
 
     if (mode.type & DRM_MODE_TYPE_PREFERRED) {
       params.has_native_mode = true;
       params.native_mode = params.modes.back();
     }
   }
 
@@ skipping 28 matching lines @@
     case DRM_FORMAT_XRGB8888:
       return gfx::BufferFormat::BGRX_8888;
     case DRM_FORMAT_UYVY:
       return gfx::BufferFormat::UYVY_422;
     default:
       NOTREACHED();
       return gfx::BufferFormat::LAST;
   }
 }
 }  // namespace ui