Implement MediaSession on top of the WebMediaPlayerDelegate.

content/renderer/media/android/webmediaplayer_android.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 "content/renderer/media/android/webmediaplayer_android.h"
 
 #include <stddef.h>
 
 #include <limits>
 
@@ skipping 166 matching lines @@
     blink::WebFrame* frame,
     blink::WebMediaPlayerClient* client,
     blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
     base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
     RendererMediaPlayerManager* player_manager,
     media::CdmFactory* cdm_factory,
     scoped_refptr<StreamTextureFactory> factory,
     int frame_id,
     bool enable_texture_copy,
     const media::WebMediaPlayerParams& params)
-    : RenderFrameObserver(RenderFrame::FromWebFrame(frame)),
-      frame_(frame),
+    : frame_(frame),
       client_(client),
       encrypted_client_(encrypted_client),
       delegate_(delegate),
+      delegate_id_(0),
       defer_load_cb_(params.defer_load_cb()),
       buffered_(static_cast<size_t>(1)),
       media_task_runner_(params.media_task_runner()),
       ignore_metadata_duration_change_(false),
       pending_seek_(false),
       seeking_(false),
       did_loading_progress_(false),
       player_manager_(player_manager),
       cdm_factory_(cdm_factory),
       media_permission_(params.media_permission()),
@@ skipping 17 matching lines @@
       is_remote_(false),
       media_log_(params.media_log()),
       init_data_type_(media::EmeInitDataType::UNKNOWN),
       cdm_context_(nullptr),
       allow_stored_credentials_(false),
       is_local_resource_(false),
       interpolator_(&default_tick_clock_),
       frame_id_(frame_id),
       enable_texture_copy_(enable_texture_copy),
       suppress_deleting_texture_(false),
+      playback_completed_(false),
+      volume_(1.0),
+      volume_multiplier_(1.0),
       weak_factory_(this) {
   DCHECK(player_manager_);
   DCHECK(cdm_factory_);
 
   DCHECK(main_thread_checker_.CalledOnValidThread());
   stream_texture_factory_->AddObserver(this);
 
+  if (delegate_)
+    delegate_id_ = delegate_->AddObserver(this);
+
   player_id_ = player_manager_->RegisterMediaPlayer(this);
 
 #if defined(VIDEO_HOLE)
-  const RendererPreferences& prefs =
-      static_cast<RenderFrameImpl*>(render_frame())
-          ->render_view()
-          ->renderer_preferences();
+  const RendererPreferences& prefs = RenderFrameImpl::FromRoutingID(frame_id)
+                                         ->render_view()
+                                         ->renderer_preferences();
   force_use_overlay_embedded_video_ = prefs.use_view_overlay_for_all_video;
   if (force_use_overlay_embedded_video_ ||
     player_manager_->ShouldUseVideoOverlayForEmbeddedEncryptedVideo()) {
     // Defer stream texture creation until we are sure it's necessary.
     needs_establish_peer_ = false;
     current_frame_ = VideoFrame::CreateBlackFrame(gfx::Size(1, 1));
   }
 #endif  // defined(VIDEO_HOLE)
   TryCreateStreamTextureProxyIfNeeded();
   interpolator_.SetUpperBound(base::TimeDelta());
@@ skipping 22 matching lines @@
     texture_id_ = 0;
     texture_mailbox_ = gpu::Mailbox();
     stream_id_ = 0;
   }
 
   {
     base::AutoLock auto_lock(current_frame_lock_);
     current_frame_ = NULL;
   }
 
-  if (delegate_)
-    delegate_->PlayerGone(this);
+  if (delegate_) {
+    delegate_->PlayerGone(delegate_id_);
+    delegate_->RemoveObserver(delegate_id_);
+  }
 
   stream_texture_factory_->RemoveObserver(this);
 
   if (media_source_delegate_) {
     // Part of |media_source_delegate_| needs to be stopped on the media thread.
     // Wait until |media_source_delegate_| is fully stopped before tearing
     // down other objects.
     base::WaitableEvent waiter(false, false);
     media_source_delegate_->Stop(
         base::Bind(&base::WaitableEvent::Signal, base::Unretained(&waiter)));
@@ skipping 125 matching lines @@
 #endif  // defined(VIDEO_HOLE)
 
   TryCreateStreamTextureProxyIfNeeded();
   // There is no need to establish the surface texture peer for fullscreen
   // video.
   if ((hasVideo() || IsHLSStream()) && needs_establish_peer_ &&
       !is_fullscreen_) {
     EstablishSurfaceTexturePeer();
   }
 
-  if (paused())
+  // UpdatePlayingState() must be run before calling Start() to ensure that the
+  // browser side MediaPlayerAndroid values for hasAudio() and hasVideo() take
+  // precedent over the guesses that we make based on mime type.
+  const bool is_paused = paused();
+  UpdatePlayingState(true);
+  if (is_paused)
     player_manager_->Start(player_id_);
-  UpdatePlayingState(true);
   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
 }
 
 void WebMediaPlayerAndroid::pause() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   Pause(true);
 }
 
 void WebMediaPlayerAndroid::requestRemotePlayback() {
   player_manager_->RequestRemotePlayback(player_id_);
 }
 
 void WebMediaPlayerAndroid::requestRemotePlaybackControl() {
   player_manager_->RequestRemotePlaybackControl(player_id_);
 }
 
 void WebMediaPlayerAndroid::seek(double seconds) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DVLOG(1) << __FUNCTION__ << "(" << seconds << ")";
 
