MediaStream Image Capture (1): idl and wireframe .h/.cpp/LayoutTest

third_party/WebKit/Source/modules/imagecapture/ImageCapture.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/imagecapture/ImageCapture.h"
+
+#include "bindings/core/v8/ScriptPromiseResolver.h"
+#include "core/dom/DOMException.h"
+#include "core/dom/ExceptionCode.h"
+#include "modules/EventTargetModules.h"
+#include "modules/mediastream/MediaStreamTrack.h"
+#include "public/platform/Platform.h"
+
+namespace blink {
+
+ImageCapture* ImageCapture::create(ExecutionContext* context, MediaStreamTrack* track, ExceptionState& exceptionState)
+{
+    if (track->kind() != "video")
+        exceptionState.throwDOMException(NotSupportedError, "Cannot create an ImageCapturer from a non-video Track.");
+
+    ImageCapture* imageCapture = new ImageCapture(context, track);
+    imageCapture->suspendIfNeeded();
+    return imageCapture;
+}
+
+const AtomicString& ImageCapture::interfaceName() const
+{
+    return EventTargetNames::ImageCapture;
+}
+
+ExecutionContext* ImageCapture::getExecutionContext() const
+{
+    return ActiveDOMObject::getExecutionContext();
+}
+
+bool ImageCapture::hasPendingActivity() const
+{
+    if (!getExecutionContext() || getExecutionContext()->activeDOMObjectsAreStopped())

[haraken, 2016/04/19 23:50:56]

A better way to do this would be:

- Make ImageCapture inherit from ContextLifecycleObserver.
- Clear all event listeners in ContextLifecycleObserver::stop().
- hasPendingActivity() should just return hasEventListeners().

If you don't need to observe suspend/resume events, ImageCapture doesn't need to
be an ActiveDOMObject. ContextLifecycleObserver would be enough.

[mcasas, 2016/04/20 00:31:51]

Done, I think.

+        return false;
+
+    // Prevents garbage collecting of this object when not hold by another
+    // object but still has listeners registered.
+    return hasEventListeners();
+}
+
+ScriptPromise ImageCapture::grabFrame(ScriptState* scriptState, ExceptionState& exceptionState)
+{
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+
+    // Spec instructs to return an exception if the track's ready state is not "live". Also reject if the track is disabled or muted.
+    if (m_streamTrack->readyState() != "live" || !m_streamTrack->enabled() || m_streamTrack->muted()) {
+        resolver->reject(DOMException::create(InvalidStateError, "The associated Track is in an invalid state."));
+        return promise;
+    }
+
+    resolver->reject(DOMException::create(NotSupportedError, "Not implemented yet"));
+    return promise;
+}
+
+ImageCapture::ImageCapture(ExecutionContext* context, MediaStreamTrack* track)
+    : ActiveScriptWrappable(this)
+    , ActiveDOMObject(context)
+    , m_streamTrack(track)
+{
+    DCHECK(m_streamTrack);
+}
+
+bool ImageCapture::addEventListenerInternal(const AtomicString& eventType, EventListener* listener, const EventListenerOptions& options)
+{
+    return EventTarget::addEventListenerInternal(eventType, listener, options);
+}
+
+DEFINE_TRACE(ImageCapture)
+{
+    visitor->trace(m_streamTrack);
+    EventTargetWithInlineData::trace(visitor);
+    ActiveDOMObject::trace(visitor);
+}
+
+} // namespace blink