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

content/renderer/presentation/presentation_dispatcher.cc

 // 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.
 
 #include "content/renderer/presentation/presentation_dispatcher.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "content/public/common/presentation_constants.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/renderer/presentation/presentation_connection_client.h"
+#include "content/renderer/presentation/presentation_connection_proxy.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationAvailabilityObserver.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationController.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationError.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationReceiver.h"
 #include "third_party/WebKit/public/platform/modules/presentation/presentation.mojom.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
@@ skipping 106 matching lines @@
 
   // The dispatcher owns the service so |this| will be valid when
   // OnSessionCreated() is called. |callback| needs to be alive and also needs
   // to be destroyed so we transfer its ownership to the mojo callback.
   presentation_service_->JoinSession(
       urls, presentationId.utf8(),
       base::Bind(&PresentationDispatcher::OnSessionCreated,
                  base::Unretained(this), base::Owned(callback)));
 }
 
-void PresentationDispatcher::sendString(const blink::WebURL& presentationUrl,
-                                        const blink::WebString& presentationId,
-                                        const blink::WebString& message) {
+void PresentationDispatcher::sendString(
+    const blink::WebURL& presentationUrl,
+    const blink::WebString& presentationId,
+    const blink::WebString& message,
+    const blink::WebPresentationConnectionProxy* connection_proxy) {
   if (message.utf8().size() > kMaxPresentationSessionMessageSize) {
     // TODO(crbug.com/459008): Limit the size of individual messages to 64k
     // for now. Consider throwing DOMException or splitting bigger messages
     // into smaller chunks later.
     LOG(WARNING) << "message size exceeded limit!";
     return;
   }
 
   message_request_queue_.push(base::WrapUnique(
       CreateSendTextMessageRequest(presentationUrl, presentationId, message)));
   // Start processing request if only one in the queue.
   if (message_request_queue_.size() == 1)
-    DoSendMessage(message_request_queue_.front().get());
+    DoSendMessage(message_request_queue_.front().get(), connection_proxy);
 }
 
 void PresentationDispatcher::sendArrayBuffer(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     const uint8_t* data,
-    size_t length) {
+    size_t length,
+    const blink::WebPresentationConnectionProxy* connection_proxy) {
   DCHECK(data);
   if (length > kMaxPresentationSessionMessageSize) {
     // TODO(crbug.com/459008): Same as in sendString().
     LOG(WARNING) << "data size exceeded limit!";
     return;
   }
 
   message_request_queue_.push(base::WrapUnique(CreateSendBinaryMessageRequest(
       presentationUrl, presentationId,
       blink::mojom::PresentationMessageType::ARRAY_BUFFER, data, length)));
   // Start processing request if only one in the queue.
   if (message_request_queue_.size() == 1)
-    DoSendMessage(message_request_queue_.front().get());
+    DoSendMessage(message_request_queue_.front().get(), connection_proxy);
 }
 
 void PresentationDispatcher::sendBlobData(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     const uint8_t* data,
-    size_t length) {
+    size_t length,
+    const blink::WebPresentationConnectionProxy* connection_proxy) {
   DCHECK(data);
   if (length > kMaxPresentationSessionMessageSize) {
     // TODO(crbug.com/459008): Same as in sendString().
     LOG(WARNING) << "data size exceeded limit!";
     return;
   }
 
   message_request_queue_.push(base::WrapUnique(CreateSendBinaryMessageRequest(
       presentationUrl, presentationId,
       blink::mojom::PresentationMessageType::BLOB, data, length)));
   // Start processing request if only one in the queue.
   if (message_request_queue_.size() == 1)
-    DoSendMessage(message_request_queue_.front().get());
+    DoSendMessage(message_request_queue_.front().get(), connection_proxy);
 }
 
-void PresentationDispatcher::DoSendMessage(SendMessageRequest* request) {
+void PresentationDispatcher::DoSendMessage(
+    SendMessageRequest* request,
+    const blink::WebPresentationConnectionProxy* connection_proxy) {
   ConnectToPresentationServiceIfNeeded();
 
   presentation_service_->SendSessionMessage(
       std::move(request->session_info), std::move(request->message),
       base::Bind(&PresentationDispatcher::HandleSendMessageRequests,
-                 base::Unretained(this)));
+                 base::Unretained(this), nullptr));
 }
 
-void PresentationDispatcher::HandleSendMessageRequests(bool success) {
+void PresentationDispatcher::HandleSendMessageRequests(
+    const blink::WebPresentationConnectionProxy* connection_proxy,
+    bool success) {
   // In normal cases, message_request_queue_ should not be empty at this point
   // of time, but when DidCommitProvisionalLoad() is invoked before receiving
   // the callback for previous send mojo call, queue would have been emptied.
   if (message_request_queue_.empty())
     return;
 
   if (!success) {
     // PresentationServiceImpl is informing that Frame has been detached or
     // navigated away. Invalidate all pending requests.
     MessageRequestQueue empty;
     std::swap(message_request_queue_, empty);
     return;
   }
 
   message_request_queue_.pop();
   if (!message_request_queue_.empty()) {
-    DoSendMessage(message_request_queue_.front().get());
+    DoSendMessage(message_request_queue_.front().get(), connection_proxy);
   }
 }
 
 void PresentationDispatcher::closeSession(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId) {
   ConnectToPresentationServiceIfNeeded();
   presentation_service_->CloseConnection(presentationUrl,
                                          presentationId.utf8());
 }
@@ skipping 202 matching lines @@
 void PresentationDispatcher::OnSessionMessagesReceived(
     blink::mojom::PresentationSessionInfoPtr session_info,
     std::vector<blink::mojom::SessionMessagePtr> messages) {
   if (!controller_)
     return;
 
   for (size_t i = 0; i < messages.size(); ++i) {
     // Note: Passing batches of messages to the Blink layer would be more
     // efficient.
     std::unique_ptr<PresentationConnectionClient> session_client(
-        new PresentationConnectionClient(session_info->url, session_info->id));
+        new PresentationConnectionClient(session_info.Clone()));
     switch (messages[i]->type) {
       case blink::mojom::PresentationMessageType::TEXT: {
         // TODO(mfoltz): Do we need to DCHECK(messages[i]->message)?
         controller_->didReceiveSessionTextMessage(
             session_client.release(),
             blink::WebString::fromUTF8(messages[i]->message.value()));
         break;
       }
       case blink::mojom::PresentationMessageType::ARRAY_BUFFER:
       case blink::mojom::PresentationMessageType::BLOB: {
@@ skipping 87 matching lines @@
 PresentationDispatcher::AvailabilityStatus::AvailabilityStatus(
     const GURL& availability_url)
     : url(availability_url),
       last_known_availability(false),
       listening_state(ListeningState::INACTIVE) {}
 
 PresentationDispatcher::AvailabilityStatus::~AvailabilityStatus() {
 }
 
 }  // namespace content