[Presentation API] Handle multiple Presentation URLs in PresentationRequest::getAvailability()

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 <string>
 #include <utility>
 #include <vector>
 
@@ skipping 58 matching lines @@
     case blink::mojom::PresentationConnectionCloseReason::CLOSED:
       return blink::WebPresentationConnectionCloseReason::Closed;
     case blink::mojom::PresentationConnectionCloseReason::WENT_AWAY:
       return blink::WebPresentationConnectionCloseReason::WentAway;
     default:
       NOTREACHED();
       return blink::WebPresentationConnectionCloseReason::Error;
   }
 }
 
+constexpr char k_not_supported_error[] =
+    "getAvailability() isn't supported at the moment. It can be due to "

[mark a. foltz, 2016/12/23 01:04:22]

kNotSupportedError per style guide

[zhaobin, 2016/12/29 18:48:38]

Code removed.

+    "a permanent or temporary system limitation. It is recommended to "
+    "try to blindly start a session in that case.";

[mark a. foltz, 2016/12/23 01:04:22]

I would keep this simple:
 
Screen availability monitoring not supported

[zhaobin, 2016/12/29 18:48:38]

Code removed.

 }  // namespace
 
 namespace content {
 
 PresentationDispatcher::PresentationDispatcher(RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
       controller_(nullptr),
       binding_(this) {
 }
 
@@ skipping 150 matching lines @@
 void PresentationDispatcher::terminateSession(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId) {
   ConnectToPresentationServiceIfNeeded();
   presentation_service_->Terminate(presentationUrl, presentationId.utf8());
 }
 
 void PresentationDispatcher::getAvailability(
     const blink::WebVector<blink::WebURL>& availabilityUrls,
     std::unique_ptr<blink::WebPresentationAvailabilityCallbacks> callbacks) {
-  // TODO(mfoltz): Pass all URLs to PresentationService. See crbug.com/627655.
-  const blink::WebURL& availabilityUrl = availabilityUrls[0];
+  std::vector<GURL> urls;
+  for (const auto& url : availabilityUrls)
+    urls.push_back(url);
+
   AvailabilityStatus* status = nullptr;
-  auto status_it = availability_status_.find(availabilityUrl);
+  auto status_it = availability_status_.find(urls);
   if (status_it == availability_status_.end()) {
-    status = new AvailabilityStatus(availabilityUrl);
-    availability_status_[availabilityUrl] = base::WrapUnique(status);
+    status = new AvailabilityStatus(urls);
+    availability_status_[urls] = base::WrapUnique(status);

[mark a. foltz, 2016/12/23 01:04:22]

Would it be simpler to continue tracking status for individual URLs and remember
which callbacks/observers are interested in which URLs?

The underlying PresentationService API to get availability information uses
individual URLs, so it would make processing updates from it simpler.

The downside is that you would need to map a status change to pending callbacks
and observers.  But I have a hunch that would be simpler overall (by having
cleanly separate availability state and observer state).

What do you think?

[zhaobin, 2016/12/29 18:48:38]

Done.

   } else {
     status = status_it->second.get();
   }
   DCHECK(status);
 
-  if (status->listening_state == ListeningState::ACTIVE) {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::Bind(&blink::WebPresentationAvailabilityCallbacks::onSuccess,
-                   base::Passed(&callbacks), status->last_known_availability));
-    return;
+  auto presentation_error = blink::WebPresentationError(
+      blink::WebPresentationError::ErrorTypeAvailabilityNotSupported,
+      blink::WebString::fromUTF8(k_not_supported_error));
+
+  auto request_availability = GetRequestAvailability(urls);
+
+  switch (request_availability) {
+    case ScreenAvailability::UNKNOWN:
+      status->availability_callbacks.Add(std::move(callbacks));
+      UpdateListeningState(status);
+      break;
+    case ScreenAvailability::UNSUPPORTED:
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE,
+          base::Bind(&blink::WebPresentationAvailabilityCallbacks::onError,
+                     base::Passed(&callbacks), presentation_error));
+      break;
+    case ScreenAvailability::AVAILABLE:
+    case ScreenAvailability::UNAVAILABLE:
+      bool is_available = request_availability == ScreenAvailability::AVAILABLE;
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE,
+          base::Bind(&blink::WebPresentationAvailabilityCallbacks::onSuccess,
+                     base::Passed(&callbacks), is_available));
+      break;
   }
-
-  status->availability_callbacks.Add(std::move(callbacks));
-  UpdateListeningState(status);
 }
 
 void PresentationDispatcher::startListening(
     blink::WebPresentationAvailabilityObserver* observer) {
-  // TODO(mfoltz): Pass all URLs to PresentationService. See crbug.com/627655.
-  const blink::WebURL& availabilityUrl = observer->urls()[0];
-  auto status_it = availability_status_.find(availabilityUrl);
+  std::vector<GURL> urls;
+  for (const auto& url : observer->urls())
+    urls.push_back(url);
+
+  auto status_it = availability_status_.find(urls);
   if (status_it == availability_status_.end()) {
-    DLOG(WARNING) << "Start listening for availability for unknown URL "
-                  << GURL(availabilityUrl);
+    DLOG(WARNING) << "Start listening for availability for unknown URLs:";
+    for (const auto& url : urls)
+      DLOG(WARNING) << " " << url;
     return;
   }
   status_it->second->availability_observers.insert(observer);
   UpdateListeningState(status_it->second.get());
 }
 
 void PresentationDispatcher::stopListening(
     blink::WebPresentationAvailabilityObserver* observer) {
-  // TODO(mfoltz): Pass all URLs to PresentationService. See crbug.com/627655.
-  const blink::WebURL& availabilityUrl = observer->urls()[0];
-  auto status_it = availability_status_.find(availabilityUrl);
+  std::vector<GURL> urls;
+  for (const auto& url : observer->urls())
+    urls.push_back(url);
+
+  auto status_it = availability_status_.find(urls);
   if (status_it == availability_status_.end()) {
-    DLOG(WARNING) << "Stop listening for availability for unknown URL "
-                  << GURL(availabilityUrl);
+    DLOG(WARNING) << "Stop listening for availability for unknown URLs: ";
+    for (const auto& url : urls)
+      DLOG(WARNING) << " " << url;
     return;
   }
   status_it->second->availability_observers.erase(observer);
   UpdateListeningState(status_it->second.get());
 }
 
 void PresentationDispatcher::setDefaultPresentationUrls(
     const blink::WebVector<blink::WebURL>& presentationUrls) {
   ConnectToPresentationServiceIfNeeded();
 
@@ skipping 22 matching lines @@
   MessageRequestQueue empty;
   std::swap(message_request_queue_, empty);
 }
 
 void PresentationDispatcher::OnDestruct() {
   delete this;
 }
 
 void PresentationDispatcher::OnScreenAvailabilityUpdated(const GURL& url,
                                                          bool available) {
-  auto status_it = availability_status_.find(url);
-  if (status_it == availability_status_.end())
-    return;
-  AvailabilityStatus* status = status_it->second.get();
+  OnScreenAvailabilityUpdated(url, available ? ScreenAvailability::AVAILABLE
+                                             : ScreenAvailability::UNAVAILABLE);
+}
+
+void PresentationDispatcher::OnScreenAvailabilityNotSupported(const GURL& url) {
+  OnScreenAvailabilityUpdated(url, ScreenAvailability::UNSUPPORTED);
+}
+
+void PresentationDispatcher::OnScreenAvailabilityUpdated(
+    const GURL& url,
+    ScreenAvailability screen_availability) {
+  DCHECK(base::ContainsKey(url_listening_state_, url));
+
+  if (url_listening_state_[url] == ListeningState::WAITING)
+    url_listening_state_[url] = ListeningState::ACTIVE;
+
+  screen_availability_[url] = screen_availability;
+
+  for (auto& status_it : availability_status_) {
+    if (!base::ContainsValue(status_it.first, url))
+      continue;
+
+    auto request_availability = GetRequestAvailability(status_it.first);
+    switch (request_availability) {
+      case ScreenAvailability::UNKNOWN:
+        break;
+      case ScreenAvailability::UNSUPPORTED:
+        OnScreenAvailabilityNotSupported(status_it.second.get());
+        break;
+      case ScreenAvailability::AVAILABLE:
+      case ScreenAvailability::UNAVAILABLE:
+        OnScreenAvailabilityUpdated(
+            status_it.second.get(),
+            (request_availability == ScreenAvailability::AVAILABLE));
+        break;
+    }
+  }
+}
+
+void PresentationDispatcher::OnScreenAvailabilityUpdated(
+    AvailabilityStatus* status,
+    bool available) {
   DCHECK(status);
 
-  if (status->listening_state == ListeningState::WAITING)
-    status->listening_state = ListeningState::ACTIVE;
-
   for (auto* observer : status->availability_observers)
     observer->availabilityChanged(available);
 
   for (AvailabilityCallbacksMap::iterator iter(&status->availability_callbacks);
-       !iter.IsAtEnd(); iter.Advance()) {
+       !iter.IsAtEnd(); iter.Advance())
     iter.GetCurrentValue()->onSuccess(available);
-  }
-  status->last_known_availability = available;
+
   status->availability_callbacks.Clear();
   UpdateListeningState(status);
 }
 
