[MediaSession] Add playbackState attribute to Blink MediaSession and use it to determine playback s…

content/browser/media/session/media_session_impl.cc

 // Copyright 2015 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/browser/media/session/media_session_impl.h"
 
 #include <algorithm>
 #include "content/browser/media/session/audio_focus_delegate.h"
 #include "content/browser/media/session/media_session_controller.h"
 #include "content/browser/media/session/media_session_player_observer.h"
@@ skipping 280 matching lines @@
     SetAudioFocusState(audio_focus_state);
 
     if (audio_focus_state_ != State::ACTIVE)
       return;
   }
 
   OnResumeInternal(suspend_type);
 }
 
 void MediaSessionImpl::Suspend(SuspendType suspend_type) {
-  DCHECK(!IsSuspended());
+  if (IsSuspended())
+    return;
 
   OnSuspendInternal(suspend_type, State::SUSPENDED);
 }
 
 void MediaSessionImpl::Stop(SuspendType suspend_type) {
   DCHECK(audio_focus_state_ != State::INACTIVE);
   DCHECK(suspend_type != SuspendType::CONTENT);
   DCHECK(!HasPepper());
 
   // TODO(mlamouri): merge the logic between UI and SYSTEM.
@@ skipping 191 matching lines @@
       !pepper_players_.empty() || !one_shot_players_.empty()) {
     return;
   }
   delegate_->AbandonAudioFocus();
 
   SetAudioFocusState(State::INACTIVE);
   NotifyAboutStateChange();
 }
 
 void MediaSessionImpl::NotifyAboutStateChange() {
+  bool is_actually_suspended = IsSuspended();
+  // Compute the actual playback state using both the MediaSessionService state
+  // and real state.
+  //
+  // TODO(zqzhang): Maybe also compute for IsControllable()? See
+  // https://crbug.com/674983
+  if (routed_service_ &&
+      routed_service_->playback_state() ==
+          blink::mojom::MediaSessionPlaybackState::PLAYING) {
+    is_actually_suspended = false;
+  }
+
   media_session_state_listeners_.Notify(audio_focus_state_);
   for (auto& observer : observers_)
-    observer.MediaSessionStateChanged(IsControllable(), IsSuspended());
+    observer.MediaSessionStateChanged(IsControllable(), is_actually_suspended);
 }
 
 void MediaSessionImpl::SetAudioFocusState(State audio_focus_state) {
   if (audio_focus_state == audio_focus_state_)
     return;
 
   audio_focus_state_ = audio_focus_state;
   switch (audio_focus_state_) {
     case State::ACTIVE:
       uma_helper_.OnSessionActive();
@@ skipping 33 matching lines @@
 }
 
 // MediaSessionService-related methods
 
 void MediaSessionImpl::OnServiceCreated(MediaSessionServiceImpl* service) {
   services_[service->GetRenderFrameHost()] = service;
 }
 
 void MediaSessionImpl::OnServiceDestroyed(MediaSessionServiceImpl* service) {
   services_.erase(service->GetRenderFrameHost());
+  if (routed_service_ == service) {
+    routed_service_ = nullptr;
+    UpdateRoutedService();
+  }
+}
+
+void MediaSessionImpl::OnMediaSessionPlaybackStateChanged(
+    MediaSessionServiceImpl* service) {
+  if (service != routed_service_)
+    return;
+  NotifyAboutStateChange();
 }
 
 void MediaSessionImpl::OnMediaSessionMetadataChanged(
     MediaSessionServiceImpl* service) {
   if (service != routed_service_)
     return;
 
   NotifyMediaSessionMetadataChange(routed_service_->metadata());
 }
 
@@ skipping 72 matching lines @@
     if (!IsServiceActiveForRenderFrameHost(frame))
       continue;
     best_frame = frame;
     min_depth = depth;
   }
 
   return best_frame ? services_[best_frame] : nullptr;
 }
 
 }  // namespace content