[Presentation API] (4th)(1-UA blink side) Add WebPresentationConnection and WebPresentationConnecti…

content/renderer/presentation/presentation_dispatcher.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 CONTENT_RENDERER_PRESENTATION_PRESENTATION_DISPATCHER_H_
 #define CONTENT_RENDERER_PRESENTATION_PRESENTATION_DISPATCHER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 31 matching lines @@
 // Blink. It forwards the calls to the Mojo PresentationService.
 class CONTENT_EXPORT PresentationDispatcher
     : public RenderFrameObserver,
       public NON_EXPORTED_BASE(blink::WebPresentationClient),
       public NON_EXPORTED_BASE(blink::mojom::PresentationServiceClient) {
  public:
   explicit PresentationDispatcher(RenderFrame* render_frame);
   ~PresentationDispatcher() override;
 
  private:
+  // TODO(crbug.com/684116): remove friend class after moving message queue
+  // logic from PresentationDispatcher to PresentationConnectionProxy.
+  friend class PresentationConnectionProxy;
   friend class TestPresentationDispatcher;
   friend class PresentationDispatcherTest;
   FRIEND_TEST_ALL_PREFIXES(PresentationDispatcherTest, TestStartSession);
   FRIEND_TEST_ALL_PREFIXES(PresentationDispatcherTest, TestStartSessionError);
   FRIEND_TEST_ALL_PREFIXES(PresentationDispatcherTest, TestJoinSession);
   FRIEND_TEST_ALL_PREFIXES(PresentationDispatcherTest, TestJoinSessionError);
   FRIEND_TEST_ALL_PREFIXES(PresentationDispatcherTest, TestSendString);
   FRIEND_TEST_ALL_PREFIXES(PresentationDispatcherTest, TestSendArrayBuffer);
   FRIEND_TEST_ALL_PREFIXES(PresentationDispatcherTest, TestSendBlobData);
   FRIEND_TEST_ALL_PREFIXES(PresentationDispatcherTest, TestCloseSession);
   FRIEND_TEST_ALL_PREFIXES(PresentationDispatcherTest, TestTerminateSession);
   FRIEND_TEST_ALL_PREFIXES(PresentationDispatcherTest,
                            TestListenForScreenAvailability);
   FRIEND_TEST_ALL_PREFIXES(PresentationDispatcherTest,
                            TestSetDefaultPresentationUrls);
 
   struct SendMessageRequest {
-    SendMessageRequest(blink::mojom::PresentationSessionInfoPtr session_info,
-                       blink::mojom::ConnectionMessagePtr message);
+    SendMessageRequest(
+        blink::mojom::PresentationSessionInfoPtr session_info,
+        blink::mojom::ConnectionMessagePtr message,
+        const blink::WebPresentationConnectionProxy* connection_proxy);
     ~SendMessageRequest();
 
     blink::mojom::PresentationSessionInfoPtr session_info;
     blink::mojom::ConnectionMessagePtr message;
+    // Proxy of Blink connection object |connection| calling connection.send().
+    // It does not take ownership of proxy object. Proxy object is owned by
+    // Blink connection. Blink connection is destroyed after
+    // PresentationDispatcher so |connection_proxy| should always be valid.
+    const blink::WebPresentationConnectionProxy* connection_proxy;
   };
 
   static SendMessageRequest* CreateSendTextMessageRequest(
       const blink::WebURL& presentationUrl,
       const blink::WebString& presentationId,
-      const blink::WebString& message);
+      const blink::WebString& message,
+      const blink::WebPresentationConnectionProxy* connection_proxy);
   static SendMessageRequest* CreateSendBinaryMessageRequest(
       const blink::WebURL& presentationUrl,
       const blink::WebString& presentationId,
       blink::mojom::PresentationMessageType type,
       const uint8_t* data,
-      size_t length);
+      size_t length,
+      const blink::WebPresentationConnectionProxy* connection_proxy);
 
   // WebPresentationClient implementation.
   void setController(blink::WebPresentationController* controller) override;
   void setReceiver(blink::WebPresentationReceiver*) override;