-void PresentationDispatcher::OnScreenAvailabilityNotSupported(const GURL& url) {
-  auto status_it = availability_status_.find(url);
-  if (status_it == availability_status_.end())
-    return;
-  AvailabilityStatus* status = status_it->second.get();
+void PresentationDispatcher::OnScreenAvailabilityNotSupported(
+    AvailabilityStatus* status) {
   DCHECK(status);
-  DCHECK(status->listening_state == ListeningState::WAITING);
 
-  const blink::WebString& not_supported_error = blink::WebString::fromUTF8(
-      "getAvailability() isn't supported at the moment. It can be due to "
-      "a permanent or temporary system limitation. It is recommended to "
-      "try to blindly start a session in that case.");
   for (AvailabilityCallbacksMap::iterator iter(&status->availability_callbacks);
        !iter.IsAtEnd(); iter.Advance()) {
     iter.GetCurrentValue()->onError(blink::WebPresentationError(
         blink::WebPresentationError::ErrorTypeAvailabilityNotSupported,
-        not_supported_error));
+        blink::WebString::fromUTF8(k_not_supported_error)));
   }
   status->availability_callbacks.Clear();
   UpdateListeningState(status);
 }
 
 void PresentationDispatcher::OnDefaultSessionStarted(
     blink::mojom::PresentationSessionInfoPtr session_info) {
   if (!controller_)
     return;
 
@@ skipping 92 matching lines @@
 }
 
 void PresentationDispatcher::ConnectToPresentationServiceIfNeeded() {
   if (presentation_service_.get())
     return;
 
   render_frame()->GetRemoteInterfaces()->GetInterface(&presentation_service_);
   presentation_service_->SetClient(binding_.CreateInterfacePtrAndBind());
 }
 
