Convert Pass()→std::move() in //mojo

BUG=557422
R=avi@chromium.org
TBR=ben@chromium.org

Review URL: https://codereview.chromium.org/1538823002

Cr-Commit-Position: refs/heads/master@{#366168}

8 files changed, 73 insertions, 63 deletions

diff --git a/mojo/converters/blink/blink_input_events_type_converters.cc b/mojo/converters/blink/blink_input_events_type_converters.cc
index eca9fac..3700340 100644
--- a/mojo/converters/blink/blink_input_events_type_converters.cc
+++ b/mojo/converters/blink/blink_input_events_type_converters.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/converters/blink/blink_input_events_type_converters.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "components/mus/public/interfaces/input_event_constants.mojom.h"
@@ -105,7 +107,7 @@ scoped_ptr<blink::WebInputEvent> BuildWebMouseEventFrom(
 
   web_event->clickCount = GetClickCount(event->flags);
 
-  return web_event.Pass();
+  return std::move(web_event);
 }
 
 scoped_ptr<blink::WebInputEvent> BuildWebKeyboardEvent(
@@ -137,7 +139,7 @@ scoped_ptr<blink::WebInputEvent> BuildWebKeyboardEvent(
   web_event->unmodifiedText[0] = event->key_data->unmodified_text;
 
   web_event->setKeyIdentifierFromWindowsKeyCode();
-  return web_event.Pass();
+  return std::move(web_event);
 }
 
 scoped_ptr<blink::WebInputEvent> BuildWebMouseWheelEventFrom(
@@ -188,7 +190,7 @@ scoped_ptr<blink::WebInputEvent> BuildWebMouseWheelEventFrom(
       break;
   }
 
-  return web_event.Pass();
+  return std::move(web_event);
 }
 
 }  // namespace
diff --git a/mojo/converters/geometry/geometry_type_converters.cc b/mojo/converters/geometry/geometry_type_converters.cc
index c918d01..980adbc 100644
--- a/mojo/converters/geometry/geometry_type_converters.cc
+++ b/mojo/converters/geometry/geometry_type_converters.cc
@@ -11,7 +11,7 @@ PointPtr TypeConverter<PointPtr, gfx::Point>::Convert(const gfx::Point& input) {
   PointPtr point(Point::New());
   point->x = input.x();
   point->y = input.y();
-  return point.Pass();
+  return point;
 }
 
 // static
@@ -27,7 +27,7 @@ PointFPtr TypeConverter<PointFPtr, gfx::PointF>::Convert(
   PointFPtr point(PointF::New());
   point->x = input.x();
   point->y = input.y();
-  return point.Pass();
+  return point;
 }
 
 // static
@@ -43,7 +43,7 @@ SizePtr TypeConverter<SizePtr, gfx::Size>::Convert(const gfx::Size& input) {
   SizePtr size(Size::New());
   size->width = input.width();
   size->height = input.height();
-  return size.Pass();
+  return size;
 }
 
 // static
@@ -60,7 +60,7 @@ RectPtr TypeConverter<RectPtr, gfx::Rect>::Convert(const gfx::Rect& input) {
   rect->y = input.y();
   rect->width = input.width();
   rect->height = input.height();
-  return rect.Pass();
+  return rect;
 }
 
 // static
@@ -77,7 +77,7 @@ RectFPtr TypeConverter<RectFPtr, gfx::RectF>::Convert(const gfx::RectF& input) {
   rect->y = input.y();
   rect->width = input.width();
   rect->height = input.height();
-  return rect.Pass();
+  return rect;
 }
 
 // static
@@ -138,7 +138,7 @@ InsetsPtr TypeConverter<InsetsPtr, gfx::Insets>::Convert(
   insets->left = input.left();
   insets->bottom = input.bottom();
   insets->right = input.right();
-  return insets.Pass();
+  return insets;
 }
 
 // static
diff --git a/mojo/converters/input_events/input_events_type_converters.cc b/mojo/converters/input_events/input_events_type_converters.cc
index 215c646..91a9820 100644
--- a/mojo/converters/input_events/input_events_type_converters.cc
+++ b/mojo/converters/input_events/input_events_type_converters.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/converters/input_events/input_events_type_converters.h"
 
+#include <utility>
+
 #if defined(USE_X11)
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
@@ -182,7 +184,7 @@ mus::mojom::EventPtr TypeConverter<mus::mojom::EventPtr, ui::Event>::Convert(
     pointer_data->kind = mus::mojom::POINTER_KIND_MOUSE;
     mus::mojom::LocationDataPtr location_data(mus::mojom::LocationData::New());
     SetPointerDataLocationFromEvent(*located_event, location_data.get());
-    pointer_data->location = location_data.Pass();
+    pointer_data->location = std::move(location_data);
 
     if (input.IsMouseWheelEvent()) {
       const ui::MouseWheelEvent* wheel_event =
@@ -206,9 +208,9 @@ mus::mojom::EventPtr TypeConverter<mus::mojom::EventPtr, ui::Event>::Convert(
         wheel_data->delta_y = wheel_event->y_offset();
         wheel_data->delta_z = 0;
       }
-      pointer_data->wheel_data = wheel_data.Pass();
+      pointer_data->wheel_data = std::move(wheel_data);
     }
-    event->pointer_data = pointer_data.Pass();
+    event->pointer_data = std::move(pointer_data);
   } else if (input.IsTouchEvent()) {
     const ui::TouchEvent* touch_event =
         static_cast<const ui::TouchEvent*>(&input);
@@ -218,7 +220,7 @@ mus::mojom::EventPtr TypeConverter<mus::mojom::EventPtr, ui::Event>::Convert(
     pointer_data->kind = mus::mojom::POINTER_KIND_TOUCH;
     mus::mojom::LocationDataPtr location_data(mus::mojom::LocationData::New());
     SetPointerDataLocationFromEvent(*touch_event, location_data.get());
-    pointer_data->location = location_data.Pass();
+    pointer_data->location = std::move(location_data);
 
     mus::mojom::BrushDataPtr brush_data(mus::mojom::BrushData::New());
 
@@ -229,8 +231,8 @@ mus::mojom::EventPtr TypeConverter<mus::mojom::EventPtr, ui::Event>::Convert(
     brush_data->pressure = touch_event->pointer_details().force();
     brush_data->tilt_y = 0;
     brush_data->tilt_z = 0;
-    pointer_data->brush_data = brush_data.Pass();
-    event->pointer_data = pointer_data.Pass();
+    pointer_data->brush_data = std::move(brush_data);
+    event->pointer_data = std::move(pointer_data);
 
     // TODO(rjkroege): Plumb raw pointer events on windows.
     // TODO(rjkroege): Handle force-touch on MacOS
@@ -258,9 +260,9 @@ mus::mojom::EventPtr TypeConverter<mus::mojom::EventPtr, ui::Event>::Convert(
       key_data->text = key_event->GetText();
       key_data->unmodified_text = key_event->GetUnmodifiedText();
     }
-    event->key_data = key_data.Pass();
+    event->key_data = std::move(key_data);
   }
-  return event.Pass();
+  return event;
 }
 
 // static
@@ -306,7 +308,7 @@ TypeConverter<scoped_ptr<ui::Event>, mus::mojom::EventPtr>::Convert(
               static_cast<int32_t>(input->key_data->windows_key_code),
               input->key_data->text,
               input->key_data->unmodified_text)));
