Merge lp:~justinmcp/oxide/media-arbitration into lp:~oxide-developers/oxide/oxide.trunk

[Justin McPherson]

[Justin McPherson (justinmcp)]

The nature of this change makes it pretty intrusive. I've tried to cut it down, but we may need to chat about the details.

Originally I made a MediaArbitrator delegate class, but concerned about adding to much code in the patches, I pulled that and it mostly rests in RenderFrameImpl.

This is something that really belongs upstream.

Since support for the MH side of the arbitration is not available yet. At the time of this comment, this branch should not yet be merged.

[Chris Coulson (chrisccoulson)]

Hi,

So there's a couple of things I'm a bit concerned about with this:

- It's quite a big patch. It might be better to constrain the patch to just adding new content API's and then adding the actual additional IPC and other bits in Oxide instead. This is something I've been meaning to do with support-native-popup-menus.patch (I just want to shrink this down to a new method on ContentRendererClient which allows Oxide to create a blink::WebExternalPopupMenu and a small patch in RenderFrameImpl::createExternalPopupMenu to call it, rather than the gigantic patch to enable the Android + OSX bits).
- As it's implemented now, arbitration leaves blink in an inconsistent state. When blink calls play() on the blink::WebMediaPlayer implementation, it expects it to play. If it doesn't play, you need to ensure blink ends up in a consistent state (ie, not thinking that it's playing). I'm not sure how best to do that without even more intrusive changes. It looks like the Android player ends up in a paused state.

[lp:~justinmcp/oxide/media-arbitration]

1179. By Justin McPherson on 2015-10-28

Better handling of process level arbitration permission

1180. By Justin McPherson on 2016-04-06

Merge from trunk.

1181. By Justin McPherson on 2016-04-08

Finish merging to trunk.

Unmerged revisions

1181. By Justin McPherson on 2016-04-08

Finish merging to trunk.

1180. By Justin McPherson on 2016-04-06

Merge from trunk.

1179. By Justin McPherson on 2015-10-28

Better handling of process level arbitration permission

1178. By Justin McPherson on 2015-10-21

Merge from trunk.

1177. By Justin McPherson on 2015-10-20

Cleanup

1176. By Justin McPherson on 2015-10-16

WIP

1175. By Justin McPherson on 2015-10-15

Fixup whitespace changes

1174. By Justin McPherson on 2015-10-15

WIP

1173. By Justin McPherson on 2015-10-14

WIP

1172. By Justin McPherson on 2015-10-14

WIP

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-03-01 15:33:04 +0000
+++ CMakeLists.txt	2016-04-08 06:30:30 +0000
@@ -268,6 +268,11 @@
   list(APPEND _GYP_COMMAND -Dcomponent=shared_library)
 endif()
 list(APPEND _GYP_COMMAND -Doxide_gettext_domain=${GETTEXT_PACKAGE})
+if(DEFINED ENABLE_MEDIA_ARBITRATION AND ENABLE_MEDIA_ARBITRATION EQUAL 0)
+   list(APPEND _GYP_COMMAND -Denable_media_arbitration=0)
+else()
+   list(APPEND _GYP_COMMAND -Denable_media_arbitration=1)
+endif()
 CHECK_INCLUDE_FILE_CXX("core/media/player.h" HAVE_MEDIAHUB "--std=c++11")
 if(NOT HAVE_MEDIAHUB)
   list(APPEND _GYP_COMMAND -Denable_mediahub=0)

=== modified file 'shared/browser/media/mediahub_player_shim.cc'
--- shared/browser/media/mediahub_player_shim.cc	2015-09-09 07:18:04 +0000
+++ shared/browser/media/mediahub_player_shim.cc	2016-04-08 06:30:30 +0000
@@ -12,6 +12,8 @@
 typedef std::map<int, std::shared_ptr<Player> > player_map;
 
 player_map g_mediahub_players;
+std::shared_ptr<Player> g_proxy_player;
+
 
 player_map::iterator find_player(Player *player)
 {
@@ -42,6 +44,38 @@
 }
 }
 
