[Presentation API] 1-UA presentation support + presenter APIs.

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 <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 184 matching lines @@
     return;
 
   scoped_ptr<ScreenAvailabilityListenerImpl> listener(
       new ScreenAvailabilityListenerImpl(availability_url, this));
   if (delegate_->AddScreenAvailabilityListener(
       render_process_id_,
       render_frame_id_,
       listener.get())) {
     screen_availability_listeners_.set(availability_url, listener.Pass());
   } else {
-    DVLOG(1) << "AddScreenAvailabilityListener failed. Ignoring request.";
+    DVLOG(1) << "AddScreenAvailabilityListener failed. Returning false.";
+    client_->OnScreenAvailabilityUpdated(url, false);
   }
 }
 
 void PresentationServiceImpl::StopListeningForScreenAvailability(
     const mojo::String& url) {
   DVLOG(2) << "StopListeningForScreenAvailability " << url;
   if (!delegate_)
     return;
 
   const std::string& availability_url = url.get();
@@ skipping 234 matching lines @@
   if (!delegate_)
     return;
 
   PresentationSessionInfo session_info(session.To<PresentationSessionInfo>());
   delegate_->ListenForSessionMessages(
       render_process_id_, render_frame_id_, session_info,
       base::Bind(&PresentationServiceImpl::OnSessionMessages,
                  weak_factory_.GetWeakPtr(), session_info));
 }
 
+void PresentationServiceImpl::GetPresentationReceiverSession(
+    const GetPresentationReceiverSessionMojoCallback& callback) {
+  DVLOG(2) << "GetPresentationReceiverSession";
+  if (!delegate_) {
+    callback.Run(presentation::PresentationSessionInfoPtr());
+    return;
+  }
+
+  presenter_session_callback_.reset(
+      new GetPresentationReceiverSessionMojoCallback(callback));
+  delegate_->GetPresentationReceiverSession(
+      render_process_id_, render_frame_id_,
+      base::Bind(
+          &PresentationServiceImpl::OnGetPresentationReceiverSessionSuccess,
+          weak_factory_.GetWeakPtr()),
+      base::Bind(
+          &PresentationServiceImpl::OnGetPresentationReceiverSessionError,
+          weak_factory_.GetWeakPtr()));
+}
+
+void PresentationServiceImpl::OnGetPresentationReceiverSessionSuccess(
+    const content::PresentationSessionInfo& session_info) {
+  DVLOG(2) << "OnGetPresentationReceiverSessionSuccess: "
+           << session_info.presentation_id;
+  if (presenter_session_callback_) {
+    presenter_session_callback_->Run(
+        presentation::PresentationSessionInfo::From(session_info));
+    presenter_session_callback_.reset();
+  }
+}
+
+void PresentationServiceImpl::OnGetPresentationReceiverSessionError(
+    const std::string& error) {
+  DVLOG(2) << __FUNCTION__ << ", error: " << error;
+  if (presenter_session_callback_) {
+    presenter_session_callback_->Run(
+        presentation::PresentationSessionInfoPtr());
+    presenter_session_callback_.reset();
+  }
+}
+
 void PresentationServiceImpl::OnSessionMessages(
     const PresentationSessionInfo& session,
     const ScopedVector<PresentationSessionMessage>& messages,
     bool pass_ownership) {
   DCHECK(client_);
 
   DVLOG(2) << "OnSessionMessages";
   mojo::Array<presentation::SessionMessagePtr> mojoMessages(messages.size());
   for (size_t i = 0; i < messages.size(); ++i)
     mojoMessages[i] = ToMojoSessionMessage(messages[i], pass_ownership);
@@ skipping 48 matching lines @@
   screen_availability_listeners_.clear();
   session_state_listeners_.clear();
 
   start_session_request_id_ = kInvalidRequestSessionId;
   pending_start_session_cb_.reset();
 
   pending_join_session_cbs_.clear();
 
   default_session_start_context_.reset();
 
-  if (on_session_messages_callback_.get()) {
+  if (on_session_messages_callback_) {
     on_session_messages_callback_->Run(
         mojo::Array<presentation::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();
   }
+
+  presenter_session_callback_.reset();
 }
 
 void PresentationServiceImpl::OnDelegateDestroyed() {
   DVLOG(2) << "PresentationServiceImpl::OnDelegateDestroyed";
   delegate_ = nullptr;
   Reset();
 }
 
 void PresentationServiceImpl::OnDefaultPresentationStarted(
     const PresentationSessionInfo& session) {
@@ skipping 102 matching lines @@
 
 void PresentationServiceImpl::DefaultSessionStartContext::Reset() {
   ScopedVector<DefaultSessionMojoCallback> callbacks;
   callbacks.swap(callbacks_);
   for (const auto& callback : callbacks)
     callback->Run(presentation::PresentationSessionInfoPtr());
   session_.reset();
 }
 
 }  // namespace content