[Presentation API] (5th) (1-UA) integrate controller and receiver side for 1-UA messaging

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 <string>
 #include <utility>
 #include <vector>
 
@@ skipping 209 matching lines @@
   message_request_queue_.push(base::WrapUnique(CreateSendBinaryMessageRequest(
       presentationUrl, presentationId,
       blink::mojom::PresentationMessageType::BINARY, data, length,
       connection_proxy)));
   // Start processing request if only one in the queue.
   if (message_request_queue_.size() == 1)
     DoSendMessage(message_request_queue_.front().get());
 }
 
 void PresentationDispatcher::DoSendMessage(SendMessageRequest* request) {
-  ConnectToPresentationServiceIfNeeded();
-
-  presentation_service_->SendConnectionMessage(
-      std::move(request->session_info), std::move(request->message),
-      base::Bind(&PresentationDispatcher::HandleSendMessageRequests,
-                 base::Unretained(this)));
+  DCHECK(request->connection_proxy);
+  // TODO(crbug.com/684116): Remove static_cast after moving message queue logic
+  // from PresentationDispatcher to PresentationConnectionProxy.
+  static_cast<const PresentationConnectionProxy*>(request->connection_proxy)
+      ->SendConnectionMessage(
+          std::move(request->message),
+          base::Bind(&PresentationDispatcher::HandleSendMessageRequests,
+                     base::Unretained(this)));
 }
 
 void PresentationDispatcher::HandleSendMessageRequests(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());
   }
 }
 
+void PresentationDispatcher::SetControllerConnection(
+    blink::mojom::PresentationSessionInfoPtr session_info,
+    blink::WebPresentationConnection* connection) {
+  DCHECK(connection);
+
+  auto* controller_connection_proxy = new ControllerConnectionProxy(connection);
+  connection->bindProxy(base::WrapUnique(controller_connection_proxy));
+
+  ConnectToPresentationServiceIfNeeded();
+  presentation_service_->SetPresentationConnection(
+      session_info.Clone(), controller_connection_proxy->Bind(),
+      controller_connection_proxy->MakeRemoteRequest());
+}
+
 void PresentationDispatcher::closeSession(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId) {
   ConnectToPresentationServiceIfNeeded();
   presentation_service_->CloseConnection(presentationUrl,
                                          presentationId.utf8());
 }
 
 void PresentationDispatcher::terminateSession(
     const blink::WebURL& presentationUrl,
@@ skipping 212 matching lines @@
   for (auto* listener : modified_listeners)
     TryRemoveAvailabilityListener(listener);
 }
 
 void PresentationDispatcher::OnDefaultSessionStarted(
     blink::mojom::PresentationSessionInfoPtr session_info) {
   if (!controller_)
     return;
 
   if (!session_info.is_null()) {
-    presentation_service_->ListenForConnectionMessages(session_info.Clone());
     auto* connection = controller_->didStartDefaultSession(
         mojo::ConvertTo<blink::WebPresentationSessionInfo>(session_info));
-    connection->bindProxy(
-        base::MakeUnique<ControllerConnectionProxy>(connection));
+
+    if (connection) {
+      SetControllerConnection(session_info.Clone(), connection);
+      // Change blink connection state to 'connected' before listening to
+      // connection message. Remove ListenForConnectionMessage() after
+      // TODO(crbug.com/687011): use BrowserPresentationConnectionProxy to send
+      // message from route to blink connection.
+      presentation_service_->ListenForConnectionMessages(session_info.Clone());
+    }
   }
 }
 
 void PresentationDispatcher::OnSessionCreated(
     std::unique_ptr<blink::WebPresentationConnectionCallbacks> callback,
     blink::mojom::PresentationSessionInfoPtr session_info,
     blink::mojom::PresentationErrorPtr error) {
   DCHECK(callback);
   if (!error.is_null()) {
     DCHECK(session_info.is_null());
     callback->onError(blink::WebPresentationError(
         GetWebPresentationErrorTypeFromMojo(error->error_type),
         blink::WebString::fromUTF8(error->message)));
     return;
   }
 
   DCHECK(!session_info.is_null());
-  presentation_service_->ListenForConnectionMessages(session_info.Clone());
   callback->onSuccess(
       mojo::ConvertTo<blink::WebPresentationSessionInfo>(session_info));
-
-  auto* connection = callback->getConnection();
-  connection->bindProxy(
-      base::MakeUnique<ControllerConnectionProxy>(connection));
+  // Change blink connection state to 'connected' before listening to
+  // connection message. Remove ListenForConnectionMessage() after
+  // TODO(crbug.com/687011): use BrowserPresentationConnectionProxy to send
+  // message from route to blink connection.
+  SetControllerConnection(session_info.Clone(), callback->getConnection());
+  presentation_service_->ListenForConnectionMessages(session_info.Clone());
 }
 
 void PresentationDispatcher::OnReceiverConnectionAvailable(
     blink::mojom::PresentationSessionInfoPtr session_info,
     blink::mojom::PresentationConnectionPtr controller_connection_ptr,
     blink::mojom::PresentationConnectionRequest receiver_connection_request) {
   DCHECK(receiver_);
+
   // Bind receiver_connection_proxy with PresentationConnection in receiver
   // page.
   auto* connection = receiver_->onReceiverConnectionAvailable(
       mojo::ConvertTo<blink::WebPresentationSessionInfo>(session_info));
   auto* receiver_connection_proxy = new ReceiverConnectionProxy(connection);
   connection->bindProxy(base::WrapUnique(receiver_connection_proxy));
 
   receiver_connection_proxy->Bind(std::move(receiver_connection_request));
   receiver_connection_proxy->BindControllerConnection(
       std::move(controller_connection_ptr));
@@ skipping 224 matching lines @@
 
 PresentationDispatcher::ListeningStatus::ListeningStatus(
     const GURL& availability_url)
     : url(availability_url),
       last_known_availability(ScreenAvailability::UNKNOWN),
       listening_state(ListeningState::INACTIVE) {}
 
 PresentationDispatcher::ListeningStatus::~ListeningStatus() {}
 
 }  // namespace content