[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 74 matching lines @@
       return blink::WebPresentationConnectionCloseReason::Error;
     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;
   }
 }
-
 }  // namespace
 
 namespace content {
 
 PresentationDispatcher::PresentationDispatcher(RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
       controller_(nullptr),
       binding_(this) {
 }
 
@@ skipping 149 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::unique_ptr<blink::WebPresentationAvailabilityCallbacks> callback) {
+  DCHECK(!availabilityUrls.isEmpty());
+
+  std::vector<GURL> urls;
+  for (const auto& availability_url : availabilityUrls)
+    urls.push_back(availability_url);
+
+  auto screen_availability = GetScreenAvailability(urls);
+  // Reject Promise if screen availability is unsupported for all URLs.
+  if (screen_availability == ScreenAvailability::UNSUPPORTED) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &blink::WebPresentationAvailabilityCallbacks::onError,
+            base::Passed(&callback),
+            blink::WebPresentationError(
+                blink::WebPresentationError::ErrorTypeAvailabilityNotSupported,
+                "Screen availability monitoring not supported")));
+    // Do not listen to urls if we reject the promise.
+    return;
+  }
+
+  auto status_it =
+      std::find_if(availability_set_.begin(), availability_set_.end(),
+                   [&urls](const std::unique_ptr<AvailabilityStatus>& x) {
+                     return x->urls == urls;
+                   });
+
   AvailabilityStatus* status = nullptr;
-  auto status_it = availability_status_.find(availabilityUrl);
-  if (status_it == availability_status_.end()) {
-    status = new AvailabilityStatus(availabilityUrl);
-    availability_status_[availabilityUrl] = base::WrapUnique(status);
+  if (status_it == availability_set_.end()) {
+    status = new AvailabilityStatus(urls);
+    availability_set_.insert(base::WrapUnique(status));
   } else {
-    status = status_it->second.get();
+    status = status_it->get();
   }
-  DCHECK(status);
 
-  if (status->listening_state == ListeningState::ACTIVE) {
+  if (screen_availability != ScreenAvailability::UNKNOWN) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&blink::WebPresentationAvailabilityCallbacks::onSuccess,
-                   base::Passed(&callbacks), status->last_known_availability));
-    return;
+                   base::Passed(&callback),
+                   screen_availability == ScreenAvailability::AVAILABLE));
+  } else {
+    status->availability_callbacks.Add(std::move(callback));
   }
 
-  status->availability_callbacks.Add(std::move(callbacks));
-  UpdateListeningState(status);
+  for (const auto& availabilityUrl : urls)
+    StartListeningToURL(availabilityUrl);
 }
 
 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);
-  if (status_it == availability_status_.end()) {
-    DLOG(WARNING) << "Start listening for availability for unknown URL "
-                  << GURL(availabilityUrl);
+  std::vector<GURL> urls;
+  for (const auto& url : observer->urls())
+    urls.push_back(url);
+
+  auto status_it =

[mark a. foltz, 2017/01/13 19:06:32]

This is repeated a few times; add a private method to search for
AvailabilityStatus to avoid duplication.

[zhaobin, 2017/01/14 01:45:32]

Done.

+      std::find_if(availability_set_.begin(), availability_set_.end(),
+                   [&urls](const std::unique_ptr<AvailabilityStatus>& x) {
+                     return x->urls == urls;
+                   });
+
+  if (status_it == availability_set_.end()) {
+    DLOG(WARNING) << "Start listening for availability for unknown URLs.";
     return;
   }
-  status_it->second->availability_observers.insert(observer);
-  UpdateListeningState(status_it->second.get());
+
+  (*status_it)->availability_observers.insert(observer);
+  for (const auto& availabilityUrl : urls)
+    StartListeningToURL(availabilityUrl);
 }
 
 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);