-      return key_event.Pass();
+      return std::move(key_event);
     }
     case mus::mojom::EVENT_TYPE_POINTER_DOWN:
     case mus::mojom::EVENT_TYPE_POINTER_UP:
@@ -321,7 +323,7 @@ TypeConverter<scoped_ptr<ui::Event>, mus::mojom::EventPtr>::Convert(
               ui::EventFlags(input->flags)));
           event->set_location_f(location);
           event->set_root_location_f(screen_location);
-          return event.Pass();
+          return std::move(event);
         } break;
         case mus::mojom::POINTER_KIND_TOUCH: {
           DCHECK(input->pointer_data->brush_data);
@@ -334,7 +336,7 @@ TypeConverter<scoped_ptr<ui::Event>, mus::mojom::EventPtr>::Convert(
               input->pointer_data->brush_data->pressure));
           touch_event->set_location_f(location);
           touch_event->set_root_location_f(screen_location);
-          return touch_event.Pass();
+          return std::move(touch_event);
         } break;
         case mus::mojom::POINTER_KIND_PEN:
           NOTIMPLEMENTED();
@@ -353,7 +355,7 @@ TypeConverter<scoped_ptr<ui::Event>, mus::mojom::EventPtr>::Convert(
           *pre_wheel_event,
           static_cast<int>(input->pointer_data->wheel_data->delta_x),
           static_cast<int>(input->pointer_data->wheel_data->delta_y)));
