NOT FOR LANDING Implement WebMediaSession

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/context_utils.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"
@@ skipping 36 matching lines @@
 MediaSession* MediaSession::Get(WebContents* web_contents) {
   MediaSession* session = FromWebContents(web_contents);
   if (!session) {
     CreateForWebContents(web_contents);
     session = FromWebContents(web_contents);
     session->Initialize();
   }
   return session;
 }
 
+// static
+MediaSession* MediaSession::Create(WebContents* web_contents, int session_id) {
+  MediaSession* session = new MediaSession(web_contents, session_id);
+  session->Initialize();
+  return session;
+}
+
 MediaSession::~MediaSession() {
   DCHECK(players_.empty());
   DCHECK(audio_focus_state_ == State::INACTIVE);
 }
 
+bool MediaSession::Activate() {
+  if (audio_focus_state_ == State::ACTIVE)
+    return true;
+
+  const Type type = Type::Content;
+  if (!RequestSystemAudioFocus(type))
+    return false;
+
+  audio_focus_state_ = State::ACTIVE;
+  audio_focus_type_ = type;
+  UpdateWebContents();
+
+  return true;
+}
+
+void MediaSession::Deactivate() {
+  AbandonSystemAudioFocusIfNeeded();
+  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));
@@ skipping 188 matching lines @@
     return;
 
   SetAudioFocusState(State::ACTIVE);
 
   for (const auto& it : players_)
     it.observer->OnResume(it.player_id);
 
   UpdateWebContents();
 }
 
-MediaSession::MediaSession(WebContents* web_contents)
+MediaSession::MediaSession(WebContents* web_contents, int session_id_)
     : WebContentsObserver(web_contents),
       audio_focus_state_(State::INACTIVE),
-      audio_focus_type_(Type::Transient) {}
+      audio_focus_type_(Type::Transient),
+      session_id_(session_id_) {}
 
 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)));
 }
 
@@ skipping 19 matching lines @@
     JNIEnv* env = base::android::AttachCurrentThread();
     DCHECK(env);
     Java_MediaSession_abandonAudioFocus(env, j_media_session_.obj());
   }
 
   SetAudioFocusState(State::INACTIVE);
   UpdateWebContents();
 }
 
 void MediaSession::UpdateWebContents() {
-  static_cast<WebContentsImpl*>(web_contents())->OnMediaSessionStateChanged();
+  static_cast<WebContentsImpl*>(web_contents())
+      ->OnMediaSessionStateChanged(this);
 }
 
 void MediaSession::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();
       break;
     case State::SUSPENDED:
       uma_helper_.OnSessionSuspended();
       break;
     case State::INACTIVE:
       uma_helper_.OnSessionInactive();
       break;
   }
 }
 
 }  // namespace content