-  if (status_it == availability_status_.end()) {
-    DLOG(WARNING) << "Stop listening for availability for unknown URL "
-                  << GURL(availabilityUrl);
+  std::vector<GURL> urls;
+  for (const auto& url : observer->urls())
+    urls.push_back(url);
+
+  auto status_it =
+      std::find_if(availability_set_.begin(), availability_set_.end(),
+                   [&urls](const std::unique_ptr<AvailabilityStatus>& x) {
+                     return x->urls == urls;
+                   });
+
+  if (status_it == availability_set_.end()) {
+    DLOG(WARNING) << "Stop listening for availability for unknown URLs.";
     return;
   }
-  status_it->second->availability_observers.erase(observer);
-  UpdateListeningState(status_it->second.get());
+
+  (*status_it)->availability_observers.erase(observer);
+
+  for (const auto& availabilityUrl : urls)
+    StopListeningToURL(availabilityUrl);
 }
 
 void PresentationDispatcher::setDefaultPresentationUrls(
     const blink::WebVector<blink::WebURL>& presentationUrls) {
   ConnectToPresentationServiceIfNeeded();
 
   std::vector<GURL> urls;
   for (const auto& url : presentationUrls)
     urls.push_back(url);
 
@@ skipping 18 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())
+  auto* listening_status = GetListeningStatus(url);
+  if (!listening_status)
     return;
-  AvailabilityStatus* status = status_it->second.get();
-  DCHECK(status);
 
-  if (status->listening_state == ListeningState::WAITING)
-    status->listening_state = ListeningState::ACTIVE;
+  if (listening_status->listening_state == ListeningState::WAITING)
+    listening_status->listening_state = ListeningState::ACTIVE;
 
-  for (auto* observer : status->availability_observers)
-    observer->availabilityChanged(available);
+  auto new_screen_availability = available ? ScreenAvailability::AVAILABLE
+                                           : ScreenAvailability::UNAVAILABLE;
+  if (listening_status->last_known_availability == new_screen_availability)
+    return;
 
-  for (AvailabilityCallbacksMap::iterator iter(&status->availability_callbacks);
-       !iter.IsAtEnd(); iter.Advance()) {
-    iter.GetCurrentValue()->onSuccess(available);
+  listening_status->last_known_availability = new_screen_availability;
+
+  for (auto& status : availability_set_) {
+    if (!base::ContainsValue(status->urls, url))
+      continue;
+    auto screen_availability = GetScreenAvailability(status->urls);
+    DCHECK(screen_availability == ScreenAvailability::AVAILABLE ||
+           screen_availability == ScreenAvailability::UNAVAILABLE);
+    bool is_available = (screen_availability == ScreenAvailability::AVAILABLE);
+
+    for (auto* observer : status->availability_observers)
+      observer->availabilityChanged(is_available);
+
+    for (AvailabilityCallbacksMap::iterator iter(
+             &status->availability_callbacks);
+         !iter.IsAtEnd(); iter.Advance()) {
+      iter.GetCurrentValue()->onSuccess(is_available);
+    }
+    status->availability_callbacks.Clear();
   }
-  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())
+  auto* listening_status = GetListeningStatus(url);
+  if (!listening_status)
     return;
-  AvailabilityStatus* status = status_it->second.get();
-  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));
+  if (listening_status->listening_state == ListeningState::WAITING)
+    listening_status->listening_state = ListeningState::ACTIVE;
+
+  if (listening_status->last_known_availability ==
+      ScreenAvailability::UNSUPPORTED)
+    return;
+
+  listening_status->last_known_availability = ScreenAvailability::UNSUPPORTED;
+
+  for (auto& status : availability_set_) {
+    if (!base::ContainsValue(status->urls, url))
+      continue;
+
+    // ScreenAvailabilityNotSupported should be a browser side setting, which
+    // means all urls in PresentationAvailability should report NotSupported.
+    // It is not possible to change listening status from Available or
+    // Unavailable to NotSupported. No need to update observer.
+    auto screen_availability = GetScreenAvailability(status->urls);
+    DCHECK_EQ(screen_availability, ScreenAvailability::UNSUPPORTED);
+
+    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));
+    }
+    status->availability_callbacks.Clear();
+
+    for (const auto& availability_url : status->urls)
+      StopListeningToURL(availability_url);
   }
