Android MediaSession: do not resume a UI suspended session on a system resume.

content/browser/media/android/media_session.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/android/media_session.h"
 
 #include "base/android/jni_android.h"
 #include "content/browser/media/android/media_session_observer.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 34 matching lines @@
   if (!session) {
     CreateForWebContents(web_contents);
     session = FromWebContents(web_contents);
     session->Initialize();
   }
   return session;
 }
 
 MediaSession::~MediaSession() {
   DCHECK(players_.empty());
-  DCHECK(audio_focus_state_ == State::Suspended);
+  DCHECK(audio_focus_state_ == State::Inactive);
 }
 
 bool MediaSession::AddPlayer(MediaSessionObserver* observer,
                              int player_id,
                              Type type) {
   // If the audio focus is already granted and is of type Content, there is
   // nothing to do. If it is granted of type Transient the requested type is
   // also transient, there is also nothing to do. Otherwise, the session needs
   // to request audio focus again.
   if (audio_focus_state_ == State::Active &&
       (audio_focus_type_ == Type::Content || audio_focus_type_ == type)) {
     players_.insert(PlayerIdentifier(observer, player_id));
     return true;
   }
 
   State old_audio_focus_state = audio_focus_state_;
   audio_focus_state_ = RequestSystemAudioFocus(type) ? State::Active
-                                                     : State::Suspended;
+                                                     : State::Inactive;
   audio_focus_type_ = type;
 
   if (audio_focus_state_ != State::Active)
     return false;
 
   // The session should be reset if a player is starting while all players are
   // suspended.
   if (old_audio_focus_state != State::Active)
     players_.clear();
 
@@ skipping 17 matching lines @@
     if (it->observer == observer)
       players_.erase(it++);
     else
       ++it;
   }
 
   AbandonSystemAudioFocusIfNeeded();
 }
 
 void MediaSession::OnSuspend(JNIEnv* env, jobject obj, jboolean temporary) {
-  OnSuspendInternal(temporary);
+  if (audio_focus_state_ != State::Active)
+    return;
+
+  OnSuspendInternal(SuspendType::System);
+  if (!temporary)
+    audio_focus_state_ = State::Inactive;
   UpdateWebContents();
 }
 
 void MediaSession::OnResume(JNIEnv* env, jobject obj) {
-  OnResumeInternal();
+  if (audio_focus_state_ != State::Suspended)
+    return;
+
+  OnResumeInternal(SuspendType::System);
   UpdateWebContents();
 }
 
-void MediaSession::Resume() {
+void MediaSession::Resume(SuspendType type) {
   DCHECK(IsSuspended());
 
-  OnResumeInternal();
+  OnResumeInternal(type);
 }
 
-void MediaSession::Suspend() {
+void MediaSession::Suspend(SuspendType type) {
   DCHECK(!IsSuspended());
 
   // Since the playback can be resumed, it's a transient suspension.
-  OnSuspendInternal(true);
+  OnSuspendInternal(type);
 }
 
 bool MediaSession::IsSuspended() const {
+  // TODO(mlamouri): should be == State::Suspended.
   return audio_focus_state_ != State::Active;
 }
 
 bool MediaSession::IsControllable() const {
-  // Only content type media session can be controllable unless it's stopped.
-  return audio_focus_state_ != State::Suspended &&
+  // Only content type media session can be controllable unless it is inactive.
+  return audio_focus_state_ != State::Inactive &&
          audio_focus_type_ == Type::Content;
 }
 
 void MediaSession::ResetJavaRefForTest() {
   j_media_session_.Reset();
 }
 
 bool MediaSession::IsActiveForTest() const {
   return audio_focus_state_ == State::Active;
 }
 
 MediaSession::Type MediaSession::audio_focus_type_for_test() const {
   return audio_focus_type_;
 }
 
 void MediaSession::RemoveAllPlayersForTest() {
   players_.clear();
   AbandonSystemAudioFocusIfNeeded();
 }
 
-void MediaSession::OnSuspendInternal(bool temporary) {
-  if (temporary)
-    audio_focus_state_ = State::TemporarilySuspended;
-  else
-    audio_focus_state_ = State::Suspended;
+void MediaSession::OnSuspendInternal(SuspendType type) {
+  audio_focus_state_ = State::Suspended;
+  suspend_type_ = type;
 
   for (const auto& it : players_)
     it.observer->OnSuspend(it.player_id);
 }
 
-void MediaSession::OnResumeInternal() {
+void MediaSession::OnResumeInternal(SuspendType type) {
+  if (suspend_type_ != type && type != SuspendType::UI)
+    return;
+
   audio_focus_state_ = State::Active;
 
   for (const auto& it : players_)
     it.observer->OnResume(it.player_id);
 }
 
 MediaSession::MediaSession(WebContents* web_contents)
     : WebContentsObserver(web_contents),
-      audio_focus_state_(State::Suspended),
+      audio_focus_state_(State::Inactive),
       audio_focus_type_(Type::Transient) {}
 
 void MediaSession::Initialize() {
   JNIEnv* env = base::android::AttachCurrentThread();
   DCHECK(env);
   j_media_session_.Reset(Java_MediaSession_createMediaSession(
       env,
       base::android::GetApplicationContext(),
       reinterpret_cast<intptr_t>(this)));
 }
 
 bool MediaSession::RequestSystemAudioFocus(Type type) {
   // During tests, j_media_session_ might be null.
   if (j_media_session_.is_null())
     return true;
 
   JNIEnv* env = base::android::AttachCurrentThread();
   DCHECK(env);
   return Java_MediaSession_requestAudioFocus(env, j_media_session_.obj(),
                                              type == Type::Transient);
 }
 
 void MediaSession::AbandonSystemAudioFocusIfNeeded() {
-  if (audio_focus_state_ == State::Suspended || !players_.empty())
+  if (audio_focus_state_ == State::Inactive || !players_.empty())
     return;
 
   // During tests, j_media_session_ might be null.
   if (!j_media_session_.is_null()) {
     JNIEnv* env = base::android::AttachCurrentThread();
     DCHECK(env);
     Java_MediaSession_abandonAudioFocus(env, j_media_session_.obj());
   }
 
-  audio_focus_state_ = State::Suspended;
+  audio_focus_state_ = State::Inactive;
   UpdateWebContents();
 }
 
 void MediaSession::UpdateWebContents() {
   static_cast<WebContentsImpl*>(web_contents())->OnMediaSessionStateChanged();
 }
 
 }  // namespace content