[Presentation API] Remove closed connections from PresentationConnectionList

content/renderer/presentation/presentation_connection_proxy.cc

 // Copyright 2017 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_connection_proxy.h"
 
 #include "base/logging.h"
 #include "content/public/common/presentation_info.h"
 #include "content/renderer/presentation/presentation_dispatcher.h"
 #include "third_party/WebKit/public/platform/WebString.h"
@@ skipping 45 matching lines @@
         blink::WebPresentationConnectionState::kConnected);
   } else if (state == content::PRESENTATION_CONNECTION_STATE_CLOSED) {
     source_connection_->DidClose();
   } else {
     NOTREACHED();
   }
 }
 
 void PresentationConnectionProxy::OnClose() {
   DCHECK(target_connection_ptr_);
-  source_connection_->DidClose();
+  DidChangeState(content::PRESENTATION_CONNECTION_STATE_CLOSED);
   target_connection_ptr_->DidChangeState(
       content::PRESENTATION_CONNECTION_STATE_CLOSED);
 }
 
 void PresentationConnectionProxy::Close() const {
   DCHECK(target_connection_ptr_);
   target_connection_ptr_->OnClose();
 }
 
 ControllerConnectionProxy::ControllerConnectionProxy(
     blink::WebPresentationConnection* controller_connection)
     : PresentationConnectionProxy(controller_connection) {}
 
 ControllerConnectionProxy::~ControllerConnectionProxy() = default;
 
 blink::mojom::PresentationConnectionPtr ControllerConnectionProxy::Bind() {
   return binding_.CreateInterfacePtrAndBind();
 }
 
 blink::mojom::PresentationConnectionRequest
 ControllerConnectionProxy::MakeRemoteRequest() {
   DCHECK(!target_connection_ptr_)
       << "target_connection_ptr_ should only be bound once.";
   return mojo::MakeRequest(&target_connection_ptr_);
 }
 
 ReceiverConnectionProxy::ReceiverConnectionProxy(
-    blink::WebPresentationConnection* receiver_connection)
-    : PresentationConnectionProxy(receiver_connection) {}
+    blink::WebPresentationConnection* receiver_connection,
+    const OnConnectionClosedCallback& connection_closed_callback)
+    : PresentationConnectionProxy(receiver_connection),
+      connection_closed_callback_(connection_closed_callback) {
+  DCHECK(connection_closed_callback_);
+}
 
 ReceiverConnectionProxy::~ReceiverConnectionProxy() = default;
 
 void ReceiverConnectionProxy::Bind(
     blink::mojom::PresentationConnectionRequest receiver_connection_request) {
   binding_.Bind(std::move(receiver_connection_request));
 }
 
 void ReceiverConnectionProxy::BindControllerConnection(
     blink::mojom::PresentationConnectionPtr controller_connection_ptr) {
   DCHECK(!target_connection_ptr_);
   target_connection_ptr_ = std::move(controller_connection_ptr);
   target_connection_ptr_->DidChangeState(
       content::PRESENTATION_CONNECTION_STATE_CONNECTED);
 
   DidChangeState(content::PRESENTATION_CONNECTION_STATE_CONNECTED);
 }
 
+void ReceiverConnectionProxy::DidChangeState(
+    content::PresentationConnectionState state) {
+  PresentationConnectionProxy::DidChangeState(state);
+  if (state == content::PRESENTATION_CONNECTION_STATE_CLOSED)
+    connection_closed_callback_.Run();
+}
+
 }  // namespace content