Presentation API: implement .getAvalability() (Blink side).

Source/modules/presentation/Presentation.cpp

 // Copyright 2014 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 "config.h"
 #include "modules/presentation/Presentation.h"
 
+#include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/frame/LocalFrame.h"
 #include "modules/EventTargetModules.h"
-#include "modules/presentation/AvailableChangeEvent.h"
 #include "modules/presentation/DefaultSessionStartEvent.h"
 #include "modules/presentation/PresentationController.h"
 #include "modules/presentation/PresentationSessionClientCallbacks.h"
 #include "public/platform/modules/presentation/WebPresentationSessionClient.h"
 
 namespace blink {
 
 Presentation::Presentation(LocalFrame* frame)
     : DOMWindowProperty(frame)
 {
@@ skipping 61 matching lines @@
     PresentationController* controller = presentationController();
     if (!controller) {
         resolver->reject(DOMException::create(InvalidStateError, "The object is no longer attached to the frame."));
         return promise;
     }
     controller->joinSession(presentationUrl, presentationId, new PresentationSessionClientCallbacks(resolver, this));
 
     return promise;
 }
 
-bool Presentation::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
+ScriptPromise Presentation::getAvailability(ScriptState* state, const String& presentationUrl)
 {
-    bool hadEventListeners = hasEventListeners(EventTypeNames::availablechange);
-    if (!RefCountedGarbageCollectedEventTargetWithInlineData<Presentation>::addEventListener(eventType, listener, useCapture))
-        return false;
+    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(state);
+    ScriptPromise promise = resolver->promise();
 
-    if (hasEventListeners(EventTypeNames::availablechange) && !hadEventListeners) {
-        PresentationController* controller = presentationController();
-        if (controller)
-            controller->updateAvailableChangeWatched(true);
+    PresentationController* controller = presentationController();
+    if (!controller) {
+        resolver->reject(DOMException::create(InvalidStateError, "The object is no longer attached to the frame."));

[whywhat, 2015/07/02 22:32:37]

nit: If we have the same check in other methods, should we eliminate the
redundancy?

[mlamouri (slow - plz ping), 2015/07/03 13:58:26]

I will look into refactoring in a follow-up. This CL is already big enough as it
is.

+        return promise;
     }
+    controller->getAvailability(presentationUrl, new CallbackPromiseAdapter<bool, void>(resolver));

[whywhat, 2015/07/02 22:32:37]

so bool means this implements Promise<bool> rather than
Promise<PresentationAvailability>, no?
I guess that bool is then converted to PresentationAvailability via its ctor,
right?

[mlamouri (slow - plz ping), 2015/07/03 13:58:26]

Oouups. That was meant to be temporary :) Fixed. PTAL.

 
-    return true;
-}
-
-bool Presentation::removeEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
-{
-    bool hadEventListeners = hasEventListeners(EventTypeNames::availablechange);
-    if (!RefCountedGarbageCollectedEventTargetWithInlineData<Presentation>::removeEventListener(eventType, listener, useCapture))
-        return false;
-
-    if (hadEventListeners && !hasEventListeners(EventTypeNames::availablechange)) {
-        PresentationController* controller = presentationController();
-        if (controller)
-            controller->updateAvailableChangeWatched(false);
-    }
-
-    return true;
-}
-
-void Presentation::removeAllEventListeners()
-{
-    bool hadEventListeners = hasEventListeners(EventTypeNames::availablechange);
-    RefCountedGarbageCollectedEventTargetWithInlineData<Presentation>::removeAllEventListeners();
-
-    if (hadEventListeners) {
-        PresentationController* controller = presentationController();
-        if (controller)
-            controller->updateAvailableChangeWatched(false);
-    }
-}
-
-void Presentation::didChangeAvailability(bool available)
-{
-    dispatchEvent(AvailableChangeEvent::create(EventTypeNames::availablechange, available));
-}
-
-bool Presentation::isAvailableChangeWatched() const
-{
-    return hasEventListeners(EventTypeNames::availablechange);
+    return promise;
 }
 
 void Presentation::didStartDefaultSession(PresentationSession* session)
 {
     dispatchEvent(DefaultSessionStartEvent::create(EventTypeNames::defaultsessionstart, session));
 }
 
 void Presentation::didChangeSessionState(WebPresentationSessionClient* sessionClient, WebPresentationSessionState sessionState)
 {
     PresentationSession* session = findSession(sessionClient);
@@ skipping 27 matching lines @@
 PresentationSession* Presentation::findSession(WebPresentationSessionClient* sessionClient)
 {
     for (const auto& session : m_openSessions) {
         if (session->matches(sessionClient))
             return session.get();
     }
     return nullptr;
 }
 
 } // namespace blink