Global conversion of Pass()→std::move() on OS=linux (GYP edition)

components/exo/wayland/server.cc

 // Copyright 2015 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 "components/exo/wayland/server.h"
 
 #include <linux/input.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <wayland-server-core.h>
 #include <wayland-server-protocol-core.h>
 #include <xdg-shell-unstable-v5-server-protocol.h>
-
 #include <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/cancelable_callback.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/exo/buffer.h"
 #include "components/exo/display.h"
 #include "components/exo/keyboard.h"
 #include "components/exo/keyboard_delegate.h"
 #include "components/exo/pointer.h"
@@ skipping 25 matching lines @@
 
 template <class T>
 T* GetUserDataAs(wl_resource* resource) {
   return static_cast<T*>(wl_resource_get_user_data(resource));
 }
 
 template <class T>
 scoped_ptr<T> TakeUserDataAs(wl_resource* resource) {
   scoped_ptr<T> user_data = make_scoped_ptr(GetUserDataAs<T>(resource));
   wl_resource_set_user_data(resource, nullptr);
-  return user_data.Pass();
+  return user_data;
 }
 
 template <class T>
 void DestroyUserData(wl_resource* resource) {
   TakeUserDataAs<T>(resource);
 }
 
 template <class T>
 void SetImplementation(wl_resource* resource,
                        const void* implementation,
@@ skipping 70 matching lines @@
 
   // base::Unretained is safe as the resource owns the callback.
   scoped_ptr<base::CancelableCallback<void(base::TimeTicks)>>
   cancelable_callback(new base::CancelableCallback<void(base::TimeTicks)>(
       base::Bind(&handle_surface_frame_callback,
                  base::Unretained(callback_resource))));
 
   GetUserDataAs<Surface>(resource)
       ->RequestFrameCallback(cancelable_callback->callback());
 
-  SetImplementation(callback_resource, nullptr, cancelable_callback.Pass());
+  SetImplementation(callback_resource, nullptr, std::move(cancelable_callback));
 }
 
 void surface_set_opaque_region(wl_client* client,
                                wl_resource* resource,
                                wl_resource* region_resource) {
   GetUserDataAs<Surface>(resource)->SetOpaqueRegion(
       region_resource ? *GetUserDataAs<SkRegion>(region_resource)
                       : SkRegion(SkIRect::MakeEmpty()));
 }
 
@@ skipping 73 matching lines @@
   wl_resource* surface_resource = wl_resource_create(
       client, &wl_surface_interface, wl_resource_get_version(resource), id);
   if (!surface_resource) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   // Set the surface resource property for type-checking downcast support.
   surface->SetProperty(kSurfaceResourceKey, surface_resource);
 
-  SetImplementation(surface_resource, &surface_implementation, surface.Pass());
+  SetImplementation(surface_resource, &surface_implementation,
+                    std::move(surface));
 }
 
 void compositor_create_region(wl_client* client,
                               wl_resource* resource,
                               uint32_t id) {
   scoped_ptr<SkRegion> region(new SkRegion);
 
   wl_resource* region_resource =
       wl_resource_create(client, &wl_region_interface, 1, id);
   if (!region_resource) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
-  SetImplementation(region_resource, &region_implementation, region.Pass());
+  SetImplementation(region_resource, &region_implementation, std::move(region));
 }
 
 const struct wl_compositor_interface compositor_implementation = {
     compositor_create_surface, compositor_create_region};
 
 const uint32_t compositor_version = 3;
 
 void bind_compositor(wl_client* client,
                      void* data,
                      uint32_t version,
@@ skipping 61 matching lines @@
   wl_resource* buffer_resource =
       wl_resource_create(client, &wl_buffer_interface, 1, id);
   if (!buffer_resource) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   buffer->set_release_callback(
       base::Bind(&wl_buffer_send_release, base::Unretained(buffer_resource)));
 
-  SetImplementation(buffer_resource, &buffer_implementation, buffer.Pass());
+  SetImplementation(buffer_resource, &buffer_implementation, std::move(buffer));
 }
 
 void shm_pool_destroy(wl_client* client, wl_resource* resource) {
   wl_resource_destroy(resource);
 }
 
 void shm_pool_resize(wl_client* client, wl_resource* resource, int32_t size) {
   // Nothing to do here.
 }
 
@@ skipping 17 matching lines @@
   }
 
   wl_resource* shm_pool_resource =
       wl_resource_create(client, &wl_shm_pool_interface, 1, id);
   if (!shm_pool_resource) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   SetImplementation(shm_pool_resource, &shm_pool_implementation,
-                    shared_memory.Pass());
+                    std::move(shared_memory));
 }
 
 const struct wl_shm_interface shm_implementation = {shm_create_pool};
 
 void bind_shm(wl_client* client, void* data, uint32_t version, uint32_t id) {
   wl_resource* resource = wl_resource_create(client, &wl_shm_interface, 1, id);
   if (!resource) {
     wl_client_post_no_memory(client);
     return;
   }
@@ skipping 183 matching lines @@
   }
 
   wl_resource* subsurface_resource =
       wl_resource_create(client, &wl_subsurface_interface, 1, id);
   if (!subsurface_resource) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   SetImplementation(subsurface_resource, &subsurface_implementation,
-                    subsurface.Pass());
+                    std::move(subsurface));
 }
 
 const struct wl_subcompositor_interface subcompositor_implementation = {
     subcompositor_destroy, subcompositor_get_subsurface};
 
 void bind_subcompositor(wl_client* client,
                         void* data,
                         uint32_t version,
                         uint32_t id) {
   wl_resource* resource =
@@ skipping 104 matching lines @@
   }
 
   wl_resource* shell_surface_resource =
       wl_resource_create(client, &wl_shell_surface_interface, 1, id);
   if (!shell_surface_resource) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   SetImplementation(shell_surface_resource, &shell_surface_implementation,
-                    shell_surface.Pass());
+                    std::move(shell_surface));
 }
 
 const struct wl_shell_interface shell_implementation = {
     shell_get_shell_surface};
 
 void bind_shell(wl_client* client, void* data, uint32_t version, uint32_t id) {
   wl_resource* resource =
       wl_resource_create(client, &wl_shell_interface, 1, id);
   if (!resource) {
     wl_client_post_no_memory(client);
@@ skipping 144 matching lines @@
       wl_resource_create(client, &xdg_surface_interface, 1, id);
   if (!xdg_surface_resource) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   // An XdgSurface is a toplevel shell surface.
   shell_surface->SetToplevel();
 
   SetImplementation(xdg_surface_resource, &xdg_surface_implementation,
-                    shell_surface.Pass());
+                    std::move(shell_surface));
 }
 
 void xdg_shell_get_xdg_popup(wl_client* client,
                              wl_resource* resource,
                              uint32_t id,
                              wl_resource* surface,
                              wl_resource* parent,
                              wl_resource* seat,
                              uint32_t serial,
                              int32_t x,
@@ skipping 560 matching lines @@
   DCHECK(event_loop);
   wl_event_loop_dispatch(event_loop, timeout.InMilliseconds());
 }
 
 void Server::Flush() {
   wl_display_flush_clients(wl_display_.get());
 }
 
 }  // namespace wayland
 }  // namespace exo