[Blink,RemotePlayback] Use PresentationController for availability

third_party/WebKit/Source/modules/remoteplayback/RemotePlayback.cpp

 // Copyright 2016 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 "modules/remoteplayback/RemotePlayback.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/modules/v8/RemotePlaybackAvailabilityCallback.h"
 #include "core/HTMLNames.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/dom/UserGestureIndicator.h"
 #include "core/events/Event.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/probe/CoreProbes.h"
 #include "modules/EventTargetModules.h"
+#include "modules/presentation/PresentationController.h"
 #include "modules/remoteplayback/AvailabilityCallbackWrapper.h"
 #include "platform/MemoryCoordinator.h"
+#include "platform/json/JSONValues.h"
+#include "platform/wtf/text/Base64.h"
 
 namespace blink {
 
 namespace {
 
 const AtomicString& RemotePlaybackStateToString(WebRemotePlaybackState state) {
   DEFINE_STATIC_LOCAL(const AtomicString, connecting_value, ("connecting"));
   DEFINE_STATIC_LOCAL(const AtomicString, connected_value, ("connected"));
   DEFINE_STATIC_LOCAL(const AtomicString, disconnected_value, ("disconnected"));
 
@@ skipping 21 matching lines @@
 // static
 RemotePlayback* RemotePlayback::Create(HTMLMediaElement& element) {
   return new RemotePlayback(element);
 }
 
 RemotePlayback::RemotePlayback(HTMLMediaElement& element)
     : state_(element.IsPlayingRemotely()
                  ? WebRemotePlaybackState::kConnected
                  : WebRemotePlaybackState::kDisconnected),
       availability_(WebRemotePlaybackAvailability::kUnknown),
-      media_element_(&element) {}
+      media_element_(&element),
+      is_listening_(false) {}
 
 const AtomicString& RemotePlayback::InterfaceName() const {
   return EventTargetNames::RemotePlayback;
 }
 
 ExecutionContext* RemotePlayback::GetExecutionContext() const {
   return &media_element_->GetDocument();
 }
 
 ScriptPromise RemotePlayback::watchAvailability(
@@ skipping 54 matching lines @@
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
   if (media_element_->FastHasAttribute(HTMLNames::disableremoteplaybackAttr)) {
     resolver->Reject(DOMException::Create(
         kInvalidStateError, "disableRemotePlayback attribute is present."));
     return promise;
   }
 
   availability_callbacks_.clear();
+  UpdateListeningState();
 
   resolver->Resolve();
   return promise;
 }
 
 ScriptPromise RemotePlayback::prompt(ScriptState* script_state) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
   if (media_element_->FastHasAttribute(HTMLNames::disableremoteplaybackAttr)) {
@@ skipping 16 matching lines @@
     return promise;
   }
 
   if (!RuntimeEnabledFeatures::remotePlaybackBackendEnabled() ||
       availability_ == WebRemotePlaybackAvailability::kDeviceNotAvailable) {
     resolver->Reject(DOMException::Create(kNotFoundError,
                                           "No remote playback devices found."));
     return promise;
   }
 
+  // TODO(avayvod): none of these two states is propagated with the new
+  // pipeline.

[mark a. foltz, 2017/05/31 21:16:41]

So kNotSupported error will not be thrown going forward?  I thought we had
figured out a way to map the enums returned by the PresentationService to meet
the needs of the Remote Playback API.

   if (availability_ == WebRemotePlaybackAvailability::kSourceNotSupported ||
       availability_ == WebRemotePlaybackAvailability::kSourceNotCompatible) {
     resolver->Reject(DOMException::Create(
         kNotSupportedError,
         "The currentSrc is not compatible with remote playback"));
     return promise;
   }
 
   prompt_promise_resolver_ = resolver;
   PromptInternal();
@@ skipping 33 matching lines @@
   // We can remove the wrapper if InspectorInstrumentation returns a task id.
   std::unique_ptr<WTF::Closure> task = WTF::Bind(
       &RemotePlayback::NotifyInitialAvailability, WrapPersistent(this), id);
   probe::AsyncTaskScheduled(GetExecutionContext(), "watchAvailabilityCallback",
                             task.get());
   TaskRunnerHelper::Get(TaskType::kMediaElementEvent, GetExecutionContext())
       ->PostTask(BLINK_FROM_HERE,
                  WTF::Bind(RunNotifyInitialAvailabilityTask,
                            WrapPersistent(GetExecutionContext()),
                            WTF::Passed(std::move(task))));
+
+  UpdateListeningState();
   return id;
 }
 
 bool RemotePlayback::CancelWatchAvailabilityInternal(int id) {
   auto iter = availability_callbacks_.find(id);
   if (iter == availability_callbacks_.end())
     return false;
   availability_callbacks_.erase(iter);
+  UpdateListeningState();
+
   return true;
 }
 
 void RemotePlayback::NotifyInitialAvailability(int callback_id) {
   // May not find the callback if the website cancels it fast enough.
   auto iter = availability_callbacks_.find(callback_id);
   if (iter == availability_callbacks_.end())
     return;
 
   iter->value->Run(this, RemotePlaybackAvailable());
@@ skipping 61 matching lines @@
 
 void RemotePlayback::PromptCancelled() {
   if (!prompt_promise_resolver_)
     return;
 
   prompt_promise_resolver_->Reject(
       DOMException::Create(kNotAllowedError, "The prompt was dismissed."));
   prompt_promise_resolver_ = nullptr;
 }
 
+void RemotePlayback::SourceChanged(const WebURL& source) {
+  DCHECK(RuntimeEnabledFeatures::newRemotePlaybackPipelineEnabled());
+
+  // If we're listening for the previous source, we should stop listening to

[mark a. foltz, 2017/05/31 21:16:41]

Do you want to restrict source URLs considered to file:, http:, https: ?

+  // update the source for the WebPresentationClient.
+  if (!availability_urls_.empty()) {
+    WebVector<WebURL> empty_urls;
+    availability_urls_.Swap(empty_urls);
+    UpdateListeningState();
+  }
+
+  // Ignore the new source if it's not meaningful.
+  if (!source.IsEmpty() && source.IsValid()) {
+    UpdateAvailabilityUrls(source);
+    UpdateListeningState();
+  }
+}
+
 bool RemotePlayback::RemotePlaybackAvailable() const {
   return availability_ == WebRemotePlaybackAvailability::kDeviceAvailable;
 }
 
 void RemotePlayback::RemotePlaybackDisabled() {
   if (prompt_promise_resolver_) {
     prompt_promise_resolver_->Reject(DOMException::Create(
         kInvalidStateError, "disableRemotePlayback attribute is present."));
     prompt_promise_resolver_ = nullptr;
   }
 
   availability_callbacks_.clear();
+  UpdateListeningState();
 
   if (state_ != WebRemotePlaybackState::kDisconnected)
     media_element_->RequestRemotePlaybackStop();
 }
 
+void RemotePlayback::AvailabilityChanged(bool availability) {
+  DCHECK(RuntimeEnabledFeatures::newRemotePlaybackPipelineEnabled());
+  AvailabilityChanged(availability
+                          ? WebRemotePlaybackAvailability::kDeviceAvailable
+                          : WebRemotePlaybackAvailability::kDeviceNotAvailable);
+}
+
+const WebVector<WebURL>& RemotePlayback::Urls() const {
+  DCHECK(RuntimeEnabledFeatures::newRemotePlaybackPipelineEnabled());
+  // TODO(avayvod): update the URL format and add frame url, mime type and
+  // response headers when available.
+  return availability_urls_;
+}
+
+void RemotePlayback::UpdateListeningState() {
+  if (!RuntimeEnabledFeatures::newRemotePlaybackPipelineEnabled())
+    return;
+
+  bool will_be_listening =
+      !availability_urls_.empty() && !availability_callbacks_.IsEmpty();
+  if (is_listening_ == will_be_listening)
+    return;
+
+  WebPresentationClient* client =
+      PresentationController::ClientFromContext(GetExecutionContext());
+  if (!client)
+    return;
+
+  if (will_be_listening) {
+    client->StartListening(this);
+  } else {
+    client->StopListening(this);
+  }
+  is_listening_ = will_be_listening;
+}
+
+void RemotePlayback::UpdateAvailabilityUrls(const WebURL& source) {
+  // The URL for each media element's source looks like the following:
+  // chrome-media-source://<encoded-data> where |encoded-data| is base64 URL
+  // encoded string representation of a JSON structure with various information
+  // about the media element's source that looks like this:
+  // {
+  //   "sourceUrl": "<sourceUrl>",
+  // }
+  // TODO(avayvod): add and fill more info to the JSON structure.

[mark a. foltz, 2017/05/31 21:16:41]

Can you explain why URL-encoding is not sufficient?  What is the "more info"
that will be required here?

+  std::unique_ptr<JSONObject> source_info = JSONObject::Create();
+  source_info->SetString("sourceUrl", source.GetString());
+  CString json_source_info = source_info->ToJSONString().Utf8();
+  String encoded_source_info =
+      WTF::Base64URLEncode(json_source_info.data(), json_source_info.length());
+
+  WebVector<WebURL> new_availability_urls((size_t)1);
+  new_availability_urls[0] =
+      KURL(kParsedURLString, "chrome-media-source://" + encoded_source_info);
+  availability_urls_.Swap(new_availability_urls);
+}
+
 DEFINE_TRACE(RemotePlayback) {
   visitor->Trace(availability_callbacks_);
   visitor->Trace(prompt_promise_resolver_);
   visitor->Trace(media_element_);
   EventTargetWithInlineData::Trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(RemotePlayback) {
   for (auto callback : availability_callbacks_.Values())
     visitor->TraceWrappers(callback);
   EventTargetWithInlineData::TraceWrappers(visitor);
 }
 
 }  // namespace blink