[Presentation API] (1-UA) fire PresentationConnection onterminate event if receiver page gets destr…

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"
@@ skipping 241 matching lines @@
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId) {
   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());
+  if (receiver_) {
+    receiver_->closeWindow();

[imcheng, 2016/11/28 22:12:01]

If the receiver frame calls terminate, how do we ensure the controllers'
connection state goes to terminated? I feel like this should go through to
MediaRouter / OPM to clean up the offscreen tab and notify controllers.

[zhaobin, 2017/02/16 00:42:30]

closeWindow() closes offscreen tab and MRP will signal controller that
connection is terminated (It is the same as close normal tab while we are
mirroring).

+    return;
+  }
+
+  if (controller_) {
+    ConnectToPresentationServiceIfNeeded();
+    presentation_service_->Terminate(presentationUrl, presentationId.utf8());
+    return;
+  }
 }
 
 void PresentationDispatcher::getAvailability(
     const blink::WebURL& availabilityUrl,
     blink::WebPresentationAvailabilityCallbacks* callbacks) {
   AvailabilityStatus* status = nullptr;
   auto status_it = availability_status_.find(availabilityUrl);
   if (status_it == availability_status_.end()) {
     status = new AvailabilityStatus(availabilityUrl);
     availability_status_[availabilityUrl] = base::WrapUnique(status);
@@ skipping 168 matching lines @@
   receiver_connection_proxy->SetTargetConnection(std::move(controller));
   // Bind receiver_connection_proxy with PresentationConnection
   // in receiver page.
   receiver_->onReceiverConnectionAvailable(new PresentationConnectionClient(
       std::move(session_info), std::move(receiver_connection_proxy)));
 }
 
 void PresentationDispatcher::OnConnectionStateChanged(
     blink::mojom::PresentationSessionInfoPtr connection,
     blink::mojom::PresentationConnectionState state) {
-  if (!controller_)
+  if (!controller_ && !receiver_)
     return;
 
-  DCHECK(!connection.is_null());
-  controller_->didChangeSessionState(
-      new PresentationConnectionClient(std::move(connection)),
-      GetWebPresentationConnectionStateFromMojo(state));
+  if (receiver_) {
+    receiver_->didChangeSessionState(
+        GetWebPresentationConnectionStateFromMojo(state));
+    return;
+  }
+
+  if (controller_) {
+    DCHECK(!connection.is_null());
+    controller_->didChangeSessionState(
+        new PresentationConnectionClient(std::move(connection)),
+        GetWebPresentationConnectionStateFromMojo(state));
+    return;
+  }
 }
 
 void PresentationDispatcher::OnConnectionClosed(
     blink::mojom::PresentationSessionInfoPtr connection,
     blink::mojom::PresentationConnectionCloseReason reason,
     const std::string& message) {
   if (!controller_)
     return;
 
   DCHECK(!connection.is_null());
@@ skipping 122 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