-
   void startSession(const blink::WebVector<blink::WebURL>& presentationUrls,
-                    std::unique_ptr<blink::WebPresentationConnectionCallback>
+                    std::unique_ptr<blink::WebPresentationConnectionCallbacks>
                         callback) override;
   void joinSession(const blink::WebVector<blink::WebURL>& presentationUrls,
                    const blink::WebString& presentationId,
-                   std::unique_ptr<blink::WebPresentationConnectionCallback>
+                   std::unique_ptr<blink::WebPresentationConnectionCallbacks>
                        callback) override;
-  void sendString(const blink::WebURL& presentationUrl,
-                  const blink::WebString& presentationId,
-                  const blink::WebString& message) override;
-  void sendArrayBuffer(const blink::WebURL& presentationUrl,
-                       const blink::WebString& presentationId,
-                       const uint8_t* data,
-                       size_t length) override;
-  void sendBlobData(const blink::WebURL& presentationUrl,
-                    const blink::WebString& presentationId,
-                    const uint8_t* data,
-                    size_t length) override;
+  void sendString(
+      const blink::WebURL& presentationUrl,
+      const blink::WebString& presentationId,
+      const blink::WebString& message,
+      const blink::WebPresentationConnectionProxy* connection_proxy) override;
+  void sendArrayBuffer(
+      const blink::WebURL& presentationUrl,
+      const blink::WebString& presentationId,
+      const uint8_t* data,
+      size_t length,
+      const blink::WebPresentationConnectionProxy* connection_proxy) override;
+  void sendBlobData(
+      const blink::WebURL& presentationUrl,
+      const blink::WebString& presentationId,
+      const uint8_t* data,
+      size_t length,
+      const blink::WebPresentationConnectionProxy* connection_proxy) override;
   void closeSession(const blink::WebURL& presentationUrl,
                     const blink::WebString& presentationId) override;
   void terminateSession(const blink::WebURL& presentationUrl,
                         const blink::WebString& presentationId) override;
   void getAvailability(
       const blink::WebVector<blink::WebURL>& availabilityUrls,
       std::unique_ptr<blink::WebPresentationAvailabilityCallbacks> callbacks)
       override;
   void startListening(blink::WebPresentationAvailabilityObserver*) override;
   void stopListening(blink::WebPresentationAvailabilityObserver*) override;
@@ skipping 16 matching lines @@
       blink::mojom::PresentationSessionInfoPtr session_info,
       blink::mojom::PresentationConnectionCloseReason reason,
       const std::string& message) override;
   void OnConnectionMessagesReceived(
       blink::mojom::PresentationSessionInfoPtr session_info,
       std::vector<blink::mojom::ConnectionMessagePtr> messages) override;
   void OnDefaultSessionStarted(
       blink::mojom::PresentationSessionInfoPtr session_info) override;
 
   void OnSessionCreated(
-      std::unique_ptr<blink::WebPresentationConnectionCallback> callback,
+      std::unique_ptr<blink::WebPresentationConnectionCallbacks> callback,
       blink::mojom::PresentationSessionInfoPtr session_info,
       blink::mojom::PresentationErrorPtr error);
   void OnReceiverConnectionAvailable(
       blink::mojom::PresentationSessionInfoPtr,
       blink::mojom::PresentationConnectionPtr,
       blink::mojom::PresentationConnectionRequest) override;
 
   // Call to PresentationService to send the message in |request|.
   // |session_info| and |message| of |reuqest| will be consumed.
   // |HandleSendMessageRequests| will be invoked after the send is attempted.
@@ skipping 88 matching lines @@
   // Returns UNKNOWN if all urls in |urls| have screen availability
   // UNKNOWN.
   ScreenAvailability GetScreenAvailability(const std::vector<GURL>& urls) const;
 
   DISALLOW_COPY_AND_ASSIGN(PresentationDispatcher);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_PRESENTATION_PRESENTATION_DISPATCHER_H_