content/renderer/presentation/presentation_dispatcher.h

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_RENDERER_PRESENTATION_PRESENTATION_DISPATCHER_H_
   6 #define CONTENT_RENDERER_PRESENTATION_PRESENTATION_DISPATCHER_H_
   7
   8 #include "base/compiler_specific.h"
   9 #include "base/containers/scoped_ptr_map.h"
  10 #include "base/id_map.h"
  11 #include "base/memory/linked_ptr.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "content/common/content_export.h"
  14 #include "content/common/presentation/presentation_service.mojom.h"
  15 #include "content/public/renderer/render_frame_observer.h"
  16 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationClient.h"
  17
  18 namespace blink {
  19 class WebPresentationAvailabilityObserver;
  20 class WebString;
  21 }  // namespace blink
  22
  23 namespace content {
  24
  25 // PresentationDispatcher is a delegate for Presentation API messages used by
  26 // Blink. It forwards the calls to the Mojo PresentationService.
  27 class CONTENT_EXPORT PresentationDispatcher
  28     : public RenderFrameObserver,
  29       public NON_EXPORTED_BASE(blink::WebPresentationClient),
  30       public NON_EXPORTED_BASE(presentation::PresentationServiceClient) {
  31  public:
  32   explicit PresentationDispatcher(RenderFrame* render_frame);
  33   ~PresentationDispatcher() override;
  34
  35  private:
  36   struct SendMessageRequest {
  37     SendMessageRequest(presentation::PresentationSessionInfoPtr session_info,
  38                        presentation::SessionMessagePtr message);
  39     ~SendMessageRequest();
  40
  41     presentation::PresentationSessionInfoPtr session_info;
  42     presentation::SessionMessagePtr message;
  43   };
  44
  45   static SendMessageRequest* CreateSendTextMessageRequest(
  46       const blink::WebString& presentationUrl,
  47       const blink::WebString& presentationId,
  48       const blink::WebString& message);
  49   static SendMessageRequest* CreateSendBinaryMessageRequest(
  50       const blink::WebString& presentationUrl,
  51       const blink::WebString& presentationId,
  52       presentation::PresentationMessageType type,
  53       const uint8* data,
  54       size_t length);
  55
  56   // WebPresentationClient implementation.
  57   virtual void setController(
  58       blink::WebPresentationController* controller);
  59   virtual void startSession(
  60       const blink::WebString& presentationUrl,
  61       blink::WebPresentationSessionClientCallbacks* callback);
  62   virtual void joinSession(
  63       const blink::WebString& presentationUrl,
  64       const blink::WebString& presentationId,
  65       blink::WebPresentationSessionClientCallbacks* callback);
  66   virtual void sendString(
  67       const blink::WebString& presentationUrl,
  68       const blink::WebString& presentationId,
  69       const blink::WebString& message);
  70   virtual void sendArrayBuffer(
  71       const blink::WebString& presentationUrl,
  72       const blink::WebString& presentationId,
  73       const uint8* data,
  74       size_t length);
  75   virtual void sendBlobData(
  76       const blink::WebString& presentationUrl,
  77       const blink::WebString& presentationId,
  78       const uint8* data,
  79       size_t length);
  80   virtual void closeSession(
  81       const blink::WebString& presentationUrl,
  82       const blink::WebString& presentationId);
  83   virtual void getAvailability(
  84       const blink::WebString& availabilityUrl,
  85       blink::WebPresentationAvailabilityCallbacks* callbacks);
  86   virtual void startListening(blink::WebPresentationAvailabilityObserver*);
  87   virtual void stopListening(blink::WebPresentationAvailabilityObserver*);
  88   virtual void setDefaultPresentationUrl(const blink::WebString& url);
  89
  90   // RenderFrameObserver implementation.
  91   void DidCommitProvisionalLoad(
  92       bool is_new_navigation,
  93       bool is_same_page_navigation) override;
  94
  95   // presentation::PresentationServiceClient
  96   void OnScreenAvailabilityNotSupported(const mojo::String& url) override;
  97   void OnScreenAvailabilityUpdated(const mojo::String& url,
  98                                    bool available) override;
  99   void OnSessionStateChanged(
 100       presentation::PresentationSessionInfoPtr session_info,
 101       presentation::PresentationSessionState new_state) override;
 102   void OnSessionMessagesReceived(
 103       presentation::PresentationSessionInfoPtr session_info,
 104       mojo::Array<presentation::SessionMessagePtr> messages) override;
 105
 106   void OnSessionCreated(
 107       blink::WebPresentationSessionClientCallbacks* callback,
 108       presentation::PresentationSessionInfoPtr session_info,
 109       presentation::PresentationErrorPtr error);
 110   void OnDefaultSessionStarted(
 111       presentation::PresentationSessionInfoPtr session_info);
 112
 113   // Call to PresentationService to send the message in |request|.
 114   // |session_info| and |message| of |reuqest| will be consumed.
 115   // |HandleSendMessageRequests| will be invoked after the send is attempted.
 116   void DoSendMessage(SendMessageRequest* request);
 117   void HandleSendMessageRequests(bool success);
 118
 119   void ConnectToPresentationServiceIfNeeded();
 120
 121   void UpdateListeningState();
 122
 123   // Used as a weak reference. Can be null since lifetime is bound to the frame.
 124   blink::WebPresentationController* controller_;
 125   presentation::PresentationServicePtr presentation_service_;
 126   mojo::Binding<presentation::PresentationServiceClient> binding_;
 127
 128   // Message requests are queued here and only one message at a time is sent
 129   // over mojo channel.
 130   using MessageRequestQueue = std::queue<linked_ptr<SendMessageRequest>>;
 131   MessageRequestQueue message_request_queue_;
 132
 133   enum class ListeningState {
 134     INACTIVE,
 135     WAITING,
 136     ACTIVE,
 137   };
 138
 139   using AvailabilityCallbacksMap =
 140       IDMap<blink::WebPresentationAvailabilityCallbacks, IDMapOwnPointer>;
 141   using AvailabilityObserversSet =
 142       std::set<blink::WebPresentationAvailabilityObserver*>;
 143
 144   // Tracks status of presentation displays availability for |availability_url|.
 145   struct AvailabilityStatus {
 146     explicit AvailabilityStatus(const std::string& availability_url);
 147     ~AvailabilityStatus();
 148
 149     const std::string url;
 150     bool last_known_availability;
 151     ListeningState listening_state;
 152     AvailabilityCallbacksMap availability_callbacks;
 153     AvailabilityObserversSet availability_observers;
 154   };
 155
 156   using AvailabilityStatusMap =
 157     base::ScopedPtrMap<std::string, scoped_ptr<AvailabilityStatus>>;
 158   AvailabilityStatusMap availability_status_;
 159
 160   // Updates the listening state of availability for |status| and notifies the
 161   // client.
 162   void UpdateListeningState(AvailabilityStatus* status);
 163
 164   DISALLOW_COPY_AND_ASSIGN(PresentationDispatcher);
 165 };
 166
 167 }  // namespace content
 168
 169 #endif  // CONTENT_RENDERER_PRESENTATION_PRESENTATION_DISPATCHER_H_