-      return wheel_event.Pass();
+      return std::move(wheel_event);
     } break;
 
     default:
diff --git a/mojo/converters/network/network_type_converters.cc b/mojo/converters/network/network_type_converters.cc
index 94109da..1453c50 100644
--- a/mojo/converters/network/network_type_converters.cc
+++ b/mojo/converters/network/network_type_converters.cc
@@ -11,7 +11,7 @@ URLRequestPtr TypeConverter<URLRequestPtr, std::string>::Convert(
     const std::string& input) {
   URLRequestPtr result(URLRequest::New());
   result->url = input;
-  return result.Pass();
+  return result;
 }
 
 }  // namespace mojo
diff --git a/mojo/converters/surfaces/surfaces_type_converters.cc b/mojo/converters/surfaces/surfaces_type_converters.cc
index f094454..c6e82fc 100644
--- a/mojo/converters/surfaces/surfaces_type_converters.cc
+++ b/mojo/converters/surfaces/surfaces_type_converters.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/converters/surfaces/surfaces_type_converters.h"
 
+#include <utility>
+
 #include "base/macros.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_metadata.h"
@@ -258,7 +260,7 @@ SurfaceIdPtr TypeConverter<SurfaceIdPtr, cc::SurfaceId>::Convert(
   SurfaceIdPtr id(SurfaceId::New());
   id->local = static_cast<uint32_t>(input.id);
   id->id_namespace = cc::SurfaceIdAllocator::NamespaceForId(input);
-  return id.Pass();
+  return id;
 }
 
 // static
