third_party/WebKit/Source/core/streams/ReadableStreamReader.cpp - Issue 2227403002: Remove blink::ReadableStream

Side by Side Diff: third_party/WebKit/Source/core/streams/ReadableStreamReader.cpp

Issue 2227403002: Remove blink::ReadableStream (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: fix Created 4 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

« no previous file with comments | « third_party/WebKit/Source/core/streams/ReadableStreamReader.h ('k') | third_party/WebKit/Source/core/streams/ReadableStreamReader.idl » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
1 // Copyright 2015 The Chromium Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style license that can be

3 // found in the LICENSE file.

4

5 #include "core/streams/ReadableStreamReader.h"

6

7 #include "bindings/core/v8/ExceptionState.h"

8 #include "bindings/core/v8/ScriptPromiseResolver.h"

9 #include "bindings/core/v8/ToV8.h"

10 #include "bindings/core/v8/V8IteratorResultValue.h"

11 #include "core/dom/DOMException.h"

12 #include "core/dom/ExceptionCode.h"

13 #include "core/streams/ReadableStream.h"

14

15 namespace blink {

16

17 ReadableStreamReader::ReadableStreamReader(ExecutionContext* executionContext, R eadableStream* stream)

18 : ActiveScriptWrappable(this)

19 , ActiveDOMObject(executionContext)

20 , m_stream(stream)

21 , m_closed(new ClosedPromise(executionContext, this, ClosedPromise::Closed))

22 {

23 suspendIfNeeded();

24 ASSERT(m_stream->isLockedTo(nullptr));

25 m_stream->setReader(this);

26

27 if (m_stream->stateInternal() == ReadableStream::Closed)

28 m_closed->resolve(ToV8UndefinedGenerator());

29 if (m_stream->stateInternal() == ReadableStream::Errored)

30 m_closed->reject(m_stream->storedException());

31 }

32

33 ScriptPromise ReadableStreamReader::closed(ScriptState* scriptState)

34 {

35 return m_closed->promise(scriptState->world());

36 }

37

38 bool ReadableStreamReader::isActive() const

39 {

40 return m_stream->isLockedTo(this);

41 }

42

43 ScriptPromise ReadableStreamReader::cancel(ScriptState* scriptState)

44 {

45 return cancel(scriptState, ScriptValue(scriptState, v8::Undefined(scriptStat e->isolate())));

46 }

47

48 ScriptPromise ReadableStreamReader::cancel(ScriptState* scriptState, ScriptValue reason)

49 {

50 if (isActive())

51 return m_stream->cancelInternal(scriptState, reason);

52

53 return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError( scriptState->isolate(), "the reader is already released"));

54 }

55

56 ScriptPromise ReadableStreamReader::read(ScriptState* scriptState)

57 {

58 if (!isActive())

59 return ScriptPromise::reject(scriptState, V8ThrowException::createTypeEr ror(scriptState->isolate(), "the reader is already released"));

60

61 return m_stream->read(scriptState);

62 }

63

64 void ReadableStreamReader::releaseLock(ExceptionState& es)

65 {

66 if (!isActive())

67 return;

68 if (m_stream->hasPendingReads()) {

69 es.throwTypeError("The stream has pending read operations.");

70 return;

71 }

72

73 releaseLock();

74 }

75

76 void ReadableStreamReader::releaseLock()

77 {

78 if (!isActive())

79 return;

80

81 ASSERT(!m_stream->hasPendingReads());

82 if (m_stream->stateInternal() != ReadableStream::Readable)

83 m_closed->reset();

84 // Note: It is generally a bad idea to store world-dependent values

85 // (e.g. v8::Object) in a ScriptPromiseProperty, so we use DOMException

86 // though the spec says the promise should be rejected with a TypeError.

87 m_closed->reject(DOMException::create(AbortError, "the reader is already rel eased"));

88

89 // We call setReader(nullptr) after resolving / rejecting \|m_closed\|

90 // because it affects hasPendingActivity.

91 m_stream->setReader(nullptr);

92 ASSERT(!isActive());

93 }

94

95 void ReadableStreamReader::close()

96 {

97 ASSERT(isActive());

98 m_closed->resolve(ToV8UndefinedGenerator());

99 }

100

101 void ReadableStreamReader::error()

102 {

103 ASSERT(isActive());

104 m_closed->reject(m_stream->storedException());

105 }

106

107 bool ReadableStreamReader::hasPendingActivity() const

108 {

109 // We need to extend ReadableStreamReader's wrapper's life while it is

110 // active in order to call resolve / reject on ScriptPromiseProperties.

111 return isActive() && m_stream->stateInternal() == ReadableStream::Readable;

112 }

113

114 void ReadableStreamReader::stop()

115 {

116 if (isActive()) {

117 // Calling \|error\| will release the lock.

118 m_stream->error(DOMException::create(AbortError, "The frame stops workin g."));

119 }

120 ActiveDOMObject::stop();

121 }

122

123 DEFINE_TRACE(ReadableStreamReader)

124 {

125 visitor->trace(m_stream);

126 visitor->trace(m_closed);

127 ActiveDOMObject::trace(visitor);

128 }

129

130 } // namespace blink

OLD	NEW