Implement MediaSession on top of the WebMediaPlayerDelegate.

media/blink/webmediaplayer_impl.cc

 // Copyright 2013 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/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 168 matching lines @@
       encrypted_media_support_(cdm_factory,
                                encrypted_client,
                                params.media_permission(),
                                base::Bind(&WebMediaPlayerImpl::SetCdm,
                                           AsWeakPtr(),
                                           base::Bind(&IgnoreCdmAttached))),
       is_cdm_attached_(false),
 #if defined(OS_ANDROID)  // WMPI_CAST
       cast_impl_(this, client_, params.context_3d_cb(), delegate),
 #endif
+      volume_(1.0),
+      volume_multiplier_(1.0),
       renderer_factory_(std::move(renderer_factory)) {
   DCHECK(!adjust_allocated_memory_cb_.is_null());
   DCHECK(renderer_factory_);
 
   if (delegate)
     delegate->AddObserver(this);
 
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
@@ skipping 12 matching lines @@
           ? params.audio_renderer_sink()
           : new NullAudioSink(media_task_runner_));
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   client_->setWebLayer(NULL);
 
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (delegate_) {
+    delegate_->PlayerGone(this);
     delegate_->RemoveObserver(this);
-    delegate_->PlayerGone(this);
   }
 
   // Abort any pending IO so stopping the pipeline doesn't get blocked.
   if (data_source_)
     data_source_->Abort();
   if (chunk_demuxer_) {
     chunk_demuxer_->Shutdown();
     chunk_demuxer_ = NULL;
   }
 
@@ skipping 92 matching lines @@
 #endif
 
   paused_ = false;
 
   pipeline_.SetPlaybackRate(playback_rate_);
   if (data_source_)
     data_source_->MediaIsPlaying();
 
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::PLAY));
 
-  if (delegate_ && playback_rate_ > 0)
+  if (playback_rate_ > 0)
     NotifyPlaybackStarted();
 }
 
 void WebMediaPlayerImpl::pause() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   const bool was_already_paused = paused_ || playback_rate_ == 0;
   paused_ = true;
 
 #if defined(OS_ANDROID)  // WMPI_CAST
   if (isRemote()) {
     cast_impl_.pause();
     return;
   }
 #endif
 
   pipeline_.SetPlaybackRate(0.0);
   UpdatePausedTime();
 
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::PAUSE));
 
-  if (!was_already_paused && delegate_)
+  if (!was_already_paused)
     NotifyPlaybackPaused();
 }
 
 bool WebMediaPlayerImpl::supportsSave() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   return supports_save_;
 }
 
 void WebMediaPlayerImpl::seek(double seconds) {
   DVLOG(1) << __FUNCTION__ << "(" << seconds << "s)";
@@ skipping 99 matching lines @@
   // following checks so rewind uses reasonable values also.
   if (rate < 0.0)
     return;
 
   // Limit rates to reasonable values by clamping.
   if (rate != 0.0) {
     if (rate < kMinRate)
       rate = kMinRate;
     else if (rate > kMaxRate)
       rate = kMaxRate;
-    if (playback_rate_ == 0 && !paused_ && delegate_)
+    if (playback_rate_ == 0 && !paused_)
       NotifyPlaybackStarted();
-  } else if (playback_rate_ != 0 && !paused_ && delegate_) {
+  } else if (playback_rate_ != 0 && !paused_) {
     NotifyPlaybackPaused();
   }
 
   playback_rate_ = rate;
   if (!paused_) {
     pipeline_.SetPlaybackRate(rate);
     if (data_source_)
       data_source_->MediaPlaybackRateChanged(rate);
   }
 }
 
 void WebMediaPlayerImpl::setVolume(double volume) {
   DVLOG(1) << __FUNCTION__ << "(" << volume << ")";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
-
-  pipeline_.SetVolume(volume);
+  volume_ = volume;
+  pipeline_.SetVolume(volume_ * volume_multiplier_);
 }
 
 void WebMediaPlayerImpl::setSinkId(
     const blink::WebString& sink_id,
     const blink::WebSecurityOrigin& security_origin,
     blink::WebSetSinkIdCallbacks* web_callback) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   media::SwitchOutputDeviceCB callback =