@@ -274,7 +276,7 @@ cc::SurfaceId TypeConverter<cc::SurfaceId, SurfaceIdPtr>::Convert(
 ColorPtr TypeConverter<ColorPtr, SkColor>::Convert(const SkColor& input) {
   ColorPtr color(Color::New());
   color->rgba = input;
-  return color.Pass();
+  return color;
 }
 
 // static
@@ -290,7 +292,7 @@ RenderPassIdPtr TypeConverter<RenderPassIdPtr, cc::RenderPassId>::Convert(
   DCHECK_LE(input.index,
             static_cast<size_t>(std::numeric_limits<uint32_t>::max()));
   pass_id->index = static_cast<uint32_t>(input.index);
-  return pass_id.Pass();
+  return pass_id;
 }
 
 // static
@@ -320,7 +322,7 @@ QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::Convert(
           DebugBorderQuadState::New();
       debug_border_state->color = Color::From(debug_border_quad->color);
       debug_border_state->width = debug_border_quad->width;
-      quad->debug_border_quad_state = debug_border_state.Pass();
+      quad->debug_border_quad_state = std::move(debug_border_state);
       break;
     }
     case cc::DrawQuad::RENDER_PASS: {
@@ -338,7 +340,7 @@ QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::Convert(
       pass_state->filters_scale = PointF::From(
           gfx::PointAtOffsetFromOrigin(render_pass_quad->filters_scale));
       // TODO(jamesr): pass_state->background_filters
-      quad->render_pass_quad_state = pass_state.Pass();
+      quad->render_pass_quad_state = std::move(pass_state);
       break;
     }
     case cc::DrawQuad::SOLID_COLOR: {
@@ -348,7 +350,7 @@ QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::Convert(
       color_state->color = Color::From(color_quad->color);
       color_state->force_anti_aliasing_off =
           color_quad->force_anti_aliasing_off;
-      quad->solid_color_quad_state = color_state.Pass();
+      quad->solid_color_quad_state = std::move(color_state);
       break;
     }
     case cc::DrawQuad::SURFACE_CONTENT: {
@@ -357,7 +359,7 @@ QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::Convert(
       SurfaceQuadStatePtr surface_state =
           SurfaceQuadState::New();
       surface_state->surface = SurfaceId::From(surface_quad->surface_id);
-      quad->surface_quad_state = surface_state.Pass();
+      quad->surface_quad_state = std::move(surface_state);
       break;
     }
     case cc::DrawQuad::TEXTURE_CONTENT: {
@@ -375,9 +377,9 @@ QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::Convert(
       for (size_t i = 0; i < 4; ++i) {
         vertex_opacity[i] = texture_quad->vertex_opacity[i];
       }
-      texture_state->vertex_opacity = vertex_opacity.Pass();
+      texture_state->vertex_opacity = std::move(vertex_opacity);
       texture_state->y_flipped = texture_quad->y_flipped;
-      quad->texture_quad_state = texture_state.Pass();
+      quad->texture_quad_state = std::move(texture_state);
       break;
     }
     case cc::DrawQuad::TILED_CONTENT: {
@@ -389,7 +391,7 @@ QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::Convert(
       tile_state->swizzle_contents = tile_quad->swizzle_contents;
       tile_state->nearest_neighbor = tile_quad->nearest_neighbor;
       tile_state->resource_id = tile_quad->resource_id();
-      quad->tile_quad_state = tile_state.Pass();
+      quad->tile_quad_state = std::move(tile_state);
       break;
     }
     case cc::DrawQuad::YUV_VIDEO_CONTENT: {
@@ -406,14 +408,14 @@ QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::Convert(
       yuv_state->a_plane_resource_id = yuv_quad->a_plane_resource_id();
       yuv_state->color_space =
           static_cast<YUVColorSpace>(yuv_quad->color_space);
-      quad->yuv_video_quad_state = yuv_state.Pass();
+      quad->yuv_video_quad_state = std::move(yuv_state);
       break;
     }
 
     default:
       NOTREACHED() << "Unsupported material " << input.material;
   }
-  return quad.Pass();
+  return quad;
 }
 
 // static
@@ -430,7 +432,7 @@ TypeConverter<mus::mojom::SharedQuadStatePtr, cc::SharedQuadState>::Convert(
   state->opacity = input.opacity;
   state->blend_mode = static_cast<mus::mojom::SkXfermode>(input.blend_mode);
   state->sorting_context_id = input.sorting_context_id;
-  return state.Pass();
+  return state;
 }
 
 // static
@@ -465,9 +467,9 @@ PassPtr TypeConverter<PassPtr, cc::RenderPass>::Convert(
   }
   // We should copy all shared quad states.
   DCHECK_EQ(next_sqs_iter.index(), shared_quad_state.size());
-  pass->quads = quads.Pass();
-  pass->shared_quad_states = shared_quad_state.Pass();
-  return pass.Pass();
+  pass->quads = std::move(quads);
+  pass->shared_quad_states = std::move(shared_quad_state);
+  return pass;
 }
 
 // static
@@ -488,7 +490,7 @@ scoped_ptr<cc::RenderPass> ConvertToRenderPass(
   cc::SharedQuadStateList::Iterator sqs_iter =
       pass->shared_quad_state_list.begin();
   for (size_t i = 0; i < input->quads.size(); ++i) {
-    QuadPtr quad = input->quads[i].Pass();
+    QuadPtr quad = std::move(input->quads[i]);
     while (quad->shared_quad_state_index > sqs_iter.index()) {
       ++sqs_iter;
     }
@@ -496,7 +498,7 @@ scoped_ptr<cc::RenderPass> ConvertToRenderPass(
                          custom_converter))
       return scoped_ptr<cc::RenderPass>();
   }
-  return pass.Pass();
+  return pass;
 }
 
 // static
@@ -516,8 +518,8 @@ MailboxPtr TypeConverter<MailboxPtr, gpu::Mailbox>::Convert(
     name[i] = input.name[i];
   }
   MailboxPtr mailbox(Mailbox::New());
-  mailbox->name = name.Pass();
-  return mailbox.Pass();
+  mailbox->name = std::move(name);
+  return mailbox;
 }
 
 // static
@@ -539,7 +541,7 @@ SyncTokenPtr TypeConverter<SyncTokenPtr, gpu::SyncToken>::Convert(
       static_cast<CommandBufferNamespace>(input.namespace_id());
   sync_token->command_buffer_id = input.command_buffer_id();
   sync_token->release_count = input.release_count();
-  return sync_token.Pass();
+  return sync_token;
 }
 
 // static
@@ -562,7 +564,7 @@ MailboxHolderPtr TypeConverter<MailboxHolderPtr, gpu::MailboxHolder>::Convert(
   holder->mailbox = Mailbox::From<gpu::Mailbox>(input.mailbox);
   holder->sync_token = SyncToken::From<gpu::SyncToken>(input.sync_token);
   holder->texture_target = input.texture_target;
-  return holder.Pass();
+  return holder;
 }
 
 // static
@@ -586,7 +588,7 @@ TypeConverter<TransferableResourcePtr, cc::TransferableResource>::Convert(
   transferable->size = Size::From(input.size);
   transferable->mailbox_holder = MailboxHolder::From(input.mailbox_holder);
   transferable->is_software = input.is_software;
-  return transferable.Pass();
+  return transferable;
 }
 
 // static
@@ -612,7 +614,7 @@ Array<TransferableResourcePtr> TypeConverter<
   for (size_t i = 0; i < input.size(); ++i) {
     resources[i] = TransferableResource::From(input[i]);
   }
-  return resources.Pass();
+  return resources;
 }
 
 // static
@@ -635,7 +637,7 @@ TypeConverter<ReturnedResourcePtr, cc::ReturnedResource>::Convert(
   returned->sync_token = SyncToken::From<gpu::SyncToken>(input.sync_token);
   returned->count = input.count;
   returned->lost = input.lost;
-  return returned.Pass();
+  return returned;
 }
 
 // static
@@ -658,7 +660,7 @@ TypeConverter<Array<ReturnedResourcePtr>, cc::ReturnedResourceArray>::Convert(
   for (size_t i = 0; i < input.size(); ++i) {
     resources[i] = ReturnedResource::From(input[i]);
   }
-  return resources.Pass();
+  return resources;
 }
 
 // static
@@ -678,7 +680,7 @@ TypeConverter<CompositorFrameMetadataPtr, cc::CompositorFrameMetadata>::Convert(
     const cc::CompositorFrameMetadata& input) {
   CompositorFrameMetadataPtr metadata = CompositorFrameMetadata::New();
   metadata->device_scale_factor = input.device_scale_factor;
-  return metadata.Pass();
+  return metadata;
 }
 
 // static
@@ -705,7 +707,7 @@ TypeConverter<CompositorFramePtr, cc::CompositorFrame>::Convert(
   for (size_t i = 0; i < pass_list.size(); ++i) {
     frame->passes[i] = Pass::From(*pass_list[i]);
   }
-  return frame.Pass();
+  return frame;
 }
 
 // static
@@ -722,13 +724,13 @@ scoped_ptr<cc::CompositorFrame> ConvertToCompositorFrame(
         input->passes[i], input->metadata, custom_converter);
     if (!pass)
       return scoped_ptr<cc::CompositorFrame>();
-    frame_data->render_pass_list.push_back(pass.Pass());
+    frame_data->render_pass_list.push_back(std::move(pass));
   }
   scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
   cc::CompositorFrameMetadata metadata =
       input->metadata.To<cc::CompositorFrameMetadata>();
