Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(350)

Side by Side Diff: Source/core/streams/ExclusiveStreamReader.cpp

Issue 1001233002: Streams Implementation Update: Reader name and Stream methods (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master
Patch Set: Created 5 years, 9 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
OLDNEW
(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
OLDNEW
« no previous file with comments | « Source/core/streams/ExclusiveStreamReader.h ('k') | Source/core/streams/ExclusiveStreamReader.idl » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698