+  playback_completed_ = false;
   base::TimeDelta new_seek_time = base::TimeDelta::FromSecondsD(seconds);
 
   if (seeking_) {
     if (new_seek_time == seek_time_) {
       if (media_source_delegate_) {
         // Don't suppress any redundant in-progress MSE seek. There could have
         // been changes to the underlying buffers after seeking the demuxer and
         // before receiving OnSeekComplete() for the currently in-progress seek.
         MEDIA_LOG(DEBUG, media_log_)
             << "Detected MediaSource seek to same time as in-progress seek to "
@@ skipping 23 matching lines @@
     media_source_delegate_->StartWaitingForSeek(seek_time_);
 
   // Kick off the asynchronous seek!
   player_manager_->Seek(player_id_, seek_time_);
 }
 
 bool WebMediaPlayerAndroid::supportsSave() const {
   return false;
 }
 
-void WebMediaPlayerAndroid::setRate(double rate) {
-  NOTIMPLEMENTED();
-}
+void WebMediaPlayerAndroid::setRate(double rate) {}
 
 void WebMediaPlayerAndroid::setVolume(double volume) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-  player_manager_->SetVolume(player_id_, volume);
+  volume_ = volume;
+  player_manager_->SetVolume(player_id_, volume_ * volume_multiplier_);
 }
 
 void WebMediaPlayerAndroid::setSinkId(
     const blink::WebString& sink_id,
     const blink::WebSecurityOrigin& security_origin,
     blink::WebSetSinkIdCallbacks* web_callback) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   scoped_ptr<blink::WebSetSinkIdCallbacks> callback(web_callback);
   callback->onError(blink::WebSetSinkIdError::NotSupported);
 }
@@ skipping 330 matching lines @@
   // know that the playback has finished. To solve this, we set the
   // current time to media duration when OnPlaybackComplete() get called.
   interpolator_.SetBounds(duration_, duration_);
   client_->timeChanged();
 
   // If the loop attribute is set, timeChanged() will update the current time
   // to 0. It will perform a seek to 0. Issue a command to the player to start
   // playing after seek completes.
   if (seeking_ && seek_time_ == base::TimeDelta())
     player_manager_->Start(player_id_);
+  else
+    playback_completed_ = true;
 }
 
 void WebMediaPlayerAndroid::OnBufferingUpdate(int percentage) {
   buffered_[0].end = duration() * percentage / 100;
   did_loading_progress_ = true;
 
   if (percentage == 100 && network_state_ < WebMediaPlayer::NetworkStateLoaded)
     UpdateNetworkState(WebMediaPlayer::NetworkStateLoaded);
 }
 
@@ skipping 216 matching lines @@
 }
 
 void WebMediaPlayerAndroid::OnPlayerReleased() {
   // |needs_external_surface_| is always false on non-TV devices.
   if (!needs_external_surface_)
     needs_establish_peer_ = true;
 
   if (is_playing_)
     OnMediaPlayerPause();
 
+  if (delegate_)
+    delegate_->PlayerGone(delegate_id_);
+
 #if defined(VIDEO_HOLE)
   last_computed_rect_ = gfx::RectF();
 #endif  // defined(VIDEO_HOLE)
 }
 
 void WebMediaPlayerAndroid::SuspendAndReleaseResources() {
   switch (network_state_) {
     // Pause the media player and inform WebKit if the player is in a good
     // shape.
     case WebMediaPlayer::NetworkStateIdle:
     case WebMediaPlayer::NetworkStateLoading:
     case WebMediaPlayer::NetworkStateLoaded:
       Pause(false);
       client_->playbackStateChanged();
+      if (delegate_)
+        delegate_->PlayerGone(delegate_id_);
       break;
     // If a WebMediaPlayer instance has entered into one of these states,
     // the internal network state in HTMLMediaElement could be set to empty.
     // And calling playbackStateChanged() could get this object deleted.
     case WebMediaPlayer::NetworkStateEmpty:
     case WebMediaPlayer::NetworkStateFormatError:
     case WebMediaPlayer::NetworkStateNetworkError:
     case WebMediaPlayer::NetworkStateDecodeError:
       break;
   }
   player_manager_->SuspendAndReleaseResources(player_id_);
   if (!needs_external_surface_)
     SetNeedsEstablishPeer(true);
 }
 
