Convert Pass()→std::move() in //components/[n-z]*

components/pdf_viewer/pdf_viewer.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 <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/bitmap_uploader/bitmap_uploader.h"
 #include "components/mus/common/types.h"
 #include "components/mus/public/cpp/input_event_handler.h"
 #include "components/mus/public/cpp/scoped_window_ptr.h"
@@ skipping 78 matching lines @@
     bitmap->resize(width * height * 4);
 
     FPDF_BITMAP f_bitmap = FPDFBitmap_CreateEx(width, height, FPDFBitmap_BGRA,
                                                &(*bitmap)[0], width * 4);
     FPDFBitmap_FillRect(f_bitmap, 0, 0, width, height, 0xFFFFFFFF);
     FPDF_RenderPageBitmap(f_bitmap, page, 0, 0, width, height, 0, 0);
     FPDFBitmap_Destroy(f_bitmap);
 
     FPDF_ClosePage(page);
 
-    bitmap_uploader_->SetBitmap(width, height, bitmap.Pass(),
+    bitmap_uploader_->SetBitmap(width, height, std::move(bitmap),
                                 bitmap_uploader::BitmapUploader::BGRA);
   }
 
   // WindowTreeDelegate:
   void OnEmbed(mus::Window* root) override {
     DCHECK(!root_);
     root_ = root;
     root_->AddObserver(this);
     root_->set_input_event_handler(this);
     bitmap_uploader_.reset(new bitmap_uploader::BitmapUploader(root_));
@@ skipping 55 matching lines @@
   // web_view::mojom::FrameClient:
   void OnConnect(web_view::mojom::FramePtr frame,
                  uint32_t change_id,
                  uint32_t view_id,
                  web_view::mojom::WindowConnectType view_connect_type,
                  mojo::Array<web_view::mojom::FrameDataPtr> frame_data,
                  int64_t navigation_start_time_ticks,
                  const OnConnectCallback& callback) override {
     callback.Run();
 
-    frame_ = frame.Pass();
+    frame_ = std::move(frame);
     frame_->DidCommitProvisionalLoad();
   }
   void OnFrameAdded(uint32_t change_id,
                     web_view::mojom::FrameDataPtr frame_data) override {}
   void OnFrameRemoved(uint32_t change_id, uint32_t frame_id) override {}
   void OnFrameClientPropertyChanged(uint32_t frame_id,
                                     const mojo::String& name,
                                     mojo::Array<uint8_t> new_value) override {}
   void OnPostMessageEvent(uint32_t source_frame_id,
                           uint32_t target_frame_id,
@@ skipping 18 matching lines @@
                             web_view::mojom::FindOptionsPtr options,
                             bool reset) override {
     NOTIMPLEMENTED();
   }
   void StopHighlightingFindResults() override {}
 
   // mojo::InterfaceFactory<web_view::mojom::FrameClient>:
   void Create(
       mojo::ApplicationConnection* connection,
       mojo::InterfaceRequest<web_view::mojom::FrameClient> request) override {
-    frame_client_binding_.Bind(request.Pass());
+    frame_client_binding_.Bind(std::move(request));
   }
 
   scoped_ptr<mojo::AppRefCount> app_ref_;
   FPDF_DOCUMENT doc_;
   int current_page_;
   int page_count_;
 
   scoped_ptr<bitmap_uploader::BitmapUploader> bitmap_uploader_;
 
   mojo::Shell* shell_;
   mus::Window* root_;
 
   web_view::mojom::FramePtr frame_;
   mojo::Binding<web_view::mojom::FrameClient> frame_client_binding_;
   DeleteCallback delete_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(PDFView);
 };
 
 // Responsible for managing all the views for displaying a PDF document.
 class PDFViewerApplicationDelegate
     : public mojo::ApplicationDelegate,
       public mojo::InterfaceFactory<mus::mojom::WindowTreeClient> {
  public:
   PDFViewerApplicationDelegate(
       mojo::InterfaceRequest<mojo::Application> request,
       mojo::URLResponsePtr response,
       const mojo::Callback<void()>& destruct_callback)
       : app_(this,
-             request.Pass(),
+             std::move(request),
              base::Bind(&PDFViewerApplicationDelegate::OnTerminate,
                         base::Unretained(this))),
         doc_(nullptr),
         is_destroying_(false),
         destruct_callback_(destruct_callback) {
-    FetchPDF(response.Pass());
+    FetchPDF(std::move(response));
   }
 
   ~PDFViewerApplicationDelegate() override {
     is_destroying_ = true;
     if (doc_)
       FPDF_CloseDocument(doc_);
     while (!pdf_views_.empty())
       pdf_views_.front()->Close();
     destruct_callback_.Run();
   }
 
  private:
   void FetchPDF(mojo::URLResponsePtr response) {
     data_.clear();
-    mojo::common::BlockingCopyToString(response->body.Pass(), &data_);
+    mojo::common::BlockingCopyToString(std::move(response->body), &data_);
     if (data_.length() >= static_cast<size_t>(std::numeric_limits<int>::max()))
       return;
     doc_ = FPDF_LoadMemDocument(data_.data(), static_cast<int>(data_.length()),
                                 nullptr);
   }
 
   // Callback from the quit closure. We key off this rather than
   // ApplicationDelegate::Quit() as we don't want to shut down the messageloop
   // when we quit (the messageloop is shared among multiple PDFViews).
   void OnTerminate() { delete this; }
@@ skipping 14 matching lines @@
   // mojo::InterfaceFactory<mus::mojom::WindowTreeClient>:
   void Create(
       mojo::ApplicationConnection* connection,
       mojo::InterfaceRequest<mus::mojom::WindowTreeClient> request) override {
     PDFView* pdf_view = new PDFView(
         &app_, connection, doc_,
         base::Bind(&PDFViewerApplicationDelegate::OnPDFViewDestroyed,
                    base::Unretained(this)));
     pdf_views_.push_back(pdf_view);
     mus::WindowTreeConnection::Create(
-        pdf_view, request.Pass(),
+        pdf_view, std::move(request),
         mus::WindowTreeConnection::CreateType::DONT_WAIT_FOR_EMBED);
   }
 
   mojo::ApplicationImpl app_;
   std::string data_;
   std::vector<PDFView*> pdf_views_;
   FPDF_DOCUMENT doc_;
   bool is_destroying_;
   mojo::Callback<void()> destruct_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(PDFViewerApplicationDelegate);
 };
 
 class ContentHandlerImpl : public mojo::ContentHandler {
  public:
   ContentHandlerImpl(mojo::InterfaceRequest<ContentHandler> request)
-      : binding_(this, request.Pass()) {}
+      : binding_(this, std::move(request)) {}
   ~ContentHandlerImpl() override {}
 
  private:
   // ContentHandler:
   void StartApplication(
       mojo::InterfaceRequest<mojo::Application> request,
       mojo::URLResponsePtr response,
       const mojo::Callback<void()>& destruct_callback) override {
-    new PDFViewerApplicationDelegate(
-        request.Pass(), response.Pass(), destruct_callback);
+    new PDFViewerApplicationDelegate(std::move(request), std::move(response),
+                                     destruct_callback);
   }
 
   mojo::StrongBinding<mojo::ContentHandler> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentHandlerImpl);
 };
 
 class PDFViewer : public mojo::ApplicationDelegate,
                   public mojo::InterfaceFactory<mojo::ContentHandler> {
  public:
@@ skipping 12 matching lines @@
 
   bool ConfigureIncomingConnection(
       mojo::ApplicationConnection* connection) override {
     connection->AddService(this);
     return true;
   }
 
   // InterfaceFactory<ContentHandler>:
   void Create(mojo::ApplicationConnection* connection,
               mojo::InterfaceRequest<mojo::ContentHandler> request) override {
-    new ContentHandlerImpl(request.Pass());
+    new ContentHandlerImpl(std::move(request));
   }
 
   mojo::TracingImpl tracing_;
 
   DISALLOW_COPY_AND_ASSIGN(PDFViewer);
 };
 }  // namespace
 }  // namespace pdf_viewer
 
 MojoResult MojoMain(MojoHandle application_request) {
   mojo::ApplicationRunner runner(new pdf_viewer::PDFViewer());
   return runner.Run(application_request);
 }