[Presentation API] (MR side) 1-UA: notify receiver page when receiver connection becomes available

content/browser/presentation/presentation_service_impl.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/browser/presentation/presentation_service_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
@@ skipping 126 matching lines @@
 
   render_process_id_ = render_frame_host->GetProcess()->GetID();
   render_frame_id_ = render_frame_host->GetRoutingID();
   DVLOG(2) << "PresentationServiceImpl: "
            << render_process_id_ << ", " << render_frame_id_;
   if (delegate_)
     delegate_->AddObserver(render_process_id_, render_frame_id_, this);
 }
 
 PresentationServiceImpl::~PresentationServiceImpl() {
+  DVLOG(2) << "~PresentationServiceImpl: " << render_process_id_ << ", "
+           << render_frame_id_;
   if (delegate_)
     delegate_->RemoveObserver(render_process_id_, render_frame_id_);
 }
 
 // static
 void PresentationServiceImpl::CreateMojoService(
     RenderFrameHost* render_frame_host,
     mojo::InterfaceRequest<blink::mojom::PresentationService> request) {
   DVLOG(2) << "CreateMojoService";
   WebContents* web_contents =
@@ skipping 14 matching lines @@
     mojo::InterfaceRequest<blink::mojom::PresentationService> request) {
   binding_.reset(new mojo::Binding<blink::mojom::PresentationService>(
       this, std::move(request)));
 }
 
 void PresentationServiceImpl::SetClient(
     blink::mojom::PresentationServiceClientPtr client) {
   DCHECK(!client_.get());
   // TODO(imcheng): Set ErrorHandler to listen for errors.
   client_ = std::move(client);
+
+  if (delegate_) {

[imcheng, 2016/09/28 07:28:37]

1) We might as well call these in the PSImpl constructor... I don't see a reason
why it needs to be called here.
2) Maybe we can add a is_receiver() method on PSD. It can be used here to
determine whether RegisterReceiverAvailableCallback or
RegisterOffscreenPresentationClient should be called, instead of calling both.

[zhaobin, 2016/09/29 17:20:44]

1) RegisterReceiverAvailableCallback() invokes
dispatcher_->OnReceiverConnectionAvailable() if there is any pending controller.
dispatcher_ is null in constructor. It will make OffscreenPresentationManager
code complicated to handle that.

2) delegate_->RegisterOffscreenPresentationClient() removed in new patch

+    delegate_->RegisterReceiverAvailableCallback(
+        base::Bind(&PresentationServiceImpl::OnReceiverConnectionAvailable,
+                   weak_factory_.GetWeakPtr()));
+    delegate_->RegisterOffscreenPresentationClient(render_process_id_,
+                                                   render_frame_id_, this);
+  }
 }
 
 void PresentationServiceImpl::ListenForScreenAvailability(const GURL& url) {
   DVLOG(2) << "ListenForScreenAvailability " << url;
   if (!delegate_) {
     client_->OnScreenAvailabilityUpdated(url, false);
     return;
   }
 
   if (screen_availability_listeners_.count(url.spec()))
@@ skipping 229 matching lines @@
   }
 }
 
 void PresentationServiceImpl::CloseConnection(
     const GURL& presentation_url,
     const std::string& presentation_id) {
   DVLOG(2) << "CloseConnection " << presentation_id;
   if (delegate_)
     delegate_->CloseConnection(render_process_id_, render_frame_id_,
                                presentation_id);
+
+  for (const auto& iter : offscreen_presentation_observers_)

[imcheng, 2016/09/28 07:28:37]

This probably doesn't make sense until we have extracted CloseConnection into
part of the PresentationConnection mojo interface since we want to close the
corresponding connection on the other side, not all of them.

[zhaobin, 2016/09/29 17:20:44]

code removed in new patch

+    iter->RemoveOffscreenPresentationClient(this);
+  offscreen_presentation_observers_.clear();
 }
 
 void PresentationServiceImpl::Terminate(const GURL& presentation_url,
                                         const std::string& presentation_id) {
   DVLOG(2) << "Terminate " << presentation_id;
   if (delegate_)
     delegate_->Terminate(render_process_id_, render_frame_id_, presentation_id);
 }
 
 void PresentationServiceImpl::OnConnectionStateChanged(
@@ skipping 45 matching lines @@
   std::transform(messages.begin(), messages.end(), mojo_messages.begin(),
                  [pass_ownership](PresentationSessionMessage* message) {
                    return ToMojoSessionMessage(message, pass_ownership);
                  });
 
   client_->OnSessionMessagesReceived(
       blink::mojom::PresentationSessionInfo::From(session),
       std::move(mojo_messages));
 }
 
+void PresentationServiceImpl::OnReceiverConnectionAvailable(
+    const content::PresentationSessionInfo& session_info,
+    OffscreenPresentationClient* controller) {
+  DVLOG(2) << "PresentationServiceImpl::OnReceiverConnectionAvailable";
+  client_->OnReceiverConnectionAvailable(
+      blink::mojom::PresentationSessionInfo::From(session_info));
+
+  controller->SetOffscreenPresentationClient(this);
+  this->SetOffscreenPresentationClient(controller);
+}
+
+void PresentationServiceImpl::SetOffscreenPresentationClient(
+    OffscreenPresentationClient* client) {
+  offscreen_presentation_observers_.insert(client);
+}
+
+void PresentationServiceImpl::RemoveOffscreenPresentationClient(
+    OffscreenPresentationClient* client) {
+  offscreen_presentation_observers_.erase(client);
+}
+
 void PresentationServiceImpl::DidNavigateAnyFrame(
     content::RenderFrameHost* render_frame_host,
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   DVLOG(2) << "PresentationServiceImpl::DidNavigateAnyFrame";
   if (!FrameMatches(render_frame_host))
     return;
 
   std::string prev_url_host = details.previous_url.host();
   std::string curr_url_host = params.url.host();
@@ skipping 49 matching lines @@
         mojo::Array<blink::mojom::SessionMessagePtr>());
     on_session_messages_callback_.reset();
   }
 
   if (send_message_callback_) {
     // Run the callback with false, indicating the renderer to stop sending
     // the requests and invalidate all pending requests.
     send_message_callback_->Run(false);
     send_message_callback_.reset();
   }
+
+  for (const auto& iter : offscreen_presentation_observers_)
+    iter->RemoveOffscreenPresentationClient(this);
+
+  offscreen_presentation_observers_.clear();
 }
 
 void PresentationServiceImpl::OnDelegateDestroyed() {
   DVLOG(2) << "PresentationServiceImpl::OnDelegateDestroyed";
   delegate_ = nullptr;
   Reset();
 }
 
 void PresentationServiceImpl::OnDefaultPresentationStarted(
     const PresentationSessionInfo& connection) {
@@ skipping 46 matching lines @@
 
 void PresentationServiceImpl::NewSessionCallbackWrapper::Run(
     blink::mojom::PresentationSessionInfoPtr session,
     blink::mojom::PresentationErrorPtr error) {
   DCHECK(!callback_.is_null());
   callback_.Run(std::move(session), std::move(error));
   callback_.Reset();
 }
 
 }  // namespace content