Presentation API: implement .getAvailability() (Chromium side).

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 <algorithm>
 #include <vector>
 
 #include "base/logging.h"
 #include "content/common/presentation/presentation_service.mojom.h"
 #include "content/public/common/presentation_constants.h"
 #include "content/public/common/service_registry.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/renderer/presentation/presentation_session_client.h"
 #include "third_party/WebKit/public/platform/WebString.h"
+#include "third_party/WebKit/public/platform/modules/presentation/WebPresentationAvailabilityObserver.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationController.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationError.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "url/gurl.h"
 
 namespace {
 
 blink::WebPresentationError::ErrorType GetWebPresentationErrorTypeFromMojo(
     presentation::PresentationErrorType mojoErrorType) {
@@ skipping 46 matching lines @@
   return session_message;
 }
 
 }  // namespace
 
 namespace content {
 
 PresentationDispatcher::PresentationDispatcher(RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
       controller_(nullptr),
-      binding_(this) {
+      binding_(this),
+      listening_(ListeningState::Inactive),
+      previous_availability_(false) {
 }
 
 PresentationDispatcher::~PresentationDispatcher() {
   // Controller should be destroyed before the dispatcher when frame is
   // destroyed.
   DCHECK(!controller_);
 }
 
 void PresentationDispatcher::setController(
     blink::WebPresentationController* controller) {
@@ skipping 189 matching lines @@
 void PresentationDispatcher::closeSession(
     const blink::WebString& presentationUrl,
     const blink::WebString& presentationId) {
   ConnectToPresentationServiceIfNeeded();
 
   presentation_service_->CloseSession(
       presentationUrl.utf8(),
       presentationId.utf8());
 }
 
+void PresentationDispatcher::getAvailability(
+    const blink::WebString& presentationUrl,
+    blink::WebPresentationAvailabilityCallbacks* callbacks) {
+  if (listening_ == ListeningState::Active) {
+    callbacks->onSuccess(&previous_availability_);
+    delete callbacks;
+    return;
+  }
+
+  availability_callbacks_.Add(callbacks);
+  UpdateListeningState();
+}
+
+void PresentationDispatcher::startListening(
+    blink::WebPresentationAvailabilityObserver* observer) {
+    availability_observers_.insert(observer);
+    UpdateListeningState();
+}
+
+void PresentationDispatcher::stopListening(
+    blink::WebPresentationAvailabilityObserver* observer) {
+    availability_observers_.erase(observer);
+    UpdateListeningState();
+}
+
 void PresentationDispatcher::DidChangeDefaultPresentation() {
   GURL presentation_url(GetPresentationURLFromFrame(render_frame()));
 
   ConnectToPresentationServiceIfNeeded();
   presentation_service_->SetDefaultPresentationURL(
       presentation_url.spec(), mojo::String());
 }
 
 void PresentationDispatcher::DidCommitProvisionalLoad(
     bool is_new_navigation,
     bool is_same_page_navigation) {
   blink::WebFrame* frame = render_frame()->GetWebFrame();
   // If not top-level navigation.
   if (frame->parent() || is_same_page_navigation)
     return;
 
   // Remove all pending send message requests.
   MessageRequestQueue empty;
   std::swap(message_request_queue_, empty);
 }
 
 void PresentationDispatcher::OnScreenAvailabilityUpdated(bool available) {
-  if (controller_)
-    controller_->didChangeAvailability(available);
+  previous_availability_ = available;

[whywhat, 2015/07/02 22:42:48]

nit: check if the last known availability is different and only then fire
availabilityChanged() ?

[mlamouri (slow - plz ping), 2015/07/03 13:35:45]

This is being checked before sending the event. Probably not useful to do the
check twice.

+
+  for (auto observer : availability_observers_)
+    observer->availabilityChanged(available);
+
+  for (AvailabilityCallbacksMap::iterator iter(&availability_callbacks_);
+       !iter.IsAtEnd(); iter.Advance()) {
+    iter.GetCurrentValue()->onSuccess(&available);
+  }
+  availability_callbacks_.Clear();
+
+  UpdateListeningState();
 }
 
 void PresentationDispatcher::OnDefaultSessionStarted(
     presentation::PresentationSessionInfoPtr session_info) {
   if (!controller_)
     return;
 
   // Reset the callback to get the next event.
   presentation_service_->ListenForDefaultSessionStart(base::Bind(
       &PresentationDispatcher::OnDefaultSessionStarted,
@@ skipping 78 matching lines @@
       &PresentationDispatcher::OnDefaultSessionStarted,
       base::Unretained(this)));
 
   // TODO(imcheng): Uncomment this once it is implemented on the browser
   // side. (crbug.com/459006)
   // presentation_service_->ListenForSessionStateChange(base::Bind(
   //     &PresentationDispatcher::OnSessionStateChange,
   //     base::Unretained(this)));
 }
 
+void PresentationDispatcher::UpdateListeningState() {
+  bool should_listen = !availability_callbacks_.IsEmpty() ||
+                       !availability_observers_.empty();
+

[whywhat, 2015/07/02 22:42:48]

maybe something like this would be shorter and easier to follow?

bool is_listening = listening_state_ != ListeningState::Inactive;
if (should_listen == is_listening)
  return;

ConnectToPresentationServiceIfNeeded();
if (should_listen) {
  listening_state_ = ListeningState::Waiting;
  presentation_service_->ListenForScreenAvailability();
} else {
  listening_state_ = ListeningState::Inactive;
  presentation_service_->StopListeningForScreenAvailability();
}

If you only had two states (or a boolean) it would probably be even shorter.

[mlamouri (slow - plz ping), 2015/07/03 13:35:45]

Done.

+  if (!should_listen) {
+    if (listening_ == ListeningState::Inactive)
+      return;
+
+    listening_ = ListeningState::Inactive;
+    ConnectToPresentationServiceIfNeeded();
+    presentation_service_->StopListeningForScreenAvailability();
+    return;
+  }
+
+  // should_listen == true.
+  if (listening_ != ListeningState::Inactive)
+    return;
+
+  listening_ = ListeningState::Waiting;
+  ConnectToPresentationServiceIfNeeded();
+  presentation_service_->ListenForScreenAvailability();
+}
+
 }  // namespace content