Convert Pass()→std::move() in //content (Android edition)

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/cancelable_callback.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 196 matching lines @@
   return g_surface_manager.Pointer();
 }
 
 // static
 scoped_ptr<cc::SurfaceIdAllocator> CompositorImpl::CreateSurfaceIdAllocator() {
   scoped_ptr<cc::SurfaceIdAllocator> allocator(
       new cc::SurfaceIdAllocator(++g_surface_id_namespace));
   cc::SurfaceManager* manager = GetSurfaceManager();
   DCHECK(manager);
   allocator->RegisterSurfaceIdNamespace(manager);
-  return allocator.Pass();
+  return allocator;
 }
 
 CompositorImpl::CompositorImpl(CompositorClient* client,
                                gfx::NativeWindow root_window)
     : root_layer_(cc::Layer::Create(Compositor::LayerSettings())),
       resource_manager_(root_window),
       surface_id_allocator_(GetSurfaceManager() ? CreateSurfaceIdAllocator()
                                                 : nullptr),
       has_transparent_background_(false),
       device_scale_factor_(1),
@@ skipping 419 matching lines @@
   DCHECK(context_provider.get());
 
   scoped_ptr<cc::OutputSurface> real_output_surface(
       new OutputSurfaceWithoutParent(
           this, context_provider,
           base::Bind(&CompositorImpl::PopulateGpuCapabilities,
                      base::Unretained(this))));
 
   cc::SurfaceManager* manager = GetSurfaceManager();
   if (manager) {
-    display_client_.reset(new cc::OnscreenDisplayClient(
-        real_output_surface.Pass(), manager, HostSharedBitmapManager::current(),
-        BrowserGpuMemoryBufferManager::current(),
-        host_->settings().renderer_settings,
-        base::ThreadTaskRunnerHandle::Get()));
+    display_client_.reset(
+        new cc::OnscreenDisplayClient(std::move(real_output_surface), manager,
+                                      HostSharedBitmapManager::current(),
+                                      BrowserGpuMemoryBufferManager::current(),
+                                      host_->settings().renderer_settings,
+                                      base::ThreadTaskRunnerHandle::Get()));
     scoped_ptr<cc::SurfaceDisplayOutputSurface> surface_output_surface(
         new cc::SurfaceDisplayOutputSurface(
             manager, surface_id_allocator_.get(), context_provider, nullptr));
 
     display_client_->set_surface_output_surface(surface_output_surface.get());
     surface_output_surface->set_display_client(display_client_.get());
     display_client_->display()->Resize(size_);
-    host_->SetOutputSurface(surface_output_surface.Pass());
+    host_->SetOutputSurface(std::move(surface_output_surface));
   } else {
-    host_->SetOutputSurface(real_output_surface.Pass());
+    host_->SetOutputSurface(std::move(real_output_surface));
   }
 }
 
 void CompositorImpl::PopulateGpuCapabilities(
     gpu::Capabilities gpu_capabilities) {
   gpu_capabilities_ = gpu_capabilities;
 }
 
 void CompositorImpl::AddObserver(VSyncObserver* observer) {
   observer_list_.AddObserver(observer);
@@ skipping 69 matching lines @@
 void CompositorImpl::DidCommit() {
   root_window_->OnCompositingDidCommit();
 }
 
 void CompositorImpl::AttachLayerForReadback(scoped_refptr<cc::Layer> layer) {
   root_layer_->AddChild(layer);
 }
 
 void CompositorImpl::RequestCopyOfOutputOnRootLayer(
     scoped_ptr<cc::CopyOutputRequest> request) {
-  root_layer_->RequestCopyOfOutput(request.Pass());
+  root_layer_->RequestCopyOfOutput(std::move(request));
 }
 
 void CompositorImpl::OnVSync(base::TimeTicks frame_time,
                              base::TimeDelta vsync_period) {
   vsync_period_ = vsync_period;
   last_vsync_ = frame_time;
 
   if (WillCompositeThisFrame()) {
     // We somehow missed the last vsync interval, so reschedule for deadline.
     // We cannot schedule immediately, or will get us out-of-phase with new
@@ skipping 17 matching lines @@
 
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->visible())
     return;
 
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content