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

Source/modules/presentation/PresentationController.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 PresentationController_h
 #define PresentationController_h
 
 #include "core/frame/LocalFrameLifecycleObserver.h"
 #include "modules/ModulesExport.h"
 #include "modules/presentation/Presentation.h"
 #include "platform/Supplementable.h"
 #include "platform/heap/Handle.h"
 #include "public/platform/modules/presentation/WebPresentationClient.h"
 #include "public/platform/modules/presentation/WebPresentationController.h"
 
 namespace blink {
 
 class LocalFrame;
+class WebPresentationAvailabilityCallback;
 class WebPresentationSessionClient;
 enum class WebPresentationSessionState;
 
 // The coordinator between the various page exposed properties and the content
 // layer represented via |WebPresentationClient|.
 class MODULES_EXPORT PresentationController final
     : public NoBaseWillBeGarbageCollectedFinalized<PresentationController>
     , public WillBeHeapSupplement<LocalFrame>
     , public LocalFrameLifecycleObserver
     , public WebPresentationController {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(PresentationController);
     WTF_MAKE_NONCOPYABLE(PresentationController);
 public:
     virtual ~PresentationController();
 
     static PassOwnPtrWillBeRawPtr<PresentationController> create(LocalFrame&, WebPresentationClient*);
 
     static const char* supplementName();
     static PresentationController* from(LocalFrame&);
 
     static void provideTo(LocalFrame&, WebPresentationClient*);
 
+    WebPresentationClient* client();

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

I think this is inconsistent with the other methods and breaks the encapsulation
of the controller somewhat although makes the plumbing a bit easier.
To remain consistent there should be start/stopListening() methods in the
controller to pass the observer to the client.

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

The only reason why these controllers exist is to hold the FooClient that can't
be accessed from inside a module otherwise. I think these controllers should
limit themselves to this purpose: make sure m_client is never stall. This is
what the PermissionController is doing for example. It's a simple class with a
simple purpose. I think the boilerplate added by having the Controller being
used to make calls is unecessary.

In the long term, the Client should be available by other means than using a
Controller. I sent a Design Doc a while ago to blink-dev with an idea.
Unfortunately, I didn't found the time to go forward with the idea but I think
reducing Controller role is the way forward.

+
     // Implementation of HeapSupplement.
     DECLARE_VIRTUAL_TRACE();
 
     // Implementation of WebPresentationController.
     virtual void didChangeAvailability(bool available) override;
     virtual bool isAvailableChangeWatched() const override;
     virtual void didStartDefaultSession(WebPresentationSessionClient*) override;
     virtual void didChangeSessionState(WebPresentationSessionClient*, WebPresentationSessionState) override;
     virtual void didReceiveSessionTextMessage(WebPresentationSessionClient*, const WebString&) override;
 
-    // Called when the first listener was added to or the last listener was removed from the
-    // |availablechange| event.
-    void updateAvailableChangeWatched(bool watched);
-
     // Called when the frame wants to start a new presentation.
     void startSession(const String& presentationUrl, const String& presentationId, WebPresentationSessionClientCallbacks*);
 
     // Called when the frame wants to join an existing presentation.
     void joinSession(const String& presentationUrl, const String& presentationId, WebPresentationSessionClientCallbacks*);
 
     // Called when the frame wants to send String message to an existing presentation session.
     void send(const String& presentationUrl, const String& presentationId, const String& message);
 
     // Called when the frame wants to send ArrayBuffer/View data to an existing presentation session.
     void send(const String& presentationUrl, const String& presentationId, const uint8_t* data, size_t length);
 
     // Called when the frame want to send Blob data to an existing presentation session.
     void sendBlobData(const String& presentationUrl, const String& presentationId, const uint8_t* data, size_t length);
 
     // Called when the frame wants to close an existing presentation.
     void closeSession(const String& url, const String& presentationId);
 
+    // Called when the frame wants to know the availability of a device to present.
+    void getAvailability(const String& presentationUrl, WebPresentationAvailabilityCallbacks*);
+
     // Connects the |Presentation| object with this controller.
     void setPresentation(Presentation*);
 
 private:
     PresentationController(LocalFrame&, WebPresentationClient*);
 
     // Implementation of LocalFrameLifecycleObserver.
     virtual void willDetachFrameHost() override;
 
     WebPresentationClient* m_client;
     PersistentWillBeMember<Presentation> m_presentation;
 };
 
 } // namespace blink
 
 #endif // PresentationController_h