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

android_webview/browser/hardware_renderer.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 "android_webview/browser/hardware_renderer.h"
 
+#include <utility>
+
 #include "android_webview/browser/aw_gl_surface.h"
 #include "android_webview/browser/aw_render_thread_context_provider.h"
 #include "android_webview/browser/child_frame.h"
 #include "android_webview/browser/deferred_gpu_command_service.h"
 #include "android_webview/browser/parent_compositor_draw_constraints.h"
 #include "android_webview/browser/parent_output_surface.h"
 #include "android_webview/browser/shared_renderer_state.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/auto_reset.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 56 matching lines @@
 
 void HardwareRenderer::CommitFrame() {
   TRACE_EVENT0("android_webview", "CommitFrame");
   scroll_offset_ = shared_renderer_state_->GetScrollOffsetOnRT();
   scoped_ptr<ChildFrame> child_frame =
       shared_renderer_state_->PassCompositorFrameOnRT();
   if (!child_frame.get())
     return;
 
   ReturnResourcesInChildFrame();
-  child_frame_ = child_frame.Pass();
+  child_frame_ = std::move(child_frame);
   DCHECK(child_frame_->frame.get());
   DCHECK(!child_frame_->frame->gl_frame_data);
 }
 
 void HardwareRenderer::DrawGL(bool stencil_enabled,
                               AwDrawGLInfo* draw_info) {
   TRACE_EVENT0("android_webview", "HardwareRenderer::DrawGL");
 
   // We need to watch if the current Android context has changed and enforce
   // a clean-up in the compositor.
@@ skipping 19 matching lines @@
       child_id_ = cc::SurfaceId();
 
       // This will return all the resources to the previous compositor.
       surface_factory_.reset();
       compositor_id_ = child_frame_->compositor_id;
       surface_factory_.reset(
           new cc::SurfaceFactory(surface_manager_.get(), this));
     }
 
     scoped_ptr<cc::CompositorFrame> child_compositor_frame =
-        child_frame_->frame.Pass();
+        std::move(child_frame_->frame);
 
     // On Android we put our browser layers in physical pixels and set our
     // browser CC device_scale_factor to 1, so suppress the transform between
     // DIP and pixels.
     child_compositor_frame->delegated_frame_data->device_scale_factor = 1.0f;
 
     gfx::Size frame_size =
         child_compositor_frame->delegated_frame_data->render_pass_list.back()
             ->output_rect.size();
     bool size_changed = frame_size != frame_size_;
     frame_size_ = frame_size;
     if (child_id_.is_null() || size_changed) {
       if (!child_id_.is_null())
         surface_factory_->Destroy(child_id_);
       child_id_ = surface_id_allocator_->GenerateId();
       surface_factory_->Create(child_id_);
     }
 
     surface_factory_->SubmitCompositorFrame(child_id_,
-                                            child_compositor_frame.Pass(),
+                                            std::move(child_compositor_frame),
                                             cc::SurfaceFactory::DrawCallback());
   }
 
   gfx::Transform transform(gfx::Transform::kSkipInitialization);
   transform.matrix().setColMajorf(draw_info->transform);
   transform.Translate(scroll_offset_.x(), scroll_offset_.y());
 
   gfx::Size viewport(draw_info->width, draw_info->height);
   // Need to post the new transform matrix back to child compositor
   // because there is no onDraw during a Render Thread animation, and child
@@ skipping 25 matching lines @@
   quad_state->visible_quad_layer_rect = gfx::Rect(frame_size_);
   quad_state->opacity = 1.f;
 
   cc::SurfaceDrawQuad* surface_quad =
       render_pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
   surface_quad->SetNew(quad_state, gfx::Rect(quad_state->quad_layer_bounds),
                        gfx::Rect(quad_state->quad_layer_bounds), child_id_);
 
   scoped_ptr<cc::DelegatedFrameData> delegated_frame(
       new cc::DelegatedFrameData);
-  delegated_frame->render_pass_list.push_back(render_pass.Pass());
+  delegated_frame->render_pass_list.push_back(std::move(render_pass));
   scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
-  frame->delegated_frame_data = delegated_frame.Pass();
+  frame->delegated_frame_data = std::move(delegated_frame);
 
   if (root_id_.is_null()) {
     root_id_ = surface_id_allocator_->GenerateId();
     surface_factory_->Create(root_id_);
     display_->SetSurfaceId(root_id_, 1.f);
   }
-  surface_factory_->SubmitCompositorFrame(root_id_, frame.Pass(),
+  surface_factory_->SubmitCompositorFrame(root_id_, std::move(frame),
                                           cc::SurfaceFactory::DrawCallback());
 
   display_->Resize(viewport);
 
   if (!output_surface_) {
     scoped_refptr<cc::ContextProvider> context_provider =
         AwRenderThreadContextProvider::Create(
             gl_surface_, DeferredGpuCommandService::GetInstance());
     scoped_ptr<ParentOutputSurface> output_surface_holder(
         new ParentOutputSurface(context_provider));
     output_surface_ = output_surface_holder.get();
-    display_->Initialize(output_surface_holder.Pass(), nullptr);
+    display_->Initialize(std::move(output_surface_holder), nullptr);
   }
   output_surface_->SetExternalStencilTest(stencil_enabled);
   display_->SetExternalClip(clip);
   display_->DrawAndSwap();
 }
 
 void HardwareRenderer::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
   ReturnResourcesToCompositor(resources, compositor_id_);
 }
@@ skipping 24 matching lines @@
   child_frame_.reset();
 }
 
 void HardwareRenderer::ReturnResourcesToCompositor(
     const cc::ReturnedResourceArray& resources,
     unsigned int compositor_id) {
   shared_renderer_state_->InsertReturnedResourcesOnRT(resources, compositor_id);
 }
 
 }  // namespace android_webview