-void WebMediaPlayerAndroid::OnDestruct() {
-  NOTREACHED() << "WebMediaPlayer should be destroyed before any "
-                  "RenderFrameObserver::OnDestruct() gets called when "
-                  "the RenderFrame goes away.";
-}
-
 void WebMediaPlayerAndroid::InitializePlayer(
     const GURL& url,
     const GURL& first_party_for_cookies,
     bool allow_stored_credentials,
     int demuxer_client_id) {
   ReportHLSMetrics();
 
   allow_stored_credentials_ = allow_stored_credentials;
   player_manager_->Initialize(
       player_type_, player_id_, url, first_party_for_cookies, demuxer_client_id,
-      frame_->document().url(), allow_stored_credentials);
+      frame_->document().url(), allow_stored_credentials, delegate_id_);
   is_player_initialized_ = true;
 
   if (is_fullscreen_)
     player_manager_->EnterFullscreen(player_id_);
 
   if (cdm_context_)
     SetCdmInternal(base::Bind(&media::IgnoreCdmAttached));
 }
 
 void WebMediaPlayerAndroid::Pause(bool is_media_related_action) {
@@ skipping 219 matching lines @@
     return;
 
   is_playing_ = is_playing;
 
   if (is_playing)
     interpolator_.StartInterpolating();
   else
     interpolator_.StopInterpolating();
 
   if (delegate_) {
-    if (is_playing)
-      delegate_->DidPlay(this);
-    else
-      delegate_->DidPause(this);
+    if (is_playing) {
+      // We must specify either video or audio to the delegate, but neither may
+      // be known at this point -- there are no video only containers, so only
+      // send audio if we know for sure its audio.  The browser side player will
+      // fill in the correct value later for media sessions.
+      delegate_->DidPlay(delegate_id_, hasVideo(), !hasVideo(), isRemote(),
+                         duration_);
+    } else {
+      // Even if OnPlaybackComplete() has not been called yet, Blink may have
+      // already fired the ended event based on current time relative to
+      // duration -- so we need to check both possibilities here.
+      delegate_->DidPause(delegate_id_,
+                          playback_completed_ || currentTime() >= duration());
+    }
   }
 }
 
 #if defined(VIDEO_HOLE)
 bool WebMediaPlayerAndroid::UpdateBoundaryRectangle() {
   if (!video_weblayer_)
     return false;
 
   // Compute the geometry of video frame layer.
   cc::Layer* layer = video_weblayer_->layer();
@@ skipping 362 matching lines @@
 
 void WebMediaPlayerAndroid::OnWaitingForDecryptionKey() {
   encrypted_client_->didBlockPlaybackWaitingForKey();
 
   // TODO(jrummell): didResumePlaybackBlockedForKey() should only be called
   // when a key has been successfully added (e.g. OnSessionKeysChange() with
   // |has_additional_usable_key| = true). http://crbug.com/461903
   encrypted_client_->didResumePlaybackBlockedForKey();
 }
 
+void WebMediaPlayerAndroid::OnHidden() {
+  // RendererMediaPlayerManager will not call SuspendAndReleaseResources() if we
+  // were already in the paused state; thus notify the MediaWebContentsObserver
+  // that we've been hidden so any lingering MediaSessions are released.
+  if (delegate_)
+    delegate_->PlayerGone(delegate_id_);
+}
+
+void WebMediaPlayerAndroid::OnShown() {}
+
+void WebMediaPlayerAndroid::OnPlay() {
+  play();
+  client_->playbackStateChanged();
+}
+
+void WebMediaPlayerAndroid::OnPause() {
+  pause();
+  client_->playbackStateChanged();
+}
+
+void WebMediaPlayerAndroid::OnVolumeMultiplierUpdate(double multiplier) {
+  volume_multiplier_ = multiplier;
+  setVolume(volume_);
+}
+
 void WebMediaPlayerAndroid::OnCdmContextReady(media::CdmContext* cdm_context) {
   DCHECK(!cdm_context_);
 
   if (!cdm_context) {
     LOG(ERROR) << "CdmContext not available (e.g. CDM creation failed).";
     return;
   }
 
   cdm_context_ = cdm_context;
 
@@ skipping 106 matching lines @@
     result = PREDICTION_RESULT_PATH_BASED_WAS_BETTER;
   } else if (is_hls_url == is_hls) {
     result = PREDICTION_RESULT_URL_BASED_WAS_BETTER;
   }
   UMA_HISTOGRAM_ENUMERATION(
       "Media.Android.IsHttpLiveStreamingMediaPredictionResult",
       result, PREDICTION_RESULT_MAX);
 }
 
 }  // namespace content