[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);
+
+  // It will invoke onReceiverConnectionAvailable callback
+  // on receiver frame (associated with ReceiverPSDImpl);
+  // It does nothing on controller frame.
+  if (delegate_)
+    delegate_->RegisterOffscreenPresentationReceiver(this);

[imcheng, 2016/09/19 23:01:17]

I have a few concerns with this approach:

1) We are calling this in a common code path, regardless of whether this PSImpl
corresponds to a controller or a receiver. Needing a comment to state that it
does nothing on the controller frame is indicative that that we are not modeling
the relationship between objects / interfaces properly.

2) It appears what the code is trying to achieve is to bind the entire
controller PSImpl to talk to the receiver PSImpl directly and vice versa. In
reality, we only want to use this special direct path for offscreen presentation
connections. For instance, if a controller page has both offscreen and
non-offscreen presentations, it's not clear to me how it would work in that
case.

3) It doesn't seem like we are actually using the special path in here - I see
we are storing |offscreen_presentation_observers_|, but they aren't used. It is
also not clear how the multiple controllers case will work.

[zhaobin, 2016/09/23 17:18:18]

Acknowledged.

 }
 
 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 121 matching lines @@
   if (request_session_id != start_session_request_id_)
     return;
 
   CHECK(pending_start_session_cb_.get());
   pending_start_session_cb_->Run(
       blink::mojom::PresentationSessionInfo::From(session_info),
       blink::mojom::PresentationErrorPtr());
   ListenForConnectionStateChange(session_info);
   pending_start_session_cb_.reset();
   start_session_request_id_ = kInvalidRequestSessionId;
+
+  if (delegate_)
+    delegate_->RegisterOffscreenPresentationController(
+        session_info.presentation_id, this);
 }
 
 void PresentationServiceImpl::OnStartSessionError(
     int request_session_id,
     const PresentationError& error) {
   if (request_session_id != start_session_request_id_)
     return;
 
   CHECK(pending_start_session_cb_.get());
   pending_start_session_cb_->Run(blink::mojom::PresentationSessionInfoPtr(),
@@ skipping 85 matching lines @@
   if (send_message_callback_) {
     send_message_callback_->Run(sent);
     send_message_callback_.reset();
   }
 }
 
 void PresentationServiceImpl::CloseConnection(
     const GURL& presentation_url,
     const std::string& presentation_id) {
   DVLOG(2) << "CloseConnection " << presentation_id;
-  if (delegate_)
+  if (delegate_) {
     delegate_->CloseConnection(render_process_id_, render_frame_id_,
                                presentation_id);
+    delegate_->UnregisterOffscreenPresentationController(presentation_id, this);
+  }
 }
 
 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) {
+  DVLOG(2) << "PresentationServiceImpl::OnReceiverConnectionAvailable";
+  client_->OnReceiverConnectionAvailable(
+      blink::mojom::PresentationSessionInfo::From(session_info));
+}
+
+void PresentationServiceImpl::AddOffscreenPresentationObserver(
+    OffscreenPresentationClient* client) {
+  offscreen_presentation_observers_.insert(client);
+}
+
+void PresentationServiceImpl::RemoveOffscreenPresentationObserver(
+    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 25 matching lines @@
 void PresentationServiceImpl::WebContentsDestroyed() {
   LOG(ERROR) << "PresentationServiceImpl is being deleted in "
              << "WebContentsDestroyed()! This shouldn't happen since it "
              << "should've been deleted during RenderFrameDeleted().";
   Reset();
   delete this;
 }
 
 void PresentationServiceImpl::Reset() {
   DVLOG(2) << "PresentationServiceImpl::Reset";
-  if (delegate_)
+  if (delegate_) {
     delegate_->Reset(render_process_id_, render_frame_id_);
+    delegate_->UnregisterOffscreenPresentationReceiver(this);
+  }
 
   default_presentation_urls_.clear();
 
   screen_availability_listeners_.clear();
 
   start_session_request_id_ = kInvalidRequestSessionId;
   pending_start_session_cb_.reset();
 
   pending_join_session_cbs_.clear();
 
@@ skipping 68 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