-  status->availability_callbacks.Clear();
-  UpdateListeningState(status);
 }
 
 void PresentationDispatcher::OnDefaultSessionStarted(
     blink::mojom::PresentationSessionInfoPtr session_info) {
   if (!controller_)
     return;
 
   if (!session_info.is_null()) {
     presentation_service_->ListenForConnectionMessages(session_info.Clone());
     controller_->didStartDefaultSession(
@@ skipping 87 matching lines @@
 }
 
 void PresentationDispatcher::ConnectToPresentationServiceIfNeeded() {
   if (presentation_service_.get())
     return;
 
   render_frame()->GetRemoteInterfaces()->GetInterface(&presentation_service_);
   presentation_service_->SetClient(binding_.CreateInterfacePtrAndBind());
 }
 
-void PresentationDispatcher::UpdateListeningState(AvailabilityStatus* status) {
-  bool should_listen = !status->availability_callbacks.IsEmpty() ||
-                       !status->availability_observers.empty();
-  bool is_listening = status->listening_state != ListeningState::INACTIVE;
+void PresentationDispatcher::StartListeningToURL(const GURL& url) {
+  auto* listening_status = GetListeningStatus(url);
+  if (!listening_status) {
+    listening_status = new ListeningStatus(url);
+    listening_status_.insert(
+        std::make_pair(url, base::WrapUnique(listening_status)));
+  }
 
-  if (should_listen == is_listening)
+  // Already listening.
+  if (listening_status->listening_state != ListeningState::INACTIVE)
     return;
 
   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);
+  listening_status->listening_state = ListeningState::WAITING;
+  presentation_service_->ListenForScreenAvailability(url);
+}
+
+void PresentationDispatcher::StopListeningToURL(const GURL& url) {
+  for (const auto& status : availability_set_) {
+    if (!base::ContainsValue(status->urls, url))
+      continue;
+
+    // URL is still observed by some availability object.
+    if (!status->availability_callbacks.IsEmpty() ||
+        !status->availability_observers.empty())
+      return;
   }
+
+  auto* listening_status = GetListeningStatus(url);
+  DCHECK(listening_status);
+
+  if (listening_status->listening_state == ListeningState::INACTIVE)
+    return;
+
+  ConnectToPresentationServiceIfNeeded();
+  listening_status->listening_state = ListeningState::INACTIVE;
+  presentation_service_->StopListeningForScreenAvailability(url);
+}
+
+PresentationDispatcher::ListeningStatus*
+PresentationDispatcher::GetListeningStatus(const GURL& url) {
+  ListeningStatus* status = nullptr;
+  auto status_it = listening_status_.find(url);
+  if (status_it != listening_status_.end())
+    status = status_it->second.get();
+  return status;
+}
+
+PresentationDispatcher::ScreenAvailability
+PresentationDispatcher::GetScreenAvailability(const std::vector<GURL>& urls) {
+  std::map<ScreenAvailability, size_t> counters;
+
+  for (const auto& url : urls) {
+    if (!base::ContainsKey(listening_status_, url)) {
+      counters[ScreenAvailability::UNKNOWN]++;
+    } else {
+      auto url_availability = listening_status_[url]->last_known_availability;
+      counters[url_availability]++;
+    }
+  }
+
+  if (counters[ScreenAvailability::AVAILABLE] > 0)
+    return ScreenAvailability::AVAILABLE;
+  if (counters[ScreenAvailability::UNSUPPORTED] > 0)
+    return ScreenAvailability::UNSUPPORTED;
+  if (counters[ScreenAvailability::UNAVAILABLE] > 0)
+    return ScreenAvailability::UNAVAILABLE;
+
+  DCHECK_EQ(counters[ScreenAvailability::UNKNOWN], urls.size());
+  return ScreenAvailability::UNKNOWN;
 }
 
 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
@@ skipping 30 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 std::vector<GURL>& availability_urls)
+    : urls(availability_urls) {}
+
+PresentationDispatcher::AvailabilityStatus::~AvailabilityStatus() {}
+
+PresentationDispatcher::ListeningStatus::ListeningStatus(
     const GURL& availability_url)
     : url(availability_url),
-      last_known_availability(false),
+      last_known_availability(ScreenAvailability::UNKNOWN),
       listening_state(ListeningState::INACTIVE) {}
 
-PresentationDispatcher::AvailabilityStatus::~AvailabilityStatus() {
-}
+PresentationDispatcher::ListeningStatus::~ListeningStatus() {}
 
 }  // namespace content