[RemotePlayback] No monitoring on low-end devices

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/ExecutionContextTask.h"
 #include "core/events/Event.h"
 #include "core/html/HTMLMediaElement.h"
 #include "modules/EventTargetModules.h"
 #include "platform/UserGestureIndicator.h"
+#include "platform/heap/Heap.h"
 
 namespace blink {
 
 namespace {
 
 const AtomicString& remotePlaybackStateToString(WebRemotePlaybackState state) {
   DEFINE_STATIC_LOCAL(const AtomicString, connectingValue, ("connecting"));
   DEFINE_STATIC_LOCAL(const AtomicString, connectedValue, ("connected"));
   DEFINE_STATIC_LOCAL(const AtomicString, disconnectedValue, ("disconnected"));
 
@@ skipping 25 matching lines @@
 }
 
 RemotePlayback::RemotePlayback(ScriptState* scriptState,
                                HTMLMediaElement& element)
     : ActiveScriptWrappable(this),
       m_scriptState(scriptState),
       m_state(element.isPlayingRemotely()
                   ? WebRemotePlaybackState::Connected
                   : WebRemotePlaybackState::Disconnected),
       m_availability(element.hasRemoteRoutes()),
-      m_mediaElement(&element) {}
+      m_mediaElement(&element),
+      m_isLowEndDevice(ProcessHeap::isLowEndDevice()) {}
 
 const AtomicString& RemotePlayback::interfaceName() const {
   return EventTargetNames::RemotePlayback;
 }
 
 ExecutionContext* RemotePlayback::getExecutionContext() const {
   return &m_mediaElement->document();
 }
 
 ScriptPromise RemotePlayback::watchAvailability(
     RemotePlaybackAvailabilityCallback* callback) {
   ScriptPromiseResolver* resolver =
       ScriptPromiseResolver::create(m_scriptState.get());
   ScriptPromise promise = resolver->promise();
 
   if (m_mediaElement->fastHasAttribute(HTMLNames::disableremoteplaybackAttr)) {
     resolver->reject(DOMException::create(
         InvalidStateError, "disableRemotePlayback attribute is present."));
     return promise;
   }
 
-  // TODO(avayvod): implement steps 4 and 5 of the algorithm.
-  // https://crbug.com/655233
+  if (m_isLowEndDevice) {
+    resolver->reject(DOMException::create(
+        NotSupportedError,
+        "Availability monitoring is not supported on this device."));
+    return promise;
+  }
+
   int id;
   do {
     id = getExecutionContext()->circularSequentialID();
   } while (!m_availabilityCallbacks
                 .add(id, TraceWrapperMember<RemotePlaybackAvailabilityCallback>(
                              this, callback))
                 .isNewEntry);
 
   // Report the current availability via the callback.
   getExecutionContext()->postTask(
@@ skipping 191 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(RemotePlayback) {
   for (auto callback : m_availabilityCallbacks.values()) {
     visitor->traceWrappers(callback);
   }
   EventTargetWithInlineData::traceWrappers(visitor);
 }
 
 }  // namespace blink