+MediaHubClientHandle
+mediahub_create_proxy_player(MediaHubDelegate *delegate)
+{
+  try {
+    g_proxy_player =
+        Service::Client::instance()->create_proxy_session(
+            Player::Client::default_configuration());
+
+    if (delegate) {
+      setup_delegate(delegate, g_proxy_player);
+    }
+
+    return MediaHubClientHandle(static_cast<void*>(g_proxy_player.get()));
+  } catch (std::runtime_error& error) {
+    std::cerr << __PRETTY_FUNCTION__ << " " << error.what() << std::endl;
+  }
+  return MediaHubClientHandle();
+}
+
+void
+mediahub_release_proxy_player(MediaHubClientHandle handle)
+{
+  try {
+    auto player = static_cast<Player*>(handle);
+    if (g_proxy_player.get() == player) {
+      g_proxy_player.reset();
+    }
+  } catch (std::runtime_error& error) {
+    std::cerr << __PRETTY_FUNCTION__ << " " << error.what() << std::endl;
+  }
+}
+
 
 MediaHubClientHandle
 mediahub_create_player(int player_id, MediaHubDelegate *delegate)
@@ -292,6 +326,20 @@
   }
 }
 
+bool
+mediahub_can_play(MediaHubClientHandle handle)
+{
+  try {
+    Player* player = static_cast<Player*>(handle);
+    if (player) {
+      return player->can_play();
+    }
+  } catch (std::runtime_error& error) {
+    std::cerr << __PRETTY_FUNCTION__ << " " << error.what() << std::endl;
+  }
+  return false;
+}
+
 int
 mediahub_can_pause(MediaHubClientHandle handle)
 {

=== modified file 'shared/browser/media/mediahub_player_shim.h'
--- shared/browser/media/mediahub_player_shim.h	2015-09-09 07:18:04 +0000
+++ shared/browser/media/mediahub_player_shim.h	2016-04-08 06:30:30 +0000
@@ -25,6 +25,12 @@
 
 enum Lifetime { normal, resumable };
 
+MediaHubClientHandle
+mediahub_create_proxy_player(MediaHubDelegate* delegate = 0);
+
+void
+mediahub_release_proxy_player(MediaHubClientHandle handle);
+
 /**
  * Creates a media hub player instance
  */
@@ -111,6 +117,9 @@
 void
 mediahub_seek_to(MediaHubClientHandle handle, int64_t offset);
 
+bool
+mediahub_can_play(MediaHubClientHandle handle);
+
 /**
  * 
  */

=== added file 'shared/browser/media/oxide_browser_media_arbitrator.cc'
--- shared/browser/media/oxide_browser_media_arbitrator.cc	1970-01-01 00:00:00 +0000
+++ shared/browser/media/oxide_browser_media_arbitrator.cc	2016-04-08 06:30:30 +0000
@@ -0,0 +1,204 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2013-2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#include <set>
+
+#include "shared/browser/media/oxide_media_web_contents_observer.h"
+
+#include "shared/common/oxide_messages.h"
+#include "content/common/media/media_player_delegate_messages.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "base/stl_util.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/web_contents.h"
+#include "shared/browser/media/oxide_browser_media_arbitrator.h"
+
+
+namespace oxide {
+
+BrowserMediaArbitrator::BrowserMediaArbitrator(
+    content::WebContents* contents)
+    : content::WebContentsObserver(contents)
+{
+}
+
+BrowserMediaArbitrator::~BrowserMediaArbitrator()
+{
+}
+
+bool BrowserMediaArbitrator::OnMessageReceived(
+    const IPC::Message& msg,
+    content::RenderFrameHost* render_frame_host
+) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(BrowserMediaArbitrator, msg, render_frame_host)
+    IPC_MESSAGE_HANDLER(OxideHostMsg_MediaShouldPlay, OnMediaShouldPlay)
+    IPC_MESSAGE_HANDLER(OxideHostMsg_MediaPlayerPlaying, OnMediaPlayerPlaying)
+    IPC_MESSAGE_HANDLER(OxideHostMsg_MediaPlayerPaused, OnMediaPlayerPaused)
+    IPC_MESSAGE_HANDLER(OxideHostMsg_MediaPlayerGone, OnMediaPlayerGone)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void BrowserMediaArbitrator::WebContentsDestroyed() {
+  delete this;
+}
+
+void BrowserMediaArbitrator::OnMediaShouldPlay(
+    content::RenderFrameHost* render_frame_host,
+    int player_cookie
+) {
+  AddPlayer(player_cookie, render_frame_host);
+
+#if defined(ENABLE_MEDIAHUB)
+    if (mediahub_can_play(mediahub_client_handle_)) {
+      Send(new OxideMsg_MediaCanPlay(
+          render_frame_host->GetRoutingID(), player_cookie, true));
+      Send(new MediaPlayerDelegateMsg_Play(render_frame_host->GetRoutingID(), player_cookie));
+    } else {
+      Send(new OxideMsg_MediaCanPlay(
+          render_frame_host->GetRoutingID(), player_cookie, false));
+    }
+#else
+  Send(new OxideMsg_MediaCanPlay(
+      render_frame_host->GetRoutingID(), player_cookie, true));
+  Send(new MediaPlayerDelegateMsg_Play(render_frame_host->GetRoutingID(), player_cookie));
+#endif
+}
+
+void BrowserMediaArbitrator::OnMediaPlayerPlaying(
+    content::RenderFrameHost* render_frame_host,
+    int player_cookie
+) {
+  if (players_[player_cookie].playing) {
+    return;
+  }
+#if defined(ENABLE_MEDIAHUB)
+   if (players_.size() == 1) {
+     mediahub_play(mediahub_client_handle_);
+   } else {
+     int playing_count =
+        std::accumulate(players_.begin(), players_.end(), 0,
+            [](const int acc, const player_map::value_type& val) {
+              return acc + (val.second.playing ? 1 : 0);
+            });
+    if (playing_count == 0) {
+      mediahub_play(mediahub_client_handle_);
+    }
+  }
+#endif
+  players_[player_cookie].playing = true;
+}
+
+void BrowserMediaArbitrator::OnMediaPlayerPaused(
+    content::RenderFrameHost* render_frame_host,
+    int player_cookie
+) {
+  if (!players_[player_cookie].playing) {
+    return;
+  }
+  players_[player_cookie].playing = false;
+
+#if defined(ENABLE_MEDIAHUB)
+  int playing_count =
+    std::accumulate(players_.begin(), players_.end(), 0,
+        [](const int acc, const player_map::value_type& val) {
+          return acc + (val.second.playing ? 1 : 0);
+        });
+  if (playing_count == 0) {
+    mediahub_pause(mediahub_client_handle_);
+  }
+#endif
+}
+
+void BrowserMediaArbitrator::OnMediaPlayerGone(
+    content::RenderFrameHost* render_frame_host,
+    int player_cookie
+) {
+  RemovePlayer(player_cookie);
+}
+
+void BrowserMediaArbitrator::AddPlayer(
+    int player_cookie,
+    content::RenderFrameHost* render_frame_host
+) {
+  players_.insert(std::make_pair(player_cookie, player_info{false, render_frame_host}));
+#if defined(ENABLE_MEDIAHUB)
+  if (players_.size() == 1) {
+    mediahub_client_handle_ = mediahub_create_proxy_player(this);
+  }
+#endif
+}
+
+void BrowserMediaArbitrator::RemovePlayer(int player_cookie) {
+  players_.erase(player_cookie);
+#if defined(ENABLE_MEDIAHUB)
+  if (players_.empty()) {
+    mediahub_release_proxy_player(mediahub_client_handle_);
+  }
+#endif
+}
+
+#if defined(ENABLE_MEDIAHUB)
+void BrowserMediaArbitrator::seeked_to(int64_t /*pos*/)
+{
+}
+
+void BrowserMediaArbitrator::end_of_stream()
+{
+}
+
+void BrowserMediaArbitrator::playback_status_changed(MediaHubDelegate::Status status)
+{
+  std::set<content::RenderFrameHost*> render_frame_hosts;
+  for (auto& info : players_) {
+    render_frame_hosts.insert(info.second.host);
+  }
+
+  switch (status) {
+  case null:
+  case ready:
+    break;
+  case playing:
+    for (auto& host : render_frame_hosts) {
+      Send(new OxideMsg_MediaResumeAll(host->GetRoutingID()));
+    }
+
+    for (auto& it : players_) {
+      info.second.playing = true;
+      Send(new MediaPlayerDelegateMsg_Play(it.second.host->GetRoutingID(), it.first));
+    }
+    break;
+  case paused:
+    for (auto& host : render_frame_hosts) {
+      Send(new OxideMsg_MediaPauseAll(host->GetRoutingID()));
+    }
+
+    for (auto& it : players_) {
+      info.second.playing = false;
+      Send(new MediaPlayerDelegateMsg_Pause(it.second.host->GetRoutingID(), it.first));
+    }
+    break;
+  case stopped:
+    break;
+  }
+}
+#endif
+
+}  // namespace content

=== added file 'shared/browser/media/oxide_browser_media_arbitrator.h'
--- shared/browser/media/oxide_browser_media_arbitrator.h	1970-01-01 00:00:00 +0000
+++ shared/browser/media/oxide_browser_media_arbitrator.h	2016-04-08 06:30:30 +0000
@@ -0,0 +1,89 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2013-2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef _OXIDE_BROWSER_MEDIA_ARBITRATOR_H_
+#define _OXIDE_BROWSER_MEDIA_ARBITRATOR_H_
+
+#include <map>
+
+#include "base/compiler_specific.h"
+#include "base/containers/scoped_ptr_hash_map.h"
+#include "content/common/content_export.h"
+#include "content/public/browser/web_contents_observer.h"
+#if defined(ENABLE_MEDIAHUB)
+#include "shared/browser/media/mediahub_player_shim.h"
+#endif
+
+namespace content {
+class WebContents;
+class RenderFrameHost;
+}
+
+namespace oxide {
+
+class BrowserMediaArbitrator :
+    public content::WebContentsObserver
+#if defined(ENABLE_MEDIAHUB)
+    , public MediaHubDelegate
+#endif
+{
+ public:
+  explicit BrowserMediaArbitrator(content::WebContents* contents);
+  ~BrowserMediaArbitrator();
+
+  bool OnMessageReceived(const IPC::Message& message,
+                         content::RenderFrameHost* render_frame_host) override;
+
+  void WebContentsDestroyed() override;
+
+ private:
+  void OnMediaShouldPlay(content::RenderFrameHost* render_frame_host,
+                         int player_cookie);
+  void OnMediaPlayerPlaying(
+      content::RenderFrameHost* render_frame_host,
+      int player_cookie
+  );
+  void OnMediaPlayerPaused(content::RenderFrameHost* render_frame_host,
+                                 int player_cookie);
+  void OnMediaPlayerGone(content::RenderFrameHost* render_frame_host,
+                         int player_cookie);
+
+#if defined(ENABLE_MEDIAHUB)
+  void seeked_to(int64_t pos);
+  void end_of_stream();
+  void playback_status_changed(MediaHubDelegate::Status status);
+  MediaHubClientHandle mediahub_client_handle_;
+#endif
+
+  void AddPlayer(int player_cookie,
+                 content::RenderFrameHost* render_frame_host);
+  void RemovePlayer(int player_cookie);
+
+  struct player_info {
+    bool playing;
+    content::RenderFrameHost* host;
+  };
+
+  typedef std::map<int, player_info> player_map;
+  player_map players_;
+
+  DISALLOW_COPY_AND_ASSIGN(BrowserMediaArbitrator);
+};
+
+}  // namespace oxide
+
+#endif  // _OXIDE_MEDIA_WEB_CONTENTS_OBSERVER_H_

=== modified file 'shared/browser/media/oxide_media_web_contents_observer.cc'
--- shared/browser/media/oxide_media_web_contents_observer.cc	2015-09-09 07:18:04 +0000
+++ shared/browser/media/oxide_media_web_contents_observer.cc	2016-04-08 06:30:30 +0000
@@ -54,13 +54,13 @@
     IPC_MESSAGE_FORWARD(OxideHostMsg_MediaPlayer_DestroyMediaPlayer,
                         GetMediaPlayerManager(render_frame_host),
                         BrowserMediaPlayerManager::OnDestroyPlayer)
-      IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void MediaWebContentsObserver::WebContentsDestroyed() {
-  delete this;  
+  delete this;
 }
 
 BrowserMediaPlayerManager* MediaWebContentsObserver::GetMediaPlayerManager(

=== modified file 'shared/browser/oxide_browser_process_main.cc'
--- shared/browser/oxide_browser_process_main.cc	2016-04-02 10:08:16 +0000
+++ shared/browser/oxide_browser_process_main.cc	2016-04-08 06:30:30 +0000
@@ -311,6 +311,10 @@
     command_line->AppendSwitch(switches::kAllowSandboxDebugging);
   }
 
+  if (IsEnvironmentOptionEnabled("ENABLE_MEDIA_ARBITRATION")) {
+    command_line->AppendSwitch(switches::kEnableMediaArbitration);
+  }
+
   if (IsEnvironmentOptionEnabled("ENABLE_MEDIA_HUB_AUDIO")) {
     command_line->AppendSwitch(switches::kEnableMediaHubAudio);
   }

=== modified file 'shared/browser/oxide_content_browser_client.cc'
--- shared/browser/oxide_content_browser_client.cc	2016-02-01 20:17:09 +0000
+++ shared/browser/oxide_content_browser_client.cc	2016-04-08 06:30:30 +0000
@@ -125,7 +125,8 @@
   static const char* const kSwitchNames[] = {
     switches::kEnableMediaHubAudio,
     switches::kFormFactor,
-    switches::kMediaHubFixedSessionDomains
+    switches::kMediaHubFixedSessionDomains,
+    switches::kEnableMediaArbitration,
   };
   command_line->CopySwitchesFrom(*base::CommandLine::ForCurrentProcess(),
                                  kSwitchNames, arraysize(kSwitchNames));

=== modified file 'shared/browser/oxide_web_view.cc'
--- shared/browser/oxide_web_view.cc	2016-03-21 15:33:21 +0000
+++ shared/browser/oxide_web_view.cc	2016-04-08 06:30:30 +0000
@@ -95,6 +95,10 @@
 #include "shared/browser/media/oxide_media_web_contents_observer.h"
 #endif
 
+#if defined(ENABLE_MEDIA_ARBITRATION)
+#include "shared/browser/media/oxide_browser_media_arbitrator.h"
+#endif
+
 #define DCHECK_VALID_SOURCE_CONTENTS DCHECK_EQ(source, web_contents());
 
 namespace oxide {
@@ -129,6 +133,9 @@
   CertificateErrorDispatcher::CreateForWebContents(contents);
   PermissionRequestDispatcher::CreateForWebContents(contents);
   ScriptMessageContentsHelper::CreateForWebContents(contents);
+#if defined(ENABLE_MEDIA_ARBITRATION)
+  new BrowserMediaArbitrator(contents);
+#endif
 #if defined(ENABLE_MEDIAHUB)
   new MediaWebContentsObserver(contents);
 #endif

=== modified file 'shared/common/oxide_constants.cc'
--- shared/common/oxide_constants.cc	2015-11-07 23:49:10 +0000
+++ shared/common/oxide_constants.cc	2016-04-08 06:30:30 +0000
@@ -25,6 +25,7 @@
 const char kFormFactorPhone[] = "phone";
 const char kIncognito[] = "incognito";
 const char kEnableMediaHubAudio[] = "enable-media-hub-audio";
+const char kEnableMediaArbitration[] = "enable-media-arbitraion";
 const char kMediaHubFixedSessionDomains[] = "media-hub-fixed-session-domains";
 
 } // namespace switches

=== modified file 'shared/common/oxide_constants.h'
--- shared/common/oxide_constants.h	2015-11-07 23:49:10 +0000
+++ shared/common/oxide_constants.h	2016-04-08 06:30:30 +0000
@@ -25,6 +25,7 @@
 extern const char kFormFactorTablet[];
 extern const char kFormFactorPhone[];
 extern const char kIncognito[];
+extern const char kEnableMediaArbitration[];
 extern const char kEnableMediaHubAudio[];
 extern const char kMediaHubFixedSessionDomains[];
 

=== modified file 'shared/common/oxide_messages.h'
--- shared/common/oxide_messages.h	2015-09-09 07:18:04 +0000
+++ shared/common/oxide_messages.h	2016-04-08 06:30:30 +0000
@@ -205,3 +205,32 @@
 IPC_MESSAGE_CONTROL2(OxideHostMsg_MediaPlayer_DurationChanged,
                      int /* demuxer_client_id */,
                      base::TimeDelta /* duration */)
+
+// Messages for Media Arbitration
+#if defined(ENABLE_MEDIA_ARBITRATION)
+// Request the browser to arbitrate whether the media should play
+IPC_MESSAGE_ROUTED1(OxideHostMsg_MediaShouldPlay,
+                    int /* internal id */)
+
+IPC_MESSAGE_ROUTED1(OxideHostMsg_MediaPlayerPlaying,
+                    int /* internal id */)
+
+IPC_MESSAGE_ROUTED1(OxideHostMsg_MediaPlayerPaused,
+                    int /* internal id */)
+
+// Tell browser player is no longer active
+IPC_MESSAGE_ROUTED1(OxideHostMsg_MediaPlayerGone,
+                    int /* internal id */)
+
+
+// Indicate whether media can play
+IPC_MESSAGE_ROUTED2(OxideMsg_MediaCanPlay,
+                    int, /* internal id */
+                    bool /* can player play*/)
+
+// Pause all playing media players
+IPC_MESSAGE_ROUTED0(OxideMsg_MediaPauseAll)
+
+// Reume media players (if previously playing)
+IPC_MESSAGE_ROUTED0(OxideMsg_MediaResumeAll)
+#endif

=== added file 'shared/renderer/media/oxide_renderer_media_arbitrator.cc'
--- shared/renderer/media/oxide_renderer_media_arbitrator.cc	1970-01-01 00:00:00 +0000
+++ shared/renderer/media/oxide_renderer_media_arbitrator.cc	2016-04-08 06:30:30 +0000
@@ -0,0 +1,148 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2013-2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#include "oxide_renderer_media_arbitrator.h"
+
+#include "base/command_line.h"
+#include "shared/common/oxide_constants.h"
+#include "shared/common/oxide_messages.h"
+#include "third_party/WebKit/public/platform/WebMediaPlayer.h"
+
+
+namespace oxide {
+
+RendererMediaArbitrator::RendererMediaArbitrator(
+    content::RenderFrame* render_frame)
+    : RenderFrameObserver(render_frame)
+    , RenderFrameObserverTracker<RendererMediaArbitrator>(render_frame)
+{
+  const base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess();
+  arbitration_enabled_ = command_line.HasSwitch(switches::kEnableMediaArbitration);
+}
+
+RendererMediaArbitrator::~RendererMediaArbitrator() {
+}
+
+bool RendererMediaArbitrator::CanDelegatePlay(int delegate_id)
+{
+  if (!arbitration_enabled_) {
+    return true;
+  }
+
+#if defined(ENABLE_MEDIAHUB)
+  const base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess();
+  // Each media-hub player session is already managed.
+  if (command_line.HasSwitch(switches::kEnableMediaHubAudio)) {
+    return true;
+  }
+#endif
+
+  auto it = registered_delegates_.find(delegate_id);
+  if (it != registered_delegates_.end() && it->second.authorised) {
+    return true;
+  }
+
+  registered_delegates_.insert(std::make_pair(delegate_id, {false, false}));
+  Send(new OxideHostMsg_MediaShouldPlay( routing_id(), delegate_id);
+
+  return false;
+}
+
+bool RendererMediaArbitrator::DelegateWillPlay(int delegate_id)
+{
+  auto it = registered_delegates_.find(delegate_id);
+  if (it != registered_delegates_.end() && it->second.authorised) {
+    return true;
+  }
+  return false;
+}
+
+void RendererMediaArbitrator::DelegateWillPause(int delegate_id)
+{
+}
+
+void RendererMediaArbitrator::DelegateDidPlay(int delegate_id)
+{
+  if (!arbitration_enabled_) {
+    return;
+  }
+  auto it = registered_delegates_.find(delegate_id);
+  if (it != registered_delegates_.end()) {
+    it->second.playing = true;
+    Send(new OxideHostMsg_MediaPlayerPlaying(routing_id(), delegate_id));
+  }
+}
+
+void RendererMediaArbitrator::DelegateDidPause(int delegate_id)
+{
+  if (!arbitration_enabled_) {
+    return;
+  }
+  auto it = registered_delegates_.find(delegate_id);
+  if (it != registered_delegates_.end() && it->second.authorised) {
+    it->second.playing = false;
+    Send(new OxideHostMsg_MediaPlayerPaused(routing_id(), delegate_id));
+  }
+}
+
+void RendererMediaArbitrator::DelegateDidGo(int delegate_id)
+{
+  if (!arbitration_enabled_) {
+    return;
+  }
+  registered_delegates_.erase(delegate_id));
+  Send(new OxideHostMsg_MediaPlayerGone( routing_id(), delegate_id));
+}
+
+bool RendererMediaArbitrator::OnMessageReceived(const IPC::Message& msg) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(RendererMediaArbitrator, msg)
+    IPC_MESSAGE_HANDLER(OxideMsg_MediaCanPlay, OnMediaCanPlay)
+    IPC_MESSAGE_HANDLER(OxideMsg_MediaPauseAll, OnMediaPauseAll)
+    IPC_MESSAGE_HANDLER(OxideMsg_MediaResumeAll, OnMediaResumeAll)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void RendererMediaArbitrator::OnMediaCanPlay(int delegate_id, bool can_play)
+{
+  auto it = registered_delegates_.find(player_cookie);
+  if (it != registered_delegates_.end()) {
+    return; 
+  }
+  it->second.authorised = can_play;
+}
+
+void RendererMediaArbitrator::OnMediaPauseAll()
+{
+  for (auto& it : registered_delegates_) {
+    it.second.authorised = false;
+  }
+}
+
+void RendererMediaArbitrator::OnMediaResumeAll()
+{
+  for (auto& it : registered_delegates_) {
+    if (it.second.playing && !it.second.authorised) {
+      info.second.authorised = true;
+    }
+  }
+}
+
+
+} // ns oxide

=== added file 'shared/renderer/media/oxide_renderer_media_arbitrator.h'
--- shared/renderer/media/oxide_renderer_media_arbitrator.h	1970-01-01 00:00:00 +0000
+++ shared/renderer/media/oxide_renderer_media_arbitrator.h	2016-04-08 06:30:30 +0000
@@ -0,0 +1,61 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2013-2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef _OXIDE_RENDERER_MEDIA_ARBITRATOR_H_
+#define _OXIDE_RENDERER_MEDIA_ARBITRATOR_H_
+
+#include "content/public/renderer/content_media_arbitrator.h"
+#include "content/public/renderer/render_frame_observer.h"
+#include "content/public/renderer/render_frame_observer_tracker.h"
+
+namespace oxide {
+
+class RendererMediaArbitrator :
+  public content::MediaArbitrator,
+  public content::RenderFrameObserver,
+  public content::RenderFrameObserverTracker<RendererMediaArbitrator> {
+ public:
+  explicit RendererMediaArbitrator(content::RenderFrame* render_frame);
+  ~RendererMediaArbitrator();
+
+  bool CanDelegatePlay(int delegate_id);
+  bool DelegateWillPlay(int delegate_id);
+  void DelegateWillPause(int delegate_id);
+  void DelegateDidPlay(int delegate_id);
+  void DelegateDidPause(int delegate_id);
+  void DelegateDidGo(int delegate_id);
+
+  bool OnMessageReceived(const IPC::Message& msg) override;
+
+ private:
+  void OnMediaCanPlay(int64_t player_cookie, bool can_play);
+  void OnMediaPauseAll();
+  void OnMediaResumeAll();
+
+  bool arbitration_enabled_;
+
+  struct delegate_info {
+    bool authorised;
+    bool playing;
+  };
+
+  std::map<int, delegate_info> registered_delegates_;
+};
+
+} // ns oxide
+
+#endif // _OXIDE_RENDERER_MEDIA_ARBITRATOR_H_

=== modified file 'shared/renderer/media/oxide_renderer_media_player_manager.cc'
--- shared/renderer/media/oxide_renderer_media_player_manager.cc	2015-09-09 07:18:04 +0000
+++ shared/renderer/media/oxide_renderer_media_player_manager.cc	2016-04-08 06:30:30 +0000
@@ -49,7 +49,7 @@
     IPC_MESSAGE_HANDLER(OxideMsg_MediaPlayer_DidMediaPlayerPlay, OnPlayerPlay)
     IPC_MESSAGE_HANDLER(OxideMsg_MediaPlayer_DidMediaPlayerPause, OnPlayerPause)
     IPC_MESSAGE_HANDLER(OxideMsg_MediaPlayer_PauseVideo, OnPauseVideo)
-  IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }

