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