@@ skipping 401 matching lines @@
 void WebMediaPlayerImpl::OnPipelineSeeked(bool time_changed,
                                           PipelineStatus status) {
   DVLOG(1) << __FUNCTION__ << "(" << time_changed << ", " << status << ")";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (status != PIPELINE_OK) {
     OnPipelineError(status);
     return;
   }
 
+  // If we we're resuming into the playing state, notify the delegate.
+  if (resuming_ && playback_rate_ > 0 && !paused_)
+    NotifyPlaybackStarted();
+
   // Whether or not the seek was caused by a resume, we're not suspended now.
   resuming_ = false;
   suspended_ = false;
 
   // If there is a pending suspend, the seek does not complete until after the
   // next resume.
   if (pending_suspend_) {
     pending_suspend_ = false;
     pending_time_change_ = time_changed;
     Suspend();
@@ skipping 24 matching lines @@
 void WebMediaPlayerImpl::OnPipelineSuspended(PipelineStatus status) {
   DVLOG(1) << __FUNCTION__ << "(" << status << ")";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (status != PIPELINE_OK) {
     OnPipelineError(status);
     return;
   }
 
   suspending_ = false;
+  if (delegate_)
+    delegate_->PlayerGone(this);
 
 #if defined(OS_ANDROID)
   if (isRemote()) {
     scoped_refptr<VideoFrame> frame = cast_impl_.GetCastingBanner();
     if (frame) {
       compositor_->PaintFrameUsingOldRenderingPath(frame);
     }
   }
 #endif
 
@@ skipping 209 matching lines @@
   if (pending_suspend_) {
     pending_suspend_ = false;
     return;
   }
 
   // Might already be resuming iff we came back from remote playback recently.
   if (suspended_ && !resuming_)
     Resume();
 }
 
+void WebMediaPlayerImpl::OnPlay() {
+  play();
+  client_->playbackStateChanged();
+}
+
+void WebMediaPlayerImpl::OnPause() {
+  pause();
+  client_->playbackStateChanged();
+}
+
+void WebMediaPlayerImpl::OnVolumeMultiplierUpdate(double multiplier) {
+  volume_multiplier_ = multiplier;
+  setVolume(volume_);
+}
+
 void WebMediaPlayerImpl::Resume() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   CHECK(suspended_);
   CHECK(!resuming_);
 
   // If there was a time change pending when we suspended (which can happen when
   // we suspend immediately after a seek), surface it after resuming.
   bool time_changed = pending_time_change_;
   pending_time_change_ = false;
 
@@ skipping 264 matching lines @@
       ended_ ? pipeline_.GetMediaDuration() : pipeline_.GetMediaTime();
 }
 
 void WebMediaPlayerImpl::NotifyPlaybackStarted() {
 #if defined(OS_ANDROID)  // WMPI_CAST
   // We do not tell our delegates about remote playback, becuase that would
   // keep the device awake, which is not what we want.
   if (isRemote())
     return;
 #endif
-  if (delegate_)
-    delegate_->DidPlay(this);
+  if (delegate_) {
+    delegate_->DidPlay(this, hasVideo(), hasAudio(), false,
+                       pipeline_.GetMediaDuration());
+  }
   if (!memory_usage_reporting_timer_.IsRunning()) {
     memory_usage_reporting_timer_.Start(FROM_HERE,
                                         base::TimeDelta::FromSeconds(2), this,
                                         &WebMediaPlayerImpl::ReportMemoryUsage);
   }
 }
 
 void WebMediaPlayerImpl::NotifyPlaybackPaused() {
 #if defined(OS_ANDROID)  // WMPI_CAST
   if (isRemote())
     return;
 #endif
   if (delegate_)
-    delegate_->DidPause(this);
+    delegate_->DidPause(this, ended_);
   memory_usage_reporting_timer_.Stop();
   ReportMemoryUsage();
 }
 
 void WebMediaPlayerImpl::ReportMemoryUsage() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // About base::Unretained() usage below: We destroy |demuxer_| on the main
   // thread.  Before that, however, ~WebMediaPlayerImpl() posts a task to the
   // media thread and waits for it to finish.  Hence, the GetMemoryUsage() task
@@ skipping 22 matching lines @@
            << ", Video: " << stats.video_memory_usage << ", DataSource: "
            << (data_source_ ? data_source_->GetMemoryUsage() : 0)
            << ", Demuxer: " << demuxer_memory_usage;
 
   const int64_t delta = current_memory_usage - last_reported_memory_usage_;
   last_reported_memory_usage_ = current_memory_usage;
   adjust_allocated_memory_cb_.Run(delta);
 }
 
 }  // namespace media