Decouple MediaSession/MediaSessionObserver from WebContents in Java[OBSOLETE, go to the combined CL]

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 "content/browser/media/session/audio_focus_delegate.h"
 #include "content/browser/media/session/media_session_player_observer.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "media/base/media_content_type.h"
 
+#if defined(OS_ANDROID)
+#include "content/browser/media/session/media_session_android.h"
+#include "jni/MediaSession_jni.h"
+#endif  // defined(OS_ANDROID)
+
 namespace content {
 
 namespace {
 
 const double kDefaultVolumeMultiplier = 1.0;
 const double kDuckingVolumeMultiplier = 0.2;
 
 }  // anonymous namespace
 
 using MediaSessionSuspendedSource =
@@ skipping 28 matching lines @@
 MediaSessionImpl* MediaSessionImpl::Get(WebContents* web_contents) {
   MediaSessionImpl* session = FromWebContents(web_contents);
   if (!session) {
     CreateForWebContents(web_contents);
     session = FromWebContents(web_contents);
     session->Initialize();
   }
   return session;
 }
 
+#if defined(OS_ANDROID)
+bool RegisterMediaSessionNatives(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
+
+// static
+base::android::ScopedJavaLocalRef<jobject> GetMediaSessionFromWebContents(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jclass>& clazz,
+    const base::android::JavaParamRef<jobject>& j_contents_android) {
+  WebContents* contents = WebContents::FromJavaWebContents(j_contents_android);
+  DCHECK(contents);

[mlamouri (slow - plz ping), 2016/10/28 10:24:50]

Early return?

[Zhiqiang Zhang (Slow), 2016/10/28 11:18:48]

Done.

+  MediaSessionImpl* session = MediaSessionImpl::Get(contents);
+  return session->session_android()->GetJavaSession();
+}
+
+#endif  // defined(OS_ANDROID)
+
 MediaSessionImpl::~MediaSessionImpl() {
   DCHECK(players_.empty());
   DCHECK(audio_focus_state_ == State::INACTIVE);
   for (auto& observer : observers_)
     observer.MediaSessionDestroyed();
   for (auto& observer : observers_)
     observer.StopObserving();
 }
 
 void MediaSessionImpl::WebContentsDestroyed() {
@@ skipping 14 matching lines @@
   observers_.AddObserver(observer);
 }
 
 void MediaSessionImpl::RemoveObserver(MediaSessionObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void MediaSessionImpl::SetMetadata(
     const base::Optional<MediaMetadata>& metadata) {
   metadata_ = metadata;
-  static_cast<WebContentsImpl*>(web_contents())
-      ->OnMediaSessionMetadataChanged();
   for (auto& observer : observers_)
     observer.MediaSessionMetadataChanged(metadata);
 }
 
 bool MediaSessionImpl::AddPlayer(MediaSessionPlayerObserver* observer,
                                  int player_id,
                                  media::MediaContentType media_content_type) {
   if (media_content_type == media::MediaContentType::Uncontrollable)
     return true;
   if (media_content_type == media::MediaContentType::Pepper)
@@ skipping 285 matching lines @@
     it.observer->OnSetVolumeMultiplier(it.player_id, GetVolumeMultiplier());
 
   UpdateWebContents();
 }
 
 MediaSessionImpl::MediaSessionImpl(WebContents* web_contents)
     : WebContentsObserver(web_contents),
       audio_focus_state_(State::INACTIVE),
       audio_focus_type_(
           AudioFocusManager::AudioFocusType::GainTransientMayDuck),
-      is_ducking_(false) {}
+      is_ducking_(false) {
+#if defined(OS_ANDROID)
+  session_android_.reset(new MediaSessionAndroid(this));
+#endif  // defined(OS_ANDROID)
+}
 
 void MediaSessionImpl::Initialize() {
   delegate_ = AudioFocusDelegate::Create(this);
 }
 
 bool MediaSessionImpl::RequestSystemAudioFocus(
     AudioFocusManager::AudioFocusType audio_focus_type) {
   bool result = delegate_->RequestAudioFocus(audio_focus_type);
   uma_helper_.RecordRequestAudioFocusResult(result);
 
@@ skipping 10 matching lines @@
     return;
   }
   delegate_->AbandonAudioFocus();
 
   SetAudioFocusState(State::INACTIVE);
   UpdateWebContents();
 }
 
 void MediaSessionImpl::UpdateWebContents() {
   media_session_state_listeners_.Notify(audio_focus_state_);
-  static_cast<WebContentsImpl*>(web_contents())->OnMediaSessionStateChanged();
   for (auto& observer : observers_)
     observer.MediaSessionStateChanged(IsControllable(), IsSuspended());
 }
 
 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_) {
@@ skipping 16 matching lines @@
   DCHECK(success);
 
   pepper_players_.insert(PlayerIdentifier(observer, player_id));
 
   observer->OnSetVolumeMultiplier(player_id, GetVolumeMultiplier());
 
   return true;
 }
 
 }  // namespace content