+void PresentationDispatcher::SetPresentationServiceForTest(
+    blink::mojom::PresentationServicePtr presentation_service) {
+  presentation_service_ = std::move(presentation_service);
+}
+
 void PresentationDispatcher::UpdateListeningState(AvailabilityStatus* status) {
-  bool should_listen = !status->availability_callbacks.IsEmpty() ||
-                       !status->availability_observers.empty();
-  bool is_listening = status->listening_state != ListeningState::INACTIVE;
+  // Calculate if we should listen to status->urls.
+  std::map<GURL, bool> url_should_listen;
+  for (const auto& it : availability_status_) {
+    bool should_listen = !it.second->availability_callbacks.IsEmpty() ||
+                         !it.second->availability_observers.empty();
 
-  if (should_listen == is_listening)
-    return;
+    for (const auto& url : it.first) {
+      if (base::ContainsValue(status->urls, url))
+        url_should_listen[url] = url_should_listen[url] || should_listen;
+    }
+  }
 
   ConnectToPresentationServiceIfNeeded();
-  if (should_listen) {
-    status->listening_state = ListeningState::WAITING;
-    presentation_service_->ListenForScreenAvailability(status->url);
-  } else {
-    status->listening_state = ListeningState::INACTIVE;
-    presentation_service_->StopListeningForScreenAvailability(status->url);
+
+  for (const auto& url : status->urls) {
+    bool is_listening = false;
+    if (base::ContainsKey(url_listening_state_, url))
+      is_listening = url_listening_state_[url] != ListeningState::INACTIVE;
+
+    bool should_listen = url_should_listen[url];
+
+    if (should_listen == is_listening)
+      continue;
+
+    if (should_listen) {
+      url_listening_state_[url] = ListeningState::WAITING;
+      presentation_service_->ListenForScreenAvailability(url);
+    } else {
+      url_listening_state_[url] = ListeningState::INACTIVE;
+      presentation_service_->StopListeningForScreenAvailability(url);
+    }
   }
 }
 
+PresentationDispatcher::ScreenAvailability
+PresentationDispatcher::GetRequestAvailability(const std::vector<GURL>& urls) {
+  size_t available_cnt = 0;
+  size_t unavailable_cnt = 0;
+  size_t unsupport_cnt = 0;
+
+  for (const auto& url : urls) {
+    if (!base::ContainsKey(screen_availability_, url))
+      return ScreenAvailability::UNKNOWN;
+
+    auto url_availability = screen_availability_[url];
+    switch (url_availability) {
+      case ScreenAvailability::AVAILABLE:
+        available_cnt++;
+        break;
+      case ScreenAvailability::UNAVAILABLE:
+        unavailable_cnt++;
+        break;
+      case ScreenAvailability::UNSUPPORTED:
+        unsupport_cnt++;
+        break;
+      case ScreenAvailability::UNKNOWN:
+        break;
+    }
+  }
+
+  if (available_cnt > 0)
+    return ScreenAvailability::AVAILABLE;
+  if (unavailable_cnt > 0)
+    return ScreenAvailability::UNAVAILABLE;
+
+  DCHECK(unsupport_cnt == urls.size());
+  return ScreenAvailability::UNSUPPORTED;
+}
+
 PresentationDispatcher::SendMessageRequest::SendMessageRequest(
     blink::mojom::PresentationSessionInfoPtr session_info,
     blink::mojom::ConnectionMessagePtr message)
     : session_info(std::move(session_info)), message(std::move(message)) {}
 
 PresentationDispatcher::SendMessageRequest::~SendMessageRequest() {}
 
 // static
 PresentationDispatcher::SendMessageRequest*
 PresentationDispatcher::CreateSendTextMessageRequest(
@@ skipping 28 matching lines @@
 
   blink::mojom::ConnectionMessagePtr session_message =
       blink::mojom::ConnectionMessage::New();
   session_message->type = type;
   session_message->data = std::vector<uint8_t>(data, data + length);
   return new SendMessageRequest(std::move(session_info),
                                 std::move(session_message));
 }
 
 PresentationDispatcher::AvailabilityStatus::AvailabilityStatus(
-    const GURL& availability_url)
-    : url(availability_url),
-      last_known_availability(false),
-      listening_state(ListeningState::INACTIVE) {}
+    const std::vector<GURL>& availability_urls)
+    : urls(availability_urls) {}
 
 PresentationDispatcher::AvailabilityStatus::~AvailabilityStatus() {
 }
 
 }  // namespace content