-  frame->delegated_frame_data = frame_data.Pass();
-  return frame.Pass();
+  frame->delegated_frame_data = std::move(frame_data);
+  return frame;
 }
 
 // static
diff --git a/mojo/converters/surfaces/surfaces_utils.cc b/mojo/converters/surfaces/surfaces_utils.cc
index 79b2996..d0793af 100644
--- a/mojo/converters/surfaces/surfaces_utils.cc
+++ b/mojo/converters/surfaces/surfaces_utils.cc
@@ -28,7 +28,7 @@ SharedQuadStatePtr CreateDefaultSQS(const gfx::Size& size) {
   sqs->opacity = 1.f;
   sqs->blend_mode = mus::mojom::SK_XFERMODE_kSrc_Mode;
   sqs->sorting_context_id = 0;
-  return sqs.Pass();
+  return sqs;
 }
 
 PassPtr CreateDefaultPass(int id, const gfx::Rect& rect) {
@@ -41,7 +41,7 @@ PassPtr CreateDefaultPass(int id, const gfx::Rect& rect) {
   pass->damage_rect = Rect::From(rect);
   pass->transform_to_root_target = Transform::From(gfx::Transform());
   pass->has_transparent_background = false;
-  return pass.Pass();
+  return pass;
 }
 
 }  // namespace mojo
