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/ExclusiveStreamReader.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/ScriptFunction.h" |
10 #include "bindings/core/v8/ScriptPromiseResolver.h" | 10 #include "bindings/core/v8/ScriptPromiseResolver.h" |
11 #include "core/dom/DOMException.h" | 11 #include "core/dom/DOMException.h" |
12 #include "core/streams/ReadableStream.h" | 12 #include "core/streams/ReadableStream.h" |
13 | 13 |
14 namespace blink { | 14 namespace blink { |
15 | 15 |
16 namespace { | 16 namespace { |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
71 { | 71 { |
72 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::
create(scriptState); | 72 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::
create(scriptState); |
73 for (ScriptPromise promise : promises) { | 73 for (ScriptPromise promise : promises) { |
74 promise.then(PromiseRaceFulfillHandler::create(resolver), PromiseRaceRej
ectHandler::create(resolver)); | 74 promise.then(PromiseRaceFulfillHandler::create(resolver), PromiseRaceRej
ectHandler::create(resolver)); |
75 } | 75 } |
76 return resolver->promise(); | 76 return resolver->promise(); |
77 } | 77 } |
78 | 78 |
79 } // namespace | 79 } // namespace |
80 | 80 |
81 ExclusiveStreamReader::ExclusiveStreamReader(ReadableStream* stream) | 81 ReadableStreamReader::ReadableStreamReader(ReadableStream* stream) |
82 : ActiveDOMObject(stream->executionContext()) | 82 : ActiveDOMObject(stream->executionContext()) |
83 , m_stream(stream) | 83 , m_stream(stream) |
84 , m_released(new ReleasedPromise(stream->executionContext(), this, ReleasedP
romise::Released)) | 84 , m_released(new ReleasedPromise(stream->executionContext(), this, ReleasedP
romise::Released)) |
85 , m_stateAfterRelease(ReadableStream::Closed) | 85 , m_stateAfterRelease(ReadableStream::Closed) |
86 { | 86 { |
87 suspendIfNeeded(); | 87 suspendIfNeeded(); |
88 ASSERT(m_stream->isLockedTo(nullptr)); | 88 ASSERT(m_stream->isLockedTo(nullptr)); |
89 m_stream->setReader(this); | 89 m_stream->setReader(this); |
90 } | 90 } |
91 | 91 |
92 ScriptPromise ExclusiveStreamReader::closed(ScriptState* scriptState) | 92 ScriptPromise ReadableStreamReader::closed(ScriptState* scriptState) |
93 { | 93 { |
94 if (isActive()) { | 94 if (isActive()) { |
95 Vector<ScriptPromise> promises; | 95 Vector<ScriptPromise> promises; |
96 promises.append(m_stream->closed(scriptState)); | 96 promises.append(m_stream->closed(scriptState)); |
97 promises.append(m_released->promise(scriptState->world())); | 97 promises.append(m_released->promise(scriptState->world())); |
98 return race(scriptState, promises); | 98 return race(scriptState, promises); |
99 } | 99 } |
100 ASSERT(m_released); | 100 ASSERT(m_released); |
101 return m_closedAfterRelease->promise(scriptState->world()); | 101 return m_closedAfterRelease->promise(scriptState->world()); |
102 } | 102 } |
103 | 103 |
104 bool ExclusiveStreamReader::isActive() const | 104 bool ReadableStreamReader::isActive() const |
105 { | 105 { |
106 return m_stream->isLockedTo(this); | 106 return m_stream->isLockedTo(this); |
107 } | 107 } |
108 | 108 |
109 ScriptPromise ExclusiveStreamReader::ready(ScriptState* scriptState) | 109 ScriptPromise ReadableStreamReader::ready(ScriptState* scriptState) |
110 { | 110 { |
111 if (isActive()) { | 111 if (isActive()) { |
112 Vector<ScriptPromise> promises; | 112 Vector<ScriptPromise> promises; |
113 promises.append(m_stream->readyInternal(scriptState)); | 113 promises.append(m_stream->readyInternal(scriptState)); |
114 promises.append(m_released->promise(scriptState->world())); | 114 promises.append(m_released->promise(scriptState->world())); |
115 return race(scriptState, promises); | 115 return race(scriptState, promises); |
116 } | 116 } |
117 ASSERT(m_readyAfterRelease); | 117 ASSERT(m_readyAfterRelease); |
118 return m_readyAfterRelease->promise(scriptState->world()); | 118 return m_readyAfterRelease->promise(scriptState->world()); |
119 } | 119 } |
120 | 120 |
121 String ExclusiveStreamReader::state() const | 121 String ReadableStreamReader::state() const |
122 { | 122 { |
123 if (isActive()) | 123 if (isActive()) |
124 return ReadableStream::stateToString(m_stream->stateInternal()); | 124 return ReadableStream::stateToString(m_stream->stateInternal()); |
125 return ReadableStream::stateToString(m_stateAfterRelease); | 125 return ReadableStream::stateToString(m_stateAfterRelease); |
126 } | 126 } |
127 | 127 |
128 ScriptPromise ExclusiveStreamReader::cancel(ScriptState* scriptState, ScriptValu
e reason) | 128 ScriptPromise ReadableStreamReader::cancel(ScriptState* scriptState, ScriptValue
reason) |
129 { | 129 { |
130 if (isActive()) { | 130 if (isActive()) { |
131 releaseLock(); | 131 releaseLock(); |
132 return m_stream->cancel(scriptState, reason); | 132 return m_stream->cancel(scriptState, reason); |
133 } | 133 } |
134 return m_closedAfterRelease->promise(scriptState->world()); | 134 return m_closedAfterRelease->promise(scriptState->world()); |
135 } | 135 } |
136 | 136 |
137 ScriptValue ExclusiveStreamReader::read(ScriptState* scriptState, ExceptionState
& es) | 137 ScriptValue ReadableStreamReader::read(ScriptState* scriptState, ExceptionState&
es) |
138 { | 138 { |
139 if (!isActive()) { | 139 if (!isActive()) { |
140 es.throwTypeError("The stream is not locked to this reader"); | 140 es.throwTypeError("The stream is not locked to this reader"); |
141 return ScriptValue(); | 141 return ScriptValue(); |
142 } | 142 } |
143 return m_stream->readInternal(scriptState, es); | 143 return m_stream->readInternal(scriptState, es); |
144 } | 144 } |
145 | 145 |
146 void ExclusiveStreamReader::releaseLock() | 146 void ReadableStreamReader::releaseLock() |
147 { | 147 { |
148 if (!isActive()) | 148 if (!isActive()) |
149 return; | 149 return; |
150 | 150 |
151 m_stream->setReader(nullptr); | 151 m_stream->setReader(nullptr); |
152 | 152 |
153 m_readyAfterRelease = new ReadyPromise(executionContext(), this, ReadyPromis
e::Ready); | 153 m_readyAfterRelease = new ReadyPromise(executionContext(), this, ReadyPromis
e::Ready); |
154 m_readyAfterRelease->resolve(ToV8UndefinedGenerator()); | 154 m_readyAfterRelease->resolve(ToV8UndefinedGenerator()); |
155 m_closedAfterRelease = new ClosedPromise(executionContext(), this, ReadyProm
ise::Closed); | 155 m_closedAfterRelease = new ClosedPromise(executionContext(), this, ReadyProm
ise::Closed); |
156 | 156 |
157 if (m_stream->stateInternal() == ReadableStream::Closed) { | 157 if (m_stream->stateInternal() == ReadableStream::Closed) { |
158 m_stateAfterRelease = ReadableStream::Closed; | 158 m_stateAfterRelease = ReadableStream::Closed; |
159 m_closedAfterRelease->resolve(ToV8UndefinedGenerator()); | 159 m_closedAfterRelease->resolve(ToV8UndefinedGenerator()); |
160 } else if (m_stream->stateInternal() == ReadableStream::Errored) { | 160 } else if (m_stream->stateInternal() == ReadableStream::Errored) { |
161 m_stateAfterRelease = ReadableStream::Errored; | 161 m_stateAfterRelease = ReadableStream::Errored; |
162 m_closedAfterRelease->reject(m_stream->storedException()); | 162 m_closedAfterRelease->reject(m_stream->storedException()); |
163 } else { | 163 } else { |
164 m_stateAfterRelease = ReadableStream::Closed; | 164 m_stateAfterRelease = ReadableStream::Closed; |
165 m_closedAfterRelease->resolve(ToV8UndefinedGenerator()); | 165 m_closedAfterRelease->resolve(ToV8UndefinedGenerator()); |
166 } | 166 } |
167 m_released->resolve(ToV8UndefinedGenerator()); | 167 m_released->resolve(ToV8UndefinedGenerator()); |
168 ASSERT(!isActive()); | 168 ASSERT(!isActive()); |
169 } | 169 } |
170 | 170 |
171 ScriptPromise ExclusiveStreamReader::released(ScriptState* scriptState) | 171 ScriptPromise ReadableStreamReader::released(ScriptState* scriptState) |
172 { | 172 { |
173 return m_released->promise(scriptState->world()); | 173 return m_released->promise(scriptState->world()); |
174 } | 174 } |
175 | 175 |
176 bool ExclusiveStreamReader::hasPendingActivity() const | 176 bool ReadableStreamReader::hasPendingActivity() const |
177 { | 177 { |
178 // We need to extend ExclusiveStreamReader's wrapper's life while it is | 178 // We need to extend ReadableStreamReader's wrapper's life while it is |
179 // active in order to call resolve / reject on ScriptPromiseProperties. | 179 // active in order to call resolve / reject on ScriptPromiseProperties. |
180 return isActive(); | 180 return isActive(); |
181 } | 181 } |
182 | 182 |
183 void ExclusiveStreamReader::stop() | 183 void ReadableStreamReader::stop() |
184 { | 184 { |
185 releaseLock(); | 185 releaseLock(); |
186 ActiveDOMObject::stop(); | 186 ActiveDOMObject::stop(); |
187 } | 187 } |
188 | 188 |
189 DEFINE_TRACE(ExclusiveStreamReader) | 189 DEFINE_TRACE(ReadableStreamReader) |
190 { | 190 { |
191 visitor->trace(m_stream); | 191 visitor->trace(m_stream); |
192 visitor->trace(m_released); | 192 visitor->trace(m_released); |
193 visitor->trace(m_closedAfterRelease); | 193 visitor->trace(m_closedAfterRelease); |
194 visitor->trace(m_readyAfterRelease); | 194 visitor->trace(m_readyAfterRelease); |
195 ActiveDOMObject::trace(visitor); | 195 ActiveDOMObject::trace(visitor); |
196 } | 196 } |
197 | 197 |
198 } // namespace blink | 198 } // namespace blink |
OLD | NEW |