[Presentation API] Use connection proxy to change connection state to 'closed'

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 144 matching lines @@
     const blink::WebString& message,
     const blink::WebPresentationConnectionProxy* connection_proxy) {
   if (message.utf8().size() > kMaxPresentationConnectionMessageSize) {
     // 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, connection_proxy)));
+  message_request_queue_.push_back(
+      base::WrapUnique(CreateSendTextMessageRequest(
+          presentationUrl, presentationId, message, 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::sendArrayBuffer(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     const uint8_t* data,
     size_t length,
     const blink::WebPresentationConnectionProxy* connection_proxy) {
   DCHECK(data);
   if (length > kMaxPresentationConnectionMessageSize) {
     // 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::BINARY, data, length,
-      connection_proxy)));
+  message_request_queue_.push_back(
+      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::sendBlobData(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     const uint8_t* data,
     size_t length,
     const blink::WebPresentationConnectionProxy* connection_proxy) {
   DCHECK(data);
   if (length > kMaxPresentationConnectionMessageSize) {
     // 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::BINARY, data, length,
-      connection_proxy)));
+  message_request_queue_.push_back(
+      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) {
   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)
@@ skipping 11 matching lines @@
     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();
+  message_request_queue_.pop_front();
   if (!message_request_queue_.empty()) {
     DoSendMessage(message_request_queue_.front().get());
   }
 }
 
 void PresentationDispatcher::SetControllerConnection(
     const PresentationSessionInfo& 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, controller_connection_proxy->Bind(),
       controller_connection_proxy->MakeRemoteRequest());
 }
 
 void PresentationDispatcher::closeSession(
     const blink::WebURL& presentationUrl,
-    const blink::WebString& presentationId) {
+    const blink::WebString& presentationId,
+    const blink::WebPresentationConnectionProxy* connection_proxy) {
+  message_request_queue_.erase(
+      std::remove_if(message_request_queue_.begin(),
+                     message_request_queue_.end(),
+                     [&connection_proxy](
+                         const std::unique_ptr<SendMessageRequest>& request) {
+                       return request->connection_proxy == connection_proxy;
+                     }),
+      message_request_queue_.end());
+
+  connection_proxy->close();
+
   ConnectToPresentationServiceIfNeeded();
   presentation_service_->CloseConnection(presentationUrl,
                                          presentationId.utf8());
 }
 
 void PresentationDispatcher::terminateSession(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId) {
   ConnectToPresentationServiceIfNeeded();
   presentation_service_->Terminate(presentationUrl, presentationId.utf8());
@@ skipping 502 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