[Presentation API] (5th) (1-UA) integrate controller and receiver side for 1-UA messaging

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 284 matching lines @@
     const NewSessionCallback& callback) {
   if (pending_join_session_cbs_.size() >= kMaxNumQueuedSessionRequests)
     return kInvalidRequestSessionId;
 
   int request_id = GetNextRequestSessionId();
   pending_join_session_cbs_[request_id].reset(
       new NewSessionCallbackWrapper(callback));
   return request_id;
 }
 
-void PresentationServiceImpl::ListenForConnectionStateChangeAndChangeState(
+void PresentationServiceImpl::ListenForConnectionStateChange(
     const PresentationSessionInfo& connection) {
   if (controller_delegate_) {
     controller_delegate_->ListenForConnectionStateChange(
         render_process_id_, render_frame_id_, connection,
         base::Bind(&PresentationServiceImpl::OnConnectionStateChanged,
                    weak_factory_.GetWeakPtr(), connection));
-    OnConnectionStateChanged(connection,
-                             PresentationConnectionStateChangeInfo(
-                                 PRESENTATION_CONNECTION_STATE_CONNECTED));
   }
 }
 
 void PresentationServiceImpl::OnStartSessionSucceeded(
     int request_session_id,
     const PresentationSessionInfo& session_info) {
   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());
-  ListenForConnectionStateChangeAndChangeState(session_info);
+  ListenForConnectionStateChange(session_info);
   pending_start_session_cb_.reset();
   start_session_request_id_ = kInvalidRequestSessionId;
 }
 
 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(),
                                  blink::mojom::PresentationError::From(error));
   pending_start_session_cb_.reset();
   start_session_request_id_ = kInvalidRequestSessionId;
 }
 
 void PresentationServiceImpl::OnJoinSessionSucceeded(
     int request_session_id,
     const PresentationSessionInfo& session_info) {
   if (RunAndEraseJoinSessionMojoCallback(
           request_session_id,
           blink::mojom::PresentationSessionInfo::From(session_info),
           blink::mojom::PresentationErrorPtr())) {
-    ListenForConnectionStateChangeAndChangeState(session_info);
+    ListenForConnectionStateChange(session_info);
   }
 }
 
 void PresentationServiceImpl::OnJoinSessionError(
     int request_session_id,
     const PresentationError& error) {
   RunAndEraseJoinSessionMojoCallback(
       request_session_id, blink::mojom::PresentationSessionInfoPtr(),
       blink::mojom::PresentationError::From(error));
 }
@@ skipping 128 matching lines @@
 
 void PresentationServiceImpl::SetPresentationConnection(
     blink::mojom::PresentationSessionInfoPtr session,
     blink::mojom::PresentationConnectionPtr connection) {
   DVLOG(2) << "SetPresentationConnection";
 
   if (!controller_delegate_)
     return;
 
   PresentationSessionInfo session_info(session.To<PresentationSessionInfo>());
-  controller_delegate_->ConnectToOffscreenPresentation(
-      render_process_id_, render_frame_id_, session_info,
-      std::move(connection));
+  controller_delegate_->ConnectToPresentation(render_process_id_,
+                                              render_frame_id_, session_info,
+                                              std::move(connection));
 }
 
 void PresentationServiceImpl::OnSessionMessages(
     const PresentationSessionInfo& session,
     const ScopedVector<PresentationSessionMessage>& messages,
     bool pass_ownership) {
   DCHECK(client_);
   DVLOG(2) << "OnSessionMessages"
            << " [id]: " << session.presentation_id;
   std::vector<blink::mojom::SessionMessagePtr> mojo_messages(messages.size());
   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,
     PresentationConnectionPtr&& controller) {
   DVLOG(2) << "PresentationServiceImpl::OnReceiverConnectionAvailable";
+
+  client_->OnReceiverConnectionAvailable(
+      blink::mojom::PresentationSessionInfo::From(session_info),
+      std::move(controller));
 }
 
 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;
 
@@ skipping 66 matching lines @@
   controller_delegate_ = nullptr;
   receiver_delegate_ = nullptr;
   Reset();
 }
 
 void PresentationServiceImpl::OnDefaultPresentationStarted(
     const PresentationSessionInfo& connection) {
   DCHECK(client_.get());
   client_->OnDefaultSessionStarted(
       blink::mojom::PresentationSessionInfo::From(connection));
-  ListenForConnectionStateChangeAndChangeState(connection);
+  ListenForConnectionStateChange(connection);
 }
 
 PresentationServiceImpl::ScreenAvailabilityListenerImpl::
     ScreenAvailabilityListenerImpl(const GURL& availability_url,
                                    PresentationServiceImpl* service)
     : availability_url_(availability_url), service_(service) {
   DCHECK(service_);
   DCHECK(service_->client_.get());
 }
 
@@ skipping 29 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