OLD | NEW |
---|---|
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "config.h" | 5 #include "config.h" |
6 #include "core/streams/ReadableStreamReader.h" | 6 #include "core/streams/ReadableStreamReader.h" |
7 | 7 |
8 #include "bindings/core/v8/ExceptionState.h" | 8 #include "bindings/core/v8/ExceptionState.h" |
9 #include "bindings/core/v8/ScriptFunction.h" | 9 #include "bindings/core/v8/V8IteratorResultValue.h" |
10 #include "bindings/core/v8/ScriptPromiseResolver.h" | |
11 #include "core/dom/DOMException.h" | 10 #include "core/dom/DOMException.h" |
12 #include "core/streams/ReadableStream.h" | 11 #include "core/streams/ReadableStream.h" |
13 | 12 |
14 namespace blink { | 13 namespace blink { |
15 | 14 |
16 namespace { | |
17 | |
18 class PromiseRaceFulfillHandler : public ScriptFunction { | |
19 public: | |
20 static v8::Handle<v8::Function> create(PassRefPtrWillBeRawPtr<ScriptPromiseR esolver> resolver) | |
21 { | |
22 return (new PromiseRaceFulfillHandler(resolver))->bindToV8Function(); | |
23 } | |
24 | |
25 DEFINE_INLINE_TRACE() | |
26 { | |
27 visitor->trace(m_resolver); | |
28 ScriptFunction::trace(visitor); | |
29 } | |
30 | |
31 private: | |
32 explicit PromiseRaceFulfillHandler(PassRefPtrWillBeRawPtr<ScriptPromiseResol ver> resolver) | |
33 : ScriptFunction(resolver->scriptState()) | |
34 , m_resolver(resolver) { } | |
35 ScriptValue call(ScriptValue value) override | |
36 { | |
37 m_resolver->resolve(value); | |
38 return ScriptValue(scriptState(), v8::Undefined(scriptState()->isolate() )); | |
39 } | |
40 | |
41 RefPtrWillBeMember<ScriptPromiseResolver> m_resolver; | |
42 }; | |
43 | |
44 class PromiseRaceRejectHandler : public ScriptFunction { | |
45 public: | |
46 static v8::Handle<v8::Function> create(PassRefPtrWillBeRawPtr<ScriptPromiseR esolver> resolver) | |
47 { | |
48 return (new PromiseRaceRejectHandler(resolver))->bindToV8Function(); | |
49 } | |
50 | |
51 DEFINE_INLINE_TRACE() | |
52 { | |
53 visitor->trace(m_resolver); | |
54 ScriptFunction::trace(visitor); | |
55 } | |
56 | |
57 private: | |
58 explicit PromiseRaceRejectHandler(PassRefPtrWillBeRawPtr<ScriptPromiseResolv er> resolver) | |
59 : ScriptFunction(resolver->scriptState()) | |
60 , m_resolver(resolver) { } | |
61 ScriptValue call(ScriptValue value) override | |
62 { | |
63 m_resolver->reject(value); | |
64 return ScriptValue(scriptState(), v8::Undefined(scriptState()->isolate() )); | |
65 } | |
66 | |
67 RefPtrWillBeMember<ScriptPromiseResolver> m_resolver; | |
68 }; | |
69 | |
70 ScriptPromise race(ScriptState* scriptState, const Vector<ScriptPromise>& promis es) | |
71 { | |
72 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | |
73 for (ScriptPromise promise : promises) { | |
74 promise.then(PromiseRaceFulfillHandler::create(resolver), PromiseRaceRej ectHandler::create(resolver)); | |
75 } | |
76 return resolver->promise(); | |
77 } | |
78 | |
79 } // namespace | |
80 | |
81 ReadableStreamReader::ReadableStreamReader(ReadableStream* stream) | 15 ReadableStreamReader::ReadableStreamReader(ReadableStream* stream) |
82 : ActiveDOMObject(stream->executionContext()) | 16 : ActiveDOMObject(stream->executionContext()) |
83 , m_stream(stream) | 17 , m_stream(stream) |
84 , m_released(new ReleasedPromise(stream->executionContext(), this, ReleasedP romise::Released)) | |
85 , m_stateAfterRelease(ReadableStream::Closed) | 18 , m_stateAfterRelease(ReadableStream::Closed) |
19 , m_closed(new ClosedPromise(stream->executionContext(), this, ClosedPromise ::Closed)) | |
86 { | 20 { |
87 suspendIfNeeded(); | 21 suspendIfNeeded(); |
88 ASSERT(m_stream->isLockedTo(nullptr)); | 22 ASSERT(m_stream->isLockedTo(nullptr)); |
89 m_stream->setReader(this); | 23 m_stream->setReader(this); |
24 | |
25 if (m_stream->stateInternal() == ReadableStream::Closed || m_stream->stateIn ternal() == ReadableStream::Errored) { | |
26 // If the stream is already closed or errored the created reader | |
27 // should be closed or errored respectively. | |
28 releaseLock(); | |
29 } | |
90 } | 30 } |
91 | 31 |
92 ScriptPromise ReadableStreamReader::closed(ScriptState* scriptState) | 32 ScriptPromise ReadableStreamReader::closed(ScriptState* scriptState) |
93 { | 33 { |
94 if (isActive()) { | 34 return m_closed->promise(scriptState->world()); |
95 Vector<ScriptPromise> promises; | |
96 promises.append(m_stream->closed(scriptState)); | |
97 promises.append(m_released->promise(scriptState->world())); | |
98 return race(scriptState, promises); | |
99 } | |
100 ASSERT(m_released); | |
101 return m_closedAfterRelease->promise(scriptState->world()); | |
102 } | 35 } |
103 | 36 |
104 bool ReadableStreamReader::isActive() const | 37 bool ReadableStreamReader::isActive() const |
105 { | 38 { |
106 return m_stream->isLockedTo(this); | 39 return m_stream->isLockedTo(this); |
107 } | 40 } |
108 | 41 |
109 ScriptPromise ReadableStreamReader::ready(ScriptState* scriptState) | |
110 { | |
111 if (isActive()) { | |
112 Vector<ScriptPromise> promises; | |
113 promises.append(m_stream->readyInternal(scriptState)); | |
114 promises.append(m_released->promise(scriptState->world())); | |
115 return race(scriptState, promises); | |
116 } | |
117 ASSERT(m_readyAfterRelease); | |
118 return m_readyAfterRelease->promise(scriptState->world()); | |
119 } | |
120 | |
121 String ReadableStreamReader::state() const | |
122 { | |
123 if (isActive()) | |
124 return ReadableStream::stateToString(m_stream->stateInternal()); | |
125 return ReadableStream::stateToString(m_stateAfterRelease); | |
126 } | |
127 | |
128 ScriptPromise ReadableStreamReader::cancel(ScriptState* scriptState, ScriptValue reason) | 42 ScriptPromise ReadableStreamReader::cancel(ScriptState* scriptState, ScriptValue reason) |
129 { | 43 { |
130 if (isActive()) { | 44 if (isActive()) { |
131 releaseLock(); | 45 releaseLock(); |
132 return m_stream->cancel(scriptState, reason); | 46 return m_stream->cancel(scriptState, reason); |
133 } | 47 } |
134 return m_closedAfterRelease->promise(scriptState->world()); | 48 return closed(scriptState); |
tyoshino (SeeGerritForStatus)
2015/03/18 07:10:50
https://streams.spec.whatwg.org/branch-snapshots/a
yhirano
2015/03/18 08:07:49
Done.
yhirano
2015/03/18 14:03:23
Oh, sorry, I forgot that ScriptPromise.cast(promis
yhirano
2015/03/19 01:36:12
Done.
| |
135 } | 49 } |
136 | 50 |
137 ScriptValue ReadableStreamReader::read(ScriptState* scriptState, ExceptionState& es) | 51 ScriptPromise ReadableStreamReader::read(ScriptState* scriptState) |
138 { | 52 { |
139 if (!isActive()) { | 53 if (!isActive()) { |
140 es.throwTypeError("The stream is not locked to this reader"); | 54 ASSERT(m_stateAfterRelease == ReadableStream::Closed || m_stateAfterRele ase == ReadableStream::Errored); |
141 return ScriptValue(); | 55 if (m_stateAfterRelease == ReadableStream::Closed) { |
56 // {value: undefined, done: true} | |
57 return ScriptPromise::cast(scriptState, v8IteratorResultDone(scriptS tate)); | |
58 } | |
59 return closed(scriptState); | |
tyoshino (SeeGerritForStatus)
2015/03/18 07:10:50
ditto
yhirano
2015/03/18 08:07:49
Done.
| |
142 } | 60 } |
143 return m_stream->readInternal(scriptState, es); | 61 |
62 return m_stream->read(scriptState); | |
63 } | |
64 | |
65 void ReadableStreamReader::releaseLock(ExceptionState& es) | |
66 { | |
67 if (!isActive()) | |
68 return; | |
69 if (m_stream->hasPendingReads()) { | |
70 es.throwTypeError("The stream has pending read operations."); | |
71 return; | |
72 } | |
73 | |
74 releaseLock(); | |
144 } | 75 } |
145 | 76 |
146 void ReadableStreamReader::releaseLock() | 77 void ReadableStreamReader::releaseLock() |
147 { | 78 { |
148 if (!isActive()) | 79 if (!isActive()) |
149 return; | 80 return; |
150 | 81 |
151 m_stream->setReader(nullptr); | 82 ASSERT(!m_stream->hasPendingReads()); |
152 | |
153 m_readyAfterRelease = new ReadyPromise(executionContext(), this, ReadyPromis e::Ready); | |
154 m_readyAfterRelease->resolve(ToV8UndefinedGenerator()); | |
155 m_closedAfterRelease = new ClosedPromise(executionContext(), this, ReadyProm ise::Closed); | |
156 | |
157 if (m_stream->stateInternal() == ReadableStream::Closed) { | 83 if (m_stream->stateInternal() == ReadableStream::Closed) { |
158 m_stateAfterRelease = ReadableStream::Closed; | 84 m_stateAfterRelease = ReadableStream::Closed; |
159 m_closedAfterRelease->resolve(ToV8UndefinedGenerator()); | 85 m_closed->resolve(ToV8UndefinedGenerator()); |
160 } else if (m_stream->stateInternal() == ReadableStream::Errored) { | 86 } else if (m_stream->stateInternal() == ReadableStream::Errored) { |
161 m_stateAfterRelease = ReadableStream::Errored; | 87 m_stateAfterRelease = ReadableStream::Errored; |
162 m_closedAfterRelease->reject(m_stream->storedException()); | 88 m_closed->reject(m_stream->storedException()); |
163 } else { | 89 } else { |
164 m_stateAfterRelease = ReadableStream::Closed; | 90 m_stateAfterRelease = ReadableStream::Closed; |
165 m_closedAfterRelease->resolve(ToV8UndefinedGenerator()); | 91 m_closed->resolve(ToV8UndefinedGenerator()); |
166 } | 92 } |
167 m_released->resolve(ToV8UndefinedGenerator()); | 93 |
94 // We call setReader(nullptr) after resolving / rejecting |m_closed| | |
95 // because it affects hasPendingActivity. | |
96 m_stream->setReader(nullptr); | |
168 ASSERT(!isActive()); | 97 ASSERT(!isActive()); |
169 } | 98 } |
170 | 99 |
171 ScriptPromise ReadableStreamReader::released(ScriptState* scriptState) | |
172 { | |
173 return m_released->promise(scriptState->world()); | |
174 } | |
175 | |
176 bool ReadableStreamReader::hasPendingActivity() const | 100 bool ReadableStreamReader::hasPendingActivity() const |
177 { | 101 { |
178 // We need to extend ReadableStreamReader's wrapper's life while it is | 102 // We need to extend ReadableStreamReader's wrapper's life while it is |
179 // active in order to call resolve / reject on ScriptPromiseProperties. | 103 // active in order to call resolve / reject on ScriptPromiseProperties. |
180 return isActive(); | 104 return isActive(); |
181 } | 105 } |
182 | 106 |
183 void ReadableStreamReader::stop() | 107 void ReadableStreamReader::stop() |
184 { | 108 { |
185 releaseLock(); | 109 releaseLock(); |
186 ActiveDOMObject::stop(); | 110 ActiveDOMObject::stop(); |
187 } | 111 } |
188 | 112 |
189 DEFINE_TRACE(ReadableStreamReader) | 113 DEFINE_TRACE(ReadableStreamReader) |
190 { | 114 { |
191 visitor->trace(m_stream); | 115 visitor->trace(m_stream); |
192 visitor->trace(m_released); | 116 visitor->trace(m_closed); |
193 visitor->trace(m_closedAfterRelease); | |
194 visitor->trace(m_readyAfterRelease); | |
195 ActiveDOMObject::trace(visitor); | 117 ActiveDOMObject::trace(visitor); |
196 } | 118 } |
197 | 119 |
198 } // namespace blink | 120 } // namespace blink |
OLD | NEW |