Replace Pass() with std::move in ui/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 <utility>
 
 #include "ui/display/util/edid_parser.h"
 
 #if !defined(DRM_MODE_CONNECTOR_DSI)
 #define DRM_MODE_CONNECTOR_DSI 16
 #endif
 
 namespace ui {
 
 namespace {
@@ skipping 79 matching lines @@
 int GetDrmProperty(int fd,
                    drmModeConnector* connector,
                    const std::string& name,
                    ScopedDrmPropertyPtr* property) {
   for (int i = 0; i < connector->count_props; ++i) {
     ScopedDrmPropertyPtr tmp(drmModeGetProperty(fd, connector->props[i]));
     if (!tmp)
       continue;
 
     if (name == tmp->name) {
-      *property = tmp.Pass();
+      *property = std::move(tmp);
       return i;
     }
   }
 
   return -1;
 }
 
 std::string GetNameForEnumValue(drmModePropertyRes* property, uint32_t value) {
   for (int i = 0; i < property->count_enums; ++i)
     if (property->enums[i].value == value)
@@ skipping 33 matching lines @@
   DCHECK_LT(display_index, 16);
   return ((device_index << 4) + display_index) & 0xFF;
 }
 
 }  // namespace
 
 HardwareDisplayControllerInfo::HardwareDisplayControllerInfo(
     ScopedDrmConnectorPtr connector,
     ScopedDrmCrtcPtr crtc,
     size_t index)
-    : connector_(connector.Pass()), crtc_(crtc.Pass()), index_(index) {}
+    : connector_(std::move(connector)), crtc_(std::move(crtc)), index_(index) {}
 
 HardwareDisplayControllerInfo::~HardwareDisplayControllerInfo() {
 }
 
 ScopedVector<HardwareDisplayControllerInfo> GetAvailableDisplayControllerInfos(
     int fd) {
   ScopedDrmResourcesPtr resources(drmModeGetResources(fd));
   DCHECK(resources) << "Failed to get DRM resources";
   ScopedVector<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));
+    displays.push_back(new HardwareDisplayControllerInfo(std::move(connector),
+                                                         std::move(crtc), 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;
@@ skipping 88 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::BGRA_8888;
   }
 }
 }  // namespace ui