Global conversion of Pass()→std::move() on OS=linux chromecast=1

content/browser/media/cdm/browser_cdm_manager.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 "content/browser/media/cdm/browser_cdm_manager.h"
 
 #include <stddef.h>
-
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/task_runner.h"
 #include "build/build_config.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
@@ skipping 399 matching lines @@
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
   if (certificate.empty()) {
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0, "Empty certificate.");
     return;
   }
 
-  cdm->SetServerCertificate(certificate, promise.Pass());
+  cdm->SetServerCertificate(certificate, std::move(promise));
 }
 
 void BrowserCdmManager::OnCreateSessionAndGenerateRequest(
     const CdmHostMsg_CreateSessionAndGenerateRequest_Params& params) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   int render_frame_id = params.render_frame_id;
   int cdm_id = params.cdm_id;
   const std::vector<uint8_t>& init_data = params.init_data;
   scoped_ptr<NewSessionPromise> promise(
@@ skipping 93 matching lines @@
                  << " is too long: " << response.size();
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0, "Response too long.");
     return;
   }
 
   if (response.empty()) {
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0, "Response is empty.");
     return;
   }
 
-  cdm->UpdateSession(session_id, response, promise.Pass());
+  cdm->UpdateSession(session_id, response, std::move(promise));
 }
 
 void BrowserCdmManager::OnCloseSession(int render_frame_id,
                                        int cdm_id,
                                        uint32_t promise_id,
                                        const std::string& session_id) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   scoped_ptr<SimplePromise> promise(new SimplePromise(
       weak_ptr_factory_.GetWeakPtr(), render_frame_id, cdm_id, promise_id));
 
   scoped_refptr<MediaKeys> cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
-  cdm->CloseSession(session_id, promise.Pass());
+  cdm->CloseSession(session_id, std::move(promise));
 }
 
 void BrowserCdmManager::OnRemoveSession(int render_frame_id,
                                         int cdm_id,
                                         uint32_t promise_id,
                                         const std::string& session_id) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   scoped_ptr<SimplePromise> promise(new SimplePromise(
       weak_ptr_factory_.GetWeakPtr(), render_frame_id, cdm_id, promise_id));
 
   scoped_refptr<MediaKeys> cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
-  cdm->RemoveSession(session_id, promise.Pass());
+  cdm->RemoveSession(session_id, std::move(promise));
 }
 
 void BrowserCdmManager::OnDestroyCdm(int render_frame_id, int cdm_id) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   RemoveCdm(GetId(render_frame_id, cdm_id));
 }
 
 void BrowserCdmManager::OnCdmCreated(
     int render_frame_id,
     int cdm_id,
@@ skipping 103 matching lines @@
     promise->reject(MediaKeys::NOT_SUPPORTED_ERROR, 0, "Permission denied.");
     return;
   }
 
   scoped_refptr<MediaKeys> cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
-  cdm->CreateSessionAndGenerateRequest(session_type, init_data_type,
-                                       init_data, promise.Pass());
+  cdm->CreateSessionAndGenerateRequest(session_type, init_data_type, init_data,
+                                       std::move(promise));
 }
 
 void BrowserCdmManager::LoadSessionIfPermitted(
     int render_frame_id,
     int cdm_id,
     media::MediaKeys::SessionType session_type,
     const std::string& session_id,
     scoped_ptr<media::NewSessionCdmPromise> promise,
     bool permission_was_allowed) {
   DCHECK_NE(media::MediaKeys::SessionType::TEMPORARY_SESSION, session_type);
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   if (!permission_was_allowed) {
     promise->reject(MediaKeys::NOT_SUPPORTED_ERROR, 0, "Permission denied.");
     return;
   }
 
   scoped_refptr<MediaKeys> cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
-  cdm->LoadSession(session_type, session_id, promise.Pass());
+  cdm->LoadSession(session_type, session_id, std::move(promise));
 }
 
 }  // namespace content