Use base::Optional for selected video track.

media/base/pipeline_impl.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 "media/base/pipeline_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 49 matching lines @@
   void Suspend();
   void Resume(std::unique_ptr<Renderer> renderer, base::TimeDelta time);
   void SetPlaybackRate(double playback_rate);
   void SetVolume(float volume);
   base::TimeDelta GetMediaTime() const;
   Ranges<base::TimeDelta> GetBufferedTimeRanges() const;
   bool DidLoadingProgress();
   PipelineStatistics GetStatistics() const;
   void SetCdm(CdmContext* cdm_context, const CdmAttachedCB& cdm_attached_cb);
 
-  // |enabledTrackIds| contains track ids of enabled audio tracks.
+  // |enabled_track_ids| contains track ids of enabled audio tracks.
   void OnEnabledAudioTracksChanged(
-      const std::vector<MediaTrack::Id>& enabledTrackIds);
+      const std::vector<MediaTrack::Id>& enabled_track_ids);
 
-  // |trackId| either empty, which means no video track is selected, or contain
-  // one element - the selected video track id.
+  // |selected_track_id| is either empty, which means no video track is
+  // selected, or contains the selected video track id.
   void OnSelectedVideoTrackChanged(
-      const std::vector<MediaTrack::Id>& selectedTrackId);
+      base::Optional<MediaTrack::Id> selected_track_id);
 
  private:
   // Contains state shared between main and media thread.
   // Main thread can only read. Media thread can both - read and write.
   // So it is not necessary to lock when reading from the media thread.
   // This struct should only contain state that is not immediately needed by
   // PipelineClient and can be cached on the media thread until queried.
   // Alternatively we could cache it on the main thread by posting the
   // notification to the main thread. But some of the state change notifications
   // (OnStatisticsUpdate and OnBufferedTimeRangesChanged) arrive much more
@@ skipping 465 matching lines @@
 
   if (state_ != kPlaying)
     return;
 
   DCHECK(!renderer_ended_);
   renderer_ended_ = true;
   CheckPlaybackEnded();
 }
 
 void PipelineImpl::OnEnabledAudioTracksChanged(
-    const std::vector<MediaTrack::Id>& enabledTrackIds) {
+    const std::vector<MediaTrack::Id>& enabled_track_ids) {
   DCHECK(thread_checker_.CalledOnValidThread());
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RendererWrapper::OnEnabledAudioTracksChanged,
-                 base::Unretained(renderer_wrapper_.get()), enabledTrackIds));
+                 base::Unretained(renderer_wrapper_.get()), enabled_track_ids));
 }
 
 void PipelineImpl::OnSelectedVideoTrackChanged(
-    const std::vector<MediaTrack::Id>& selectedTrackId) {
+    base::Optional<MediaTrack::Id> selected_track_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RendererWrapper::OnSelectedVideoTrackChanged,
-                 base::Unretained(renderer_wrapper_.get()), selectedTrackId));
+                 base::Unretained(renderer_wrapper_.get()), selected_track_id));
 }
 
 void PipelineImpl::RendererWrapper::OnEnabledAudioTracksChanged(
-    const std::vector<MediaTrack::Id>& enabledTrackIds) {
+    const std::vector<MediaTrack::Id>& enabled_track_ids) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // If the pipeline has been created, but not started yet, we may still receive
   // track notifications from blink level (e.g. when video track gets deselected
   // due to player/pipeline belonging to a background tab). We can safely ignore
   // these, since WebMediaPlayerImpl will ensure that demuxer stream / track
   // status is in sync with blink after pipeline is started.
   if (state_ == kCreated) {
     DCHECK(!demuxer_);
     return;
   }
 
   // Track status notifications might be delivered asynchronously. If we receive
   // a notification when pipeline is stopped/shut down, it's safe to ignore it.
   if (state_ == kStopping || state_ == kStopped) {
     return;
   }
 
   DCHECK(demuxer_);
   DCHECK(shared_state_.renderer || (state_ != kPlaying));
 
-  base::TimeDelta currTime = (state_ == kPlaying)
-                                 ? shared_state_.renderer->GetMediaTime()
-                                 : demuxer_->GetStartTime();
-  demuxer_->OnEnabledAudioTracksChanged(enabledTrackIds, currTime);
+  base::TimeDelta curr_time = (state_ == kPlaying)
+                                  ? shared_state_.renderer->GetMediaTime()
+                                  : demuxer_->GetStartTime();
+  demuxer_->OnEnabledAudioTracksChanged(enabled_track_ids, curr_time);
 }
 
 void PipelineImpl::RendererWrapper::OnSelectedVideoTrackChanged(
-    const std::vector<MediaTrack::Id>& selectedTrackId) {
+    base::Optional<MediaTrack::Id> selected_track_id) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // If the pipeline has been created, but not started yet, we may still receive
   // track notifications from blink level (e.g. when video track gets deselected
   // due to player/pipeline belonging to a background tab). We can safely ignore
   // these, since WebMediaPlayerImpl will ensure that demuxer stream / track
   // status is in sync with blink after pipeline is started.
   if (state_ == kCreated) {
     DCHECK(!demuxer_);
     return;
   }
 
   // Track status notifications might be delivered asynchronously. If we receive
   // a notification when pipeline is stopped/shut down, it's safe to ignore it.
   if (state_ == kStopping || state_ == kStopped) {
     return;
   }
 
   DCHECK(demuxer_);
   DCHECK(shared_state_.renderer || (state_ != kPlaying));
 
-  base::TimeDelta currTime = (state_ == kPlaying)
-                                 ? shared_state_.renderer->GetMediaTime()
-                                 : demuxer_->GetStartTime();
-  demuxer_->OnSelectedVideoTrackChanged(selectedTrackId, currTime);
+  base::TimeDelta curr_time = (state_ == kPlaying)
+                                  ? shared_state_.renderer->GetMediaTime()
+                                  : demuxer_->GetStartTime();
+  demuxer_->OnSelectedVideoTrackChanged(selected_track_id, curr_time);
 }
 
 void PipelineImpl::RendererWrapper::OnStatisticsUpdate(
     const PipelineStatistics& stats) {
   DVLOG(3) << __func__;
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(shared_state_lock_);
   shared_state_.statistics.audio_bytes_decoded += stats.audio_bytes_decoded;
   shared_state_.statistics.video_bytes_decoded += stats.video_bytes_decoded;
@@ skipping 711 matching lines @@
 void PipelineImpl::OnSuspendDone() {
   DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(!suspend_cb_.is_null());
   base::ResetAndReturn(&suspend_cb_).Run(PIPELINE_OK);
 }
 
 }  // namespace media