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

media/formats/mp2t/mp2t_stream_parser.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 "media/formats/mp2t/mp2t_stream_parser.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/stl_util.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/text_track_config.h"
 #include "media/base/timestamp_constants.h"
 #include "media/formats/mp2t/es_parser.h"
 #include "media/formats/mp2t/es_parser_adts.h"
 #include "media/formats/mp2t/es_parser_h264.h"
 #include "media/formats/mp2t/es_parser_mpeg1audio.h"
@@ skipping 48 matching lines @@
 
   int pid_;
   PidType pid_type_;
   scoped_ptr<TsSection> section_parser_;
 
   bool enable_;
 
   int continuity_counter_;
 };
 
-PidState::PidState(int pid, PidType pid_type,
+PidState::PidState(int pid,
+                   PidType pid_type,
                    scoped_ptr<TsSection> section_parser)
-  : pid_(pid),
-    pid_type_(pid_type),
-    section_parser_(section_parser.Pass()),
-    enable_(false),
-    continuity_counter_(-1) {
+    : pid_(pid),
+      pid_type_(pid_type),
+      section_parser_(std::move(section_parser)),
+      enable_(false),
+      continuity_counter_(-1) {
   DCHECK(section_parser_);
 }
 
 bool PidState::PushTsPacket(const TsPacket& ts_packet) {
   DCHECK_EQ(ts_packet.pid(), pid_);
 
   // The current PID is not part of the PID filter,
   // just discard the incoming TS packet.
   if (!enable_)
     return true;
@@ skipping 182 matching lines @@
 
     // Parse the section.
     std::map<int, PidState*>::iterator it = pids_.find(ts_packet->pid());
     if (it == pids_.end() &&
         ts_packet->pid() == TsSection::kPidPat) {
       // Create the PAT state here if needed.
       scoped_ptr<TsSection> pat_section_parser(
           new TsSectionPat(
               base::Bind(&Mp2tStreamParser::RegisterPmt,
                          base::Unretained(this))));
-      scoped_ptr<PidState> pat_pid_state(
-          new PidState(ts_packet->pid(), PidState::kPidPat,
-                       pat_section_parser.Pass()));
+      scoped_ptr<PidState> pat_pid_state(new PidState(
+          ts_packet->pid(), PidState::kPidPat, std::move(pat_section_parser)));
       pat_pid_state->Enable();
       it = pids_.insert(
           std::pair<int, PidState*>(ts_packet->pid(),
                                     pat_pid_state.release())).first;
     }
 
     if (it != pids_.end()) {
       if (!it->second->PushTsPacket(*ts_packet))
         return false;
     } else {
@@ skipping 26 matching lines @@
     }
   }
 
   // Create the PMT state here if needed.
   DVLOG(1) << "Create a new PMT parser";
   scoped_ptr<TsSection> pmt_section_parser(
       new TsSectionPmt(
           base::Bind(&Mp2tStreamParser::RegisterPes,
                      base::Unretained(this), pmt_pid)));
   scoped_ptr<PidState> pmt_pid_state(
-      new PidState(pmt_pid, PidState::kPidPmt, pmt_section_parser.Pass()));
+      new PidState(pmt_pid, PidState::kPidPmt, std::move(pmt_section_parser)));
   pmt_pid_state->Enable();
   pids_.insert(std::pair<int, PidState*>(pmt_pid, pmt_pid_state.release()));
 }
 
 void Mp2tStreamParser::RegisterPes(int pmt_pid,
                                    int pes_pid,
                                    int stream_type) {
   // TODO(damienv): check there is no mismatch if the entry already exists.
   DVLOG(1) << "RegisterPes:"
            << " pes_pid=" << pes_pid
@@ skipping 33 matching lines @@
                    pes_pid),
         media_log_));
     is_audio = true;
   } else {
     return;
   }
 
   // Create the PES state here.
   DVLOG(1) << "Create a new PES state";
   scoped_ptr<TsSection> pes_section_parser(
-      new TsSectionPes(es_parser.Pass(), &timestamp_unroller_));
+      new TsSectionPes(std::move(es_parser), &timestamp_unroller_));
   PidState::PidType pid_type =
       is_audio ? PidState::kPidAudioPes : PidState::kPidVideoPes;
   scoped_ptr<PidState> pes_pid_state(
-      new PidState(pes_pid, pid_type, pes_section_parser.Pass()));
+      new PidState(pes_pid, pid_type, std::move(pes_section_parser)));
   pids_.insert(std::pair<int, PidState*>(pes_pid, pes_pid_state.release()));
 
   // A new PES pid has been added, the PID filter might change.
   UpdatePidFilter();
 }
 
 void Mp2tStreamParser::UpdatePidFilter() {
   // Applies the HLS rule to select the default audio/video PIDs:
   // select the audio/video streams with the lowest PID.
   // TODO(damienv): this can be changed when the StreamParser interface
@@ skipping 240 matching lines @@
   // so that buffers with the same config can be added later on.
   BufferQueueWithConfig queue_with_config(
       true, last_audio_config, last_video_config);
   buffer_queue_chain_.push_back(queue_with_config);
 
   return true;
 }
 
 }  // namespace mp2t
 }  // namespace media