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

chrome/renderer/chrome_render_process_observer.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 "chrome/renderer/chrome_render_process_observer.h"
 
 #include <stddef.h>
-
 #include <limits>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ skipping 97 matching lines @@
 
   base::WeakPtrFactory<RendererResourceDelegate> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererResourceDelegate);
 };
 
 static const int kWaitForWorkersStatsTimeoutMS = 20;
 
 class ResourceUsageReporterImpl : public ResourceUsageReporter {
  public:
-  ResourceUsageReporterImpl(
-      base::WeakPtr<ChromeRenderProcessObserver> observer,
-      mojo::InterfaceRequest<ResourceUsageReporter> req)
-      : binding_(this, req.Pass()), observer_(observer), weak_factory_(this) {}
+  ResourceUsageReporterImpl(base::WeakPtr<ChromeRenderProcessObserver> observer,
+                            mojo::InterfaceRequest<ResourceUsageReporter> req)
+      : binding_(this, std::move(req)),
+        observer_(observer),
+        weak_factory_(this) {}
   ~ResourceUsageReporterImpl() override {}
 
  private:
   static void CollectOnWorkerThread(
       const scoped_refptr<base::TaskRunner>& master,
       base::WeakPtr<ResourceUsageReporterImpl> impl) {
     size_t total_bytes = 0;
     size_t used_bytes = 0;
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     if (isolate) {
@@ skipping 10 matching lines @@
   void ReceiveStats(size_t total_bytes, size_t used_bytes) {
     usage_data_->v8_bytes_allocated += total_bytes;
     usage_data_->v8_bytes_used += used_bytes;
     workers_to_go_--;
     if (!workers_to_go_)
       SendResults();
   }
 
   void SendResults() {
     if (!callback_.is_null())
-      callback_.Run(usage_data_.Pass());
+      callback_.Run(std::move(usage_data_));
     callback_.reset();
     weak_factory_.InvalidateWeakPtrs();
     workers_to_go_ = 0;
   }
 
   void GetUsageData(
       const mojo::Callback<void(ResourceUsageDataPtr)>& callback) override {
     DCHECK(callback_.is_null());
     weak_factory_.InvalidateWeakPtrs();
     usage_data_ = ResourceUsageData::New();
@@ skipping 41 matching lines @@
   int workers_to_go_;
   mojo::StrongBinding<ResourceUsageReporter> binding_;
   base::WeakPtr<ChromeRenderProcessObserver> observer_;
 
   base::WeakPtrFactory<ResourceUsageReporterImpl> weak_factory_;
 };
 
 void CreateResourceUsageReporter(
     base::WeakPtr<ChromeRenderProcessObserver> observer,
     mojo::InterfaceRequest<ResourceUsageReporter> request) {
-  new ResourceUsageReporterImpl(observer, request.Pass());
+  new ResourceUsageReporterImpl(observer, std::move(request));
 }
 
 }  // namespace
 
 bool ChromeRenderProcessObserver::is_incognito_process_ = false;
 
 ChromeRenderProcessObserver::ChromeRenderProcessObserver()
     : webkit_initialized_(false), weak_factory_(this) {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
@@ skipping 100 matching lines @@
 ChromeRenderProcessObserver::content_setting_rules() const {
   return &content_setting_rules_;
 }
 
 void ChromeRenderProcessObserver::OnFieldTrialGroupFinalized(
     const std::string& trial_name,
     const std::string& group_name) {
   content::RenderThread::Get()->Send(
       new ChromeViewHostMsg_FieldTrialActivated(trial_name));
 }