=== modified file 'shared/renderer/oxide_content_renderer_client.cc'
--- shared/renderer/oxide_content_renderer_client.cc	2016-03-30 18:33:11 +0000
+++ shared/renderer/oxide_content_renderer_client.cc	2016-04-08 06:30:30 +0000
@@ -55,6 +55,11 @@
 #include "media/oxide_web_media_player.h"
 #endif
 
+#if defined(ENABLE_MEDIA_ARBITRATION)
+#include "media/oxide_renderer_media_arbitrator.h"
+#endif
+
+
 namespace oxide {
 
 void ContentRendererClient::RenderThreadStarted() {
@@ -87,6 +92,9 @@
 #if defined(ENABLE_MEDIAHUB)
   new RendererMediaPlayerManager(render_frame);
 #endif
+#if defined(ENABLE_MEDIA_ARBITRATION)
+  new RendererMediaArbitrator(render_frame);
+#endif
 }
 
 void ContentRendererClient::RenderViewCreated(
@@ -157,6 +165,18 @@
 }
 #endif
 
+#if defined(ENABLE_MEDIA_ARBITRATION)
+content::MediaArbitrator* ContentRendererClient::GetMediaArbitrator(
+    blink::WebFrame *frame
+) {
+  RendererMediaArbitrator* ma = RendererMediaArbitrator::Get(
+                                    content::RenderFrame::FromWebFrame(frame));
+  DCHECK(ma);
+
+  return ma;
+}
+#endif
+
 void ContentRendererClient::OverrideCompositorSettings(
     cc::LayerTreeSettings* settings) {
   // XXX: If we support overlay scrollbars on desktop, then we'll want to

=== modified file 'shared/renderer/oxide_content_renderer_client.h'
--- shared/renderer/oxide_content_renderer_client.h	2016-03-30 18:33:11 +0000
+++ shared/renderer/oxide_content_renderer_client.h	2016-04-08 06:30:30 +0000
@@ -53,6 +53,9 @@
       base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
       media::MediaLog* media_log) override;
 #endif
+#if defined(ENABLE_MEDIA_ARBITRATION)
+  content::MediaArbitrator* GetMediaArbitrator(blink::WebFrame* frame) final;
+#endif
   void OverrideCompositorSettings(cc::LayerTreeSettings* settings) override;
   std::string GetUserAgentOverrideForURL(const GURL& url) override;
 

=== modified file 'shared/shared.gyp'
--- shared/shared.gyp	2016-04-04 17:56:47 +0000
+++ shared/shared.gyp	2016-04-08 06:30:30 +0000
@@ -608,6 +608,17 @@
             '<(DEPTH)/ppapi/ppapi_internal.gyp:ppapi_shared',
           ],
         }],
+        ['enable_media_arbitration==1', {
+          'defines': [
+            'ENABLE_MEDIA_ARBITRATION=1'
+          ],
+          'sources': [
+            'browser/media/oxide_browser_media_arbitrator.cc',
+            'browser/media/oxide_browser_media_arbitrator.h',
+            'renderer/media/oxide_renderer_media_arbitrator.cc',
+            'renderer/media/oxide_renderer_media_arbitrator.h',
+          ]
+        }],
         ['enable_mediahub==1', {
           'defines': [
             'ENABLE_MEDIAHUB=1'