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/id_map.h"
  10 #include "base/memory/linked_ptr.h"
  11 #include "content/common/content_export.h"
  12 #include "content/common/presentation/presentation_service.mojom.h"
  13 #include "content/public/renderer/render_frame_observer.h"
  14 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationClient.h"
  15
  16 namespace blink {
  17 class WebPresentationAvailabilityObserver;
  18 class WebString;
  19 }  // namespace blink
  20
  21 namespace content {
  22
  23 // PresentationDispatcher is a delegate for Presentation API messages used by
  24 // Blink. It forwards the calls to the Mojo PresentationService.
  25 class CONTENT_EXPORT PresentationDispatcher
  26     : public RenderFrameObserver,
  27       public NON_EXPORTED_BASE(blink::WebPresentationClient),
  28       public NON_EXPORTED_BASE(presentation::PresentationServiceClient) {
  29  public:
  30   explicit PresentationDispatcher(RenderFrame* render_frame);
  31   ~PresentationDispatcher() override;
  32
  33  private:
  34   // WebPresentationClient implementation.
  35   virtual void setController(
  36       blink::WebPresentationController* controller);
  37   virtual void updateAvailableChangeWatched(bool watched);
  38   virtual void startSession(
  39       const blink::WebString& presentationUrl,
  40       blink::WebPresentationSessionClientCallbacks* callback);
  41   virtual void joinSession(
  42       const blink::WebString& presentationUrl,
  43       const blink::WebString& presentationId,
  44       blink::WebPresentationSessionClientCallbacks* callback);
  45   virtual void sendString(
  46       const blink::WebString& presentationUrl,
  47       const blink::WebString& presentationId,
  48       const blink::WebString& message);
  49   virtual void sendArrayBuffer(
  50       const blink::WebString& presentationUrl,
  51       const blink::WebString& presentationId,
  52       const uint8* data,
  53       size_t length);
  54   virtual void sendBlobData(
  55       const blink::WebString& presentationUrl,
  56       const blink::WebString& presentationId,
  57       const uint8* data,
  58       size_t length);
  59   virtual void closeSession(
  60       const blink::WebString& presentationUrl,
  61       const blink::WebString& presentationId);
  62   virtual void getAvailability(
  63       const blink::WebString& presentationUrl,
  64       blink::WebPresentationAvailabilityCallbacks* callbacks);
  65   virtual void startListening(blink::WebPresentationAvailabilityObserver*);
  66   virtual void stopListening(blink::WebPresentationAvailabilityObserver*);
  67   virtual void setDefaultPresentationUrl(const blink::WebString& url);
  68
  69   // RenderFrameObserver implementation.
  70   void DidCommitProvisionalLoad(
  71       bool is_new_navigation,
  72       bool is_same_page_navigation) override;
  73
  74   // presentation::PresentationServiceClient
  75   void OnScreenAvailabilityUpdated(bool available) override;
  76   void OnSessionStateChanged(
  77       presentation::PresentationSessionInfoPtr session_info,
  78       presentation::PresentationSessionState new_state) override;
  79   void OnScreenAvailabilityNotSupported() override;
  80
  81   void OnSessionCreated(
  82       blink::WebPresentationSessionClientCallbacks* callback,
  83       presentation::PresentationSessionInfoPtr session_info,
  84       presentation::PresentationErrorPtr error);
  85   void OnDefaultSessionStarted(
  86       presentation::PresentationSessionInfoPtr session_info);
  87   void OnSessionMessagesReceived(
  88       mojo::Array<presentation::SessionMessagePtr> messages);
  89   void DoSendMessage(const presentation::SessionMessage& session_message);
  90   void HandleSendMessageRequests(bool success);
  91
  92   void ConnectToPresentationServiceIfNeeded();
  93
  94   void UpdateListeningState();
  95
  96   void StartListenForMessages();
  97
  98   // Used as a weak reference. Can be null since lifetime is bound to the frame.
  99   blink::WebPresentationController* controller_;
 100   presentation::PresentationServicePtr presentation_service_;
 101   mojo::Binding<presentation::PresentationServiceClient> binding_;
 102
 103   // Message requests are queued here and only one message at a time is sent
 104   // over mojo channel.
 105   using MessageRequestQueue =
 106       std::queue<linked_ptr<presentation::SessionMessage>>;
 107   MessageRequestQueue message_request_queue_;
 108
 109   enum class ListeningState {
 110     Inactive,
 111     Waiting,
 112     Active,
 113   };
 114
 115   ListeningState listening_state_;
 116   bool last_known_availability_;
 117
 118   using AvailabilityCallbacksMap =
 119       IDMap<blink::WebPresentationAvailabilityCallbacks, IDMapOwnPointer>;
 120   AvailabilityCallbacksMap availability_callbacks_;
 121
 122   using AvailabilityObserversSet =
 123       std::set<blink::WebPresentationAvailabilityObserver*>;
 124   AvailabilityObserversSet availability_observers_;
 125
 126   bool listening_for_messages_;
 127
 128   DISALLOW_COPY_AND_ASSIGN(PresentationDispatcher);
 129 };
 130
 131 }  // namespace content
 132
 133 #endif  // CONTENT_RENDERER_PRESENTATION_PRESENTATION_DISPATCHER_H_