Link MediaSessionTabHelper with native MediaSession [CL is going to be split]

content/browser/media/session/media_session.h

 // 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.
 
 #ifndef CONTENT_BROWSER_MEDIA_SESSION_MEDIA_SESSION_H_
 #define CONTENT_BROWSER_MEDIA_SESSION_MEDIA_SESSION_H_
 
 #include <stddef.h>
 
 #include "base/callback_list.h"
 #include "base/id_map.h"
 #include "base/macros.h"
 #include "base/optional.h"
+#include "base/observer_list.h"
 #include "content/browser/media/session/audio_focus_manager.h"
 #include "content/browser/media/session/media_session_uma_helper.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "content/public/common/media_metadata.h"
 
 class MediaSessionBrowserTest;
 
 namespace media {
 enum class MediaContentType;
 }  // namespace media
 
 namespace content {
 
 class AudioFocusDelegate;
 class AudioFocusManagerTest;
 class MediaSessionPlayerObserver;
+class MediaSessionObserver;
 class MediaSessionStateObserver;
 class MediaSessionVisibilityBrowserTest;
 
 // MediaSession manages the media session and audio focus for a given
 // WebContents. It is requesting the audio focus, pausing when requested by the
 // system and dropping it on demand.
 // The audio focus can be of two types: Transient or Content. A Transient audio
 // focus will allow other players to duck instead of pausing and will be
 // declared as temporary to the system. A Content audio focus will not be
 // declared as temporary and will not allow other players to duck. If a given
@@ skipping 22 matching lines @@
     SUSPENDED,
     INACTIVE
   };
 
   // Returns the MediaSession associated to this WebContents. Creates one if
   // none is currently available.
   CONTENT_EXPORT static MediaSession* Get(WebContents* web_contents);
 
   ~MediaSession() override;
 
+  void AddObserver(MediaSessionObserver* observer);
+  void RemoveObserver(MediaSessionObserver* observer);
+  // Only passes ownership and does not observe.
+  void PassObserverOwnership(std::unique_ptr<MediaSessionObserver> owned_observer);

[whywhat, 2016/10/20 15:38:33]

this seems like an antipattern, along with the map below...

[Zhiqiang Zhang (Slow), 2016/10/20 16:22:32]

It's a problem that I've been struggling with. I discussed with Mounir and he's
fine to have MSO that are owned and not owned by MediaSession.

As you said in the other comment, maybe we could make MSO be owned by
WebContents, but actually it's the same as owned by MediaSession, since MS and
WC have the same lifetime. However there might be some other cases we don't want
it be owned by WC or MS, such as in tests, or the observer (CastMediaBlocker) in
chromecast/

+
   void SetMetadata(const base::Optional<MediaMetadata>& metadata);
   const base::Optional<MediaMetadata>& metadata() const { return metadata_; }
 
   // Adds the given player to the current media session. Returns whether the
   // player was successfully added. If it returns false, AddPlayer() should be
   // called again later.
   CONTENT_EXPORT bool AddPlayer(MediaSessionPlayerObserver* observer,
                                 int player_id,
                                 media::MediaContentType media_content_type);
 
@@ skipping 146 matching lines @@
   MediaSessionUmaHelper uma_helper_;
 
   // The ducking state of this media session. The initial value is |false|, and
   // is set to |true| after StartDucking(), and will be set to |false| after
   // StopDucking().
   bool is_ducking_;
 
   base::Optional<MediaMetadata> metadata_;
   base::CallbackList<void(State)> media_session_state_listeners_;
 
+  base::ObserverList<MediaSessionObserver> observers_;
+
+  using OwnedObserversType =
+  std::map<MediaSessionObserver*, std::unique_ptr<MediaSessionObserver>>;

[boliu, 2016/10/19 20:39:40]

would scoped_vector be better? is there going to be that many observers in
practice that a hashed data structure is needed?

[Zhiqiang Zhang (Slow), 2016/10/20 16:22:32]

The map is used when removing observers from the session. We don't expect many
observers, so I think using std::map is not very expensive.

[boliu, 2016/10/20 16:28:33]

Hmm? Usually the argument goes that vectors are slower for random access, but is
ok if N is tiny, where vector's memory efficiency wins out. I've never seen
anyone argue hash map is slow before :p

[Zhiqiang Zhang (Slow), 2016/10/20 17:07:03]

You are right, actually base::ObserverList uses std::vector<>.
Done.

+  OwnedObserversType owned_observers_;
+
   DISALLOW_COPY_AND_ASSIGN(MediaSession);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_MEDIA_SESSION_MEDIA_SESSION_H_