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 "config.h" | |
6 #include "core/streams/ExclusiveStreamReader.h" | |
7 | |
8 #include "bindings/core/v8/ExceptionState.h" | |
9 #include "bindings/core/v8/ScriptFunction.h" | |
10 #include "bindings/core/v8/ScriptPromiseResolver.h" | |
11 #include "core/dom/DOMException.h" | |
12 #include "core/streams/ReadableStream.h" | |
13 | |
14 namespace blink { | |
15 | |
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 ExclusiveStreamReader::ExclusiveStreamReader(ReadableStream* stream) | |
82 : ActiveDOMObject(stream->executionContext()) | |
83 , m_stream(stream) | |
84 , m_released(new ReleasedPromise(stream->executionContext(), this, ReleasedP
romise::Released)) | |
85 , m_stateAfterRelease(ReadableStream::Closed) | |
86 { | |
87 suspendIfNeeded(); | |
88 ASSERT(m_stream->isLockedTo(nullptr)); | |
89 m_stream->setReader(this); | |
90 } | |
91 | |
92 ScriptPromise ExclusiveStreamReader::closed(ScriptState* scriptState) | |
93 { | |
94 if (isActive()) { | |
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 } | |
103 | |
104 bool ExclusiveStreamReader::isActive() const | |
105 { | |
106 return m_stream->isLockedTo(this); | |
107 } | |
108 | |
109 ScriptPromise ExclusiveStreamReader::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 ExclusiveStreamReader::state() const | |
122 { | |
123 if (isActive()) | |
124 return ReadableStream::stateToString(m_stream->stateInternal()); | |
125 return ReadableStream::stateToString(m_stateAfterRelease); | |
126 } | |
127 | |
128 ScriptPromise ExclusiveStreamReader::cancel(ScriptState* scriptState, ScriptValu
e reason) | |
129 { | |
130 if (isActive()) { | |
131 releaseLock(); | |
132 return m_stream->cancel(scriptState, reason); | |
133 } | |
134 return m_closedAfterRelease->promise(scriptState->world()); | |
135 } | |
136 | |
137 ScriptValue ExclusiveStreamReader::read(ScriptState* scriptState, ExceptionState
& es) | |
138 { | |
139 if (!isActive()) { | |
140 es.throwTypeError("The stream is not locked to this reader"); | |
141 return ScriptValue(); | |
142 } | |
143 return m_stream->readInternal(scriptState, es); | |
144 } | |
145 | |
146 void ExclusiveStreamReader::releaseLock() | |
147 { | |
148 if (!isActive()) | |
149 return; | |
150 | |
151 m_stream->setReader(nullptr); | |
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) { | |
158 m_stateAfterRelease = ReadableStream::Closed; | |
159 m_closedAfterRelease->resolve(ToV8UndefinedGenerator()); | |
160 } else if (m_stream->stateInternal() == ReadableStream::Errored) { | |
161 m_stateAfterRelease = ReadableStream::Errored; | |
162 m_closedAfterRelease->reject(m_stream->storedException()); | |
163 } else { | |
164 m_stateAfterRelease = ReadableStream::Closed; | |
165 m_closedAfterRelease->resolve(ToV8UndefinedGenerator()); | |
166 } | |
167 m_released->resolve(ToV8UndefinedGenerator()); | |
168 ASSERT(!isActive()); | |
169 } | |
170 | |
171 ScriptPromise ExclusiveStreamReader::released(ScriptState* scriptState) | |
172 { | |
173 return m_released->promise(scriptState->world()); | |
174 } | |
175 | |
176 bool ExclusiveStreamReader::hasPendingActivity() const | |
177 { | |
178 // We need to extend ExclusiveStreamReader's wrapper's life while it is | |
179 // active in order to call resolve / reject on ScriptPromiseProperties. | |
180 return isActive(); | |
181 } | |
182 | |
183 void ExclusiveStreamReader::stop() | |
184 { | |
185 releaseLock(); | |
186 ActiveDOMObject::stop(); | |
187 } | |
188 | |
189 DEFINE_TRACE(ExclusiveStreamReader) | |
190 { | |
191 visitor->trace(m_stream); | |
192 visitor->trace(m_released); | |
193 visitor->trace(m_closedAfterRelease); | |
194 visitor->trace(m_readyAfterRelease); | |
195 ActiveDOMObject::trace(visitor); | |
196 } | |
197 | |
198 } // namespace blink | |
OLD | NEW |