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 53 matching lines @@
   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.
   void OnEnabledAudioTracksChanged(
       const std::vector<MediaTrack::Id>& enabledTrackIds);
 
-  // |trackId| either empty, which means no video track is selected, or contain
-  // one element - the selected video track id.
+  // |selectedTrackId| 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> selectedTrackId);
 
  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 474 matching lines @@
 void PipelineImpl::OnEnabledAudioTracksChanged(
     const std::vector<MediaTrack::Id>& enabledTrackIds) {
   DCHECK(thread_checker_.CalledOnValidThread());
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RendererWrapper::OnEnabledAudioTracksChanged,
                  base::Unretained(renderer_wrapper_.get()), enabledTrackIds));
 }
 
 void PipelineImpl::OnSelectedVideoTrackChanged(
-    const std::vector<MediaTrack::Id>& selectedTrackId) {
+    base::Optional<MediaTrack::Id> selectedTrackId) {
   DCHECK(thread_checker_.CalledOnValidThread());
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RendererWrapper::OnSelectedVideoTrackChanged,
                  base::Unretained(renderer_wrapper_.get()), selectedTrackId));
 }
 
 void PipelineImpl::RendererWrapper::OnEnabledAudioTracksChanged(
     const std::vector<MediaTrack::Id>& enabledTrackIds) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
@@ skipping 10 matching lines @@
 
   // 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)

[watk, 2017/02/23 20:57:54]

s/currTime/curr_time/?

[servolk, 2017/02/23 21:15:48]

Done.

                                  ? shared_state_.renderer->GetMediaTime()
                                  : demuxer_->GetStartTime();
   demuxer_->OnEnabledAudioTracksChanged(enabledTrackIds, currTime);
 }
 
 void PipelineImpl::RendererWrapper::OnSelectedVideoTrackChanged(
-    const std::vector<MediaTrack::Id>& selectedTrackId) {
+    base::Optional<MediaTrack::Id> selectedTrackId) {
   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;
@@ skipping 736 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