diff --git a/mojo/converters/surfaces/tests/surface_unittest.cc b/mojo/converters/surfaces/tests/surface_unittest.cc
index 3d0694b..eb4ebf3 100644
--- a/mojo/converters/surfaces/tests/surface_unittest.cc
+++ b/mojo/converters/surfaces/tests/surface_unittest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <utility>
+
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/solid_color_draw_quad.h"
@@ -180,14 +182,14 @@ TEST_F(SurfaceLibQuadTest, TextureQuadEmptyVertexOpacity) {
   mus_texture_quad->material = mus::mojom::MATERIAL_TEXTURE_CONTENT;
   TextureQuadStatePtr mus_texture_state = TextureQuadState::New();
   mus_texture_state->background_color = Color::New();
-  mus_texture_quad->texture_quad_state = mus_texture_state.Pass();
+  mus_texture_quad->texture_quad_state = std::move(mus_texture_state);
   PassPtr mus_pass = Pass::New();
   mus_pass->id = RenderPassId::New();
   mus_pass->id->layer_id = 1;
   mus_pass->id->index = 1u;
-  mus_pass->quads.push_back(mus_texture_quad.Pass());
+  mus_pass->quads.push_back(std::move(mus_texture_quad));
   SharedQuadStatePtr mus_sqs = SharedQuadState::New();
-  mus_pass->shared_quad_states.push_back(mus_sqs.Pass());
+  mus_pass->shared_quad_states.push_back(std::move(mus_sqs));
 
   scoped_ptr<cc::RenderPass> pass = mus_pass.To<scoped_ptr<cc::RenderPass>>();
 
@@ -199,14 +201,14 @@ TEST_F(SurfaceLibQuadTest, TextureQuadEmptyBackgroundColor) {
   mus_texture_quad->material = mus::mojom::MATERIAL_TEXTURE_CONTENT;
   TextureQuadStatePtr mus_texture_state = TextureQuadState::New();
   mus_texture_state->vertex_opacity = mojo::Array<float>::New(4);
-  mus_texture_quad->texture_quad_state = mus_texture_state.Pass();
+  mus_texture_quad->texture_quad_state = std::move(mus_texture_state);
   PassPtr mus_pass = Pass::New();
   mus_pass->id = RenderPassId::New();
   mus_pass->id->layer_id = 1;
   mus_pass->id->index = 1u;
-  mus_pass->quads.push_back(mus_texture_quad.Pass());
+  mus_pass->quads.push_back(std::move(mus_texture_quad));
   SharedQuadStatePtr mus_sqs = SharedQuadState::New();
-  mus_pass->shared_quad_states.push_back(mus_sqs.Pass());
+  mus_pass->shared_quad_states.push_back(std::move(mus_sqs));
 
   scoped_ptr<cc::RenderPass> pass = mus_pass.To<scoped_ptr<cc::RenderPass>>();
   EXPECT_FALSE(pass);
diff --git a/mojo/converters/transform/transform_type_converters.cc b/mojo/converters/transform/transform_type_converters.cc
index 92a5370..e2a4ced 100644
--- a/mojo/converters/transform/transform_type_converters.cc
+++ b/mojo/converters/transform/transform_type_converters.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/converters/transform/transform_type_converters.h"
 
+#include <utility>
+
 namespace mojo {
 
 // static
@@ -14,8 +16,8 @@ TransformPtr TypeConverter<TransformPtr, gfx::Transform>::Convert(
   mojo::Array<float> matrix;
   matrix.Swap(&storage);
   TransformPtr transform(Transform::New());
-  transform->matrix = matrix.Pass();
-  return transform.Pass();
+  transform->matrix = std::move(matrix);
+  return transform;
 }
 
 // static