Adding mojo MediaSessionClient to support media controls

third_party/WebKit/Source/modules/mediasession/MediaSession.cpp

 // 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 "modules/mediasession/MediaSession.h"
 
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
+#include "core/events/Event.h"
 #include "core/frame/LocalFrame.h"
 #include "modules/EventTargetModules.h"
 #include "modules/mediasession/MediaMetadata.h"
 #include "modules/mediasession/MediaMetadataSanitizer.h"
 #include "public/platform/InterfaceProvider.h"
 #include <memory>
 
 namespace blink {
 
+namespace {
+
+using ::blink::mojom::blink::MediaSessionAction;
+
+const AtomicString& mojomActionToEventName(MediaSessionAction action) {
+  DEFINE_STATIC_LOCAL(AtomicString, emptyString, (""));
+
+  switch (action) {
+    case MediaSessionAction::PLAY:
+      return EventTypeNames::play;
+    case MediaSessionAction::PAUSE:
+      return EventTypeNames::pause;
+    case MediaSessionAction::PLAY_PAUSE:
+      return EventTypeNames::playpause;
+    case MediaSessionAction::PREVIOUS_TRACK:
+      return EventTypeNames::previoustrack;
+    case MediaSessionAction::NEXT_TRACK:
+      return EventTypeNames::nexttrack;
+    case MediaSessionAction::SEEK_FORWARD:
+      return EventTypeNames::seekforward;
+    case MediaSessionAction::SEEK_BACKWARD:
+      return EventTypeNames::seekbackward;
+    default:
+      NOTREACHED();
+  }
+  return emptyString;

[haraken, 2016/10/19 12:58:05]

Return WTF::emptyString() ?

[Zhiqiang Zhang (Slow), 2016/10/21 14:52:45]

Actually WTF::emptyAtom :)

+}
+
+MediaSessionAction eventNameToMojomAction(const AtomicString& eventName) {
+  if (EventTypeNames::play == eventName)
+    return MediaSessionAction::PLAY;
+  if (EventTypeNames::pause == eventName)
+    return MediaSessionAction::PAUSE;
+  if (EventTypeNames::playpause == eventName)
+    return MediaSessionAction::PLAY_PAUSE;
+  if (EventTypeNames::previoustrack == eventName)
+    return MediaSessionAction::PREVIOUS_TRACK;
+  if (EventTypeNames::nexttrack == eventName)
+    return MediaSessionAction::NEXT_TRACK;
+  if (EventTypeNames::seekforward == eventName)
+    return MediaSessionAction::SEEK_FORWARD;
+  if (EventTypeNames::seekbackward == eventName)
+    return MediaSessionAction::SEEK_BACKWARD;
+
+  NOTREACHED();
+  return MediaSessionAction::PLAY;

[whywhat, 2016/10/19 21:59:00]

I believe you need to return something different and check the return value
(maybe use Optional?).
One can add an event handler with any valid event name to any object AFAIK, we
don't want this to result in enabling Play.

[Zhiqiang Zhang (Slow), 2016/10/21 14:52:45]

Done.

+}
+
+}  // anonymous namespace
+
 MediaSession::MediaSession(ScriptState* scriptState)
-    : m_scriptState(scriptState) {}
+    : m_scriptState(scriptState), m_clientBinding(this) {}
 
 MediaSession* MediaSession::create(ScriptState* scriptState) {
   return new MediaSession(scriptState);
 }
 
+void MediaSession::dispose() {
+  m_clientBinding.Close();
+}
+
 void MediaSession::setMetadata(MediaMetadata* metadata) {
   if (mojom::blink::MediaSessionService* service =
           getService(m_scriptState.get())) {
     service->SetMetadata(
         MediaMetadataSanitizer::sanitizeAndConvertToMojo(metadata));
   }
 }
 
 MediaMetadata* MediaSession::metadata() const {
   return m_metadata;
 }
 
 const WTF::AtomicString& MediaSession::interfaceName() const {
   return EventTargetNames::MediaSession;
 }
 
 ExecutionContext* MediaSession::getExecutionContext() const {
   return m_scriptState->getExecutionContext();
 }
 
 mojom::blink::MediaSessionService* MediaSession::getService(
     ScriptState* scriptState) {
-  if (!m_service) {
-    InterfaceProvider* interfaceProvider = nullptr;
-    DCHECK(scriptState->getExecutionContext()->isDocument())
-        << "MediaSession::getService() is only available from a frame";
-    Document* document = toDocument(scriptState->getExecutionContext());
-    if (document->frame())
-      interfaceProvider = document->frame()->interfaceProvider();
+  if (m_service)
+    return m_service.get();
 
-    if (interfaceProvider)
-      interfaceProvider->getInterface(mojo::GetProxy(&m_service));
-  }
+  DCHECK(scriptState->getExecutionContext()->isDocument())
+      << "MediaSession::getService() is only available from a frame";
+  Document* document = toDocument(scriptState->getExecutionContext());
+  if (!document->frame())
+    return nullptr;
+
+  InterfaceProvider* interfaceProvider = document->frame()->interfaceProvider();
+  if (!interfaceProvider)
+    return nullptr;
+
+  interfaceProvider->getInterface(mojo::GetProxy(&m_service));
+  if (m_service.get())
+    m_service->SetClient(m_clientBinding.CreateInterfacePtrAndBind());
+
   return m_service.get();
 }
 
 bool MediaSession::addEventListenerInternal(
     const AtomicString& eventType,
     EventListener* listener,
     const AddEventListenerOptionsResolved& options) {
-  // TODO(zqzhang): Notify MediaSessionService the handler has been set. See
-  // https://crbug.com/656563
+  if (mojom::blink::MediaSessionService* service =
+          getService(m_scriptState.get())) {
+    service->EnableAction(eventNameToMojomAction(eventType));
+  }
   return EventTarget::addEventListenerInternal(eventType, listener, options);
 }
 
 bool MediaSession::removeEventListenerInternal(
     const AtomicString& eventType,
     const EventListener* listener,
     const EventListenerOptions& options) {
-  // TODO(zqzhang): Notify MediaSessionService the handler has been unset. See
-  // https://crbug.com/656563
+  if (mojom::blink::MediaSessionService* service =
+          getService(m_scriptState.get())) {
+    service->DisableAction(eventNameToMojomAction(eventType));
+  }
   return EventTarget::removeEventListenerInternal(eventType, listener, options);
 }
 
+void MediaSession::DidReceiveAction(
+    blink::mojom::blink::MediaSessionAction action) {
+  dispatchEvent(Event::create(mojomActionToEventName(action)));
+}
+
 DEFINE_TRACE(MediaSession) {
   visitor->trace(m_metadata);
   EventTargetWithInlineData::trace(visitor);
 }
 
 }  // namespace blink