Scroll snapping on Mac should use AppKit animations
[WebKit-https.git] / Source / WTF / ChangeLog
1 2016-11-29  Wenson Hsieh  <wenson_hsieh@apple.com>
2
3         Scroll snapping on Mac should use AppKit animations
4         https://bugs.webkit.org/show_bug.cgi?id=147261
5         <rdar://problem/29395293>
6
7         Reviewed by Brent Fulgham.
8
9         Introduce HAVE(NSSCROLLING_FILTERS), which is on for macOS El Capitan and later.
10
11         * wtf/Platform.h:
12
13 2016-11-28  Darin Adler  <darin@apple.com>
14
15         Streamline and speed up tokenizer and segmented string classes
16         https://bugs.webkit.org/show_bug.cgi?id=165003
17
18         Reviewed by Sam Weinig.
19
20         * wtf/text/StringBuilder.cpp:
21         (WTF::StringBuilder::bufferCharacters<LChar>): Moved this here from
22         the header since it is only used inside the class. Also renamed from
23         getBufferCharacters.
24         (WTF::StringBuilder::bufferCharacters<UChar>): Ditto.
25         (WTF::StringBuilder::appendUninitializedUpconvert): Added. Helper
26         for the upconvert case in the 16-bit overload of StrinBuilder::append.
27         (WTF::StringBuilder::append): Changed to use appendUninitializedUpconvert.
28         (WTF::quotedJSONStringLength): Added. Used in new appendQuotedJSONString
29         implementation below that now correctly determines the size of what will
30         be appended by walking thorugh the string twice.
31         (WTF::appendQuotedJSONStringInternal): Moved the code that writes the
32         quote marks in here. Also made a few coding style tweaks.
33         (WTF::StringBuilder::appendQuotedJSONString): Rewrote to use a much
34         simpler algorithm that grows the string the same way the append function
35         does. The old code would use reserveCapacity in a way that was costly when
36         doing a lot of appends on the same string, and also allocated far too much
37         memory for normal use cases where characters did not need to be turned
38         into escape sequences.
39
40         * wtf/text/StringBuilder.h:
41         (WTF::StringBuilder::append): Tweaked style a bit, fixed a bug where the
42         m_is8Bit field wasn't set correctly in one case, optimized the function that
43         adds substrings for the case where this is the first append and the substring
44         happens to cover the entire string. Also clarified the assertions and removed
45         an unneeded check from that substring overload.
46         (WTF::equal): Reimplemented, using equalCommon.
47
48 2016-11-26  Yusuke Suzuki  <utatane.tea@gmail.com>
49
50         [WTF] Import std::optional reference implementation as WTF::Optional
51         https://bugs.webkit.org/show_bug.cgi?id=164199
52
53         Reviewed by Saam Barati and Sam Weinig.
54
55         Import std::optional reference implementation offered by the C++17
56         original proposal paper. It has the same interface and functionality
57         to the C++17's one. Previous WTF::Optional lacks several functionalities.
58         The largest one is the correct constexpr constructors. This fact prevents
59         us from using Optional<literal type> in constexpr context in WebKit.
60
61         In WebKit, we do not allow global constructors. So only the constexpr
62         constructor is the way to use WTF::Optional in the static const
63         global variables. WTF::Optional is used in DOMJIT::Effect and
64         we would like to emit static const global variables that includes
65         this DOMJIT::Effect. That is the main motivation of this work.
66         This functionality allows the IDL code generator to emit DOMJIT
67         signatures as static const global variables.
68
69         We import the reference implementation one instead of LLVM libc++'s one.
70         This is because LLVM libc++'s one depends on many macro and type_traits
71         offered by libc++ implementation. And adopting it to WebKit requires
72         large modification compared to this reference implementation one.
73         Furthermore, it is difficult to compile libc++'s optional in old GCC and VC++.
74         It also requires some more modifications. To keep the thing simple,
75         we import the reference implementation one now. Once C++17 is released
76         and we update the compiler baseline, we can smoothly switch to the standard
77         library's std::optional.
78
79         We also add support for the environment that does not use exceptions to this
80         reference implementation.
81
82         And we also add valueOrCompute helper function. That keeps the extended
83         functionality that previous WTF::Optional has.
84
85         * wtf/CrossThreadQueue.h:
86         (WTF::CrossThreadQueue<DataType>::tryGetMessage):
87         * wtf/Expected.h:
88         (WTF::makeExpected):
89         * wtf/Forward.h:
90         * wtf/HashTraits.h:
91         (WTF::HashTraits<Ref<P>>::take):
92         * wtf/MainThread.cpp:
93         (WTF::initializeGCThreads):
94         (WTF::mayBeGCThread):
95         * wtf/MainThread.h:
96         * wtf/Optional.h:
97         (std::detail_::is_assignable::has_assign):
98         (std::detail_::has_overloaded_addressof::has_overload):
99         (std::detail_::static_addressof):
100         (std::detail_::convert):
101         (std::nullopt_t::nullopt_t):
102         (std::bad_optional_access::bad_optional_access):
103         (std::optional_base::optional_base):
104         (std::optional_base::~optional_base):
105         (std::constexpr_optional_base::constexpr_optional_base):
106         (std::optional::dataptr):
107         (std::optional::contained_val):
108         (std::optional::__NOEXCEPT_):
109         (std::optional::optional):
110         (std::optional::operator=):
111         (std::optional::emplace):
112         (std::optional::operator ->):
113         (std::optional::operator *):
114         (std::optional::value):
115         (std::optional::value_or):
116         (std::operator==):
117         (std::operator!=):
118         (std::operator<):
119         (std::operator>):
120         (std::operator<=):
121         (std::operator>=):
122         (std::__NOEXCEPT_):
123         (std::make_optional):
124         (std::hash<std::optional<T>>::operator()):
125         (WTF::NulloptTag::NulloptTag): Deleted.
126         (WTF::Optional::Optional): Deleted.
127         (WTF::Optional::~Optional): Deleted.
128         (WTF::Optional::operator=): Deleted.
129         (WTF::Optional::operator bool): Deleted.
130         (WTF::Optional::operator->): Deleted.
131         (WTF::Optional::operator*): Deleted.
132         (WTF::Optional::value): Deleted.
133         (WTF::Optional::valueOr): Deleted.
134         (WTF::Optional::valueOrCompute): Deleted.
135         (WTF::Optional::asPtr): Deleted.
136         (WTF::Optional::destroy): Deleted.
137         (WTF::operator==): Deleted.
138         (WTF::operator!=): Deleted.
139         (WTF::makeOptional): Deleted.
140         (WTF::printInternal): Deleted.
141         * wtf/text/StringView.cpp:
142         (WTF::StringView::GraphemeClusters::Iterator::Impl::Impl):
143         (WTF::StringView::GraphemeClusters::Iterator::Iterator):
144         * wtf/text/StringView.h:
145
146 2016-11-26  Simon Fraser  <simon.fraser@apple.com>
147
148         Migrate some layout timer-related code from std::chrono to Seconds and MonotonicTime
149         https://bugs.webkit.org/show_bug.cgi?id=164992
150
151         Reviewed by Darin Adler.
152
153         Add Seconds::zero() as a nicer way to express Seconds(0). 
154
155         * wtf/Seconds.h:
156         (WTF::Seconds::zero):
157
158 2016-11-26  Simon Fraser  <simon.fraser@apple.com>
159
160         Add literals for various time units
161         https://bugs.webkit.org/show_bug.cgi?id=165074
162
163         Reviewed by Filip Pizlo.
164         
165         Add _min, _s, _ms, _us and _ns literals for easy creation of Seconds from long double
166         and unsigned long long types (those allowed for custom literals).
167         
168         Add minutes-related functions (there are one or two use cases in WebCore).
169
170         * wtf/Seconds.h:
171         (WTF::Seconds::minutes):
172         (WTF::Seconds::fromMinutes):
173         (WTF::Seconds::fromMilliseconds):
174         (WTF::Seconds::fromMicroseconds):
175         (WTF::Seconds::fromNanoseconds):
176         (WTF::operator _min):
177         (WTF::operator _s):
178         (WTF::operator _ms):
179         (WTF::operator _us):
180         (WTF::operator _ns):
181
182 2016-11-22  Darin Adler  <darin@apple.com>
183
184         One more tiny bit of follow-up.
185
186         * wtf/text/TextBreakIterator.cpp:
187         (WTF::numCharactersInGraphemeClusters): Removed unneeded always-true check.
188
189 2016-11-22  Darin Adler  <darin@apple.com>
190
191         Quick follow-up to previous patch.
192
193         * wtf/text/TextBreakIterator.cpp:
194         (WTF::numCharactersInGraphemeClusters): Removed incorrect assertion.
195
196 2016-11-22  Darin Adler  <darin@apple.com>
197
198         Make normal case fast in the input element limitString function
199         https://bugs.webkit.org/show_bug.cgi?id=165023
200
201         Reviewed by Dan Bernstein.
202
203         * wtf/text/LineBreakIteratorPoolICU.h: Removed many unneeded includes.
204         Simplified the class a bit, removing some extra definitions.
205         (WTF::LineBreakIteratorPool::sharedPool): Use NeverDestroyed instead of new.
206         (WTF::LineBreakIteratorPool::makeLocaleWithBreakKeyword): Reimplemented in
207         a simpler way without using StringBuilder. Also updated for change to
208         LineBreakIteratorMode.
209         (WTF::LineBreakIteratorPool::put): Use uncheckedAppend since the code is
210         careful to only use the inline capacity in the vector.
211
212         * wtf/text/TextBreakIterator.cpp: Moved some includes in here from the header.
213         (WTF::mapLineIteratorModeToRules): Updated for change to LineBreakIteratorMode.
214         (WTF::openLineBreakIterator): Ditto.
215         (WTF::numGraphemeClusters): Added a fast path for all 8-bit strings; don't
216         use ICU for that case, even if there is a CR character in it.
217         (WTF::numCharactersInGraphemeClusters): Added a fast path for strings that are
218         short enough to entirely fit without even looking at the characters; that's a
219         case we likely hit all the time. Also added a fast path for all 8-bit strings.
220
221         * wtf/text/TextBreakIterator.h: Changed LineBreakIteratorMode to be an enum
222         class and not repeat UAX14 in the names of the modes. Initialize data members
223         in the class definition rather than the constructors.
224
225 2016-11-21  Mark Lam  <mark.lam@apple.com>
226
227         Hasher::addCharacters() should be able to handle zero length strings.
228         https://bugs.webkit.org/show_bug.cgi?id=165024
229
230         Reviewed by Yusuke Suzuki.
231
232         Currently, it will fail to handle zero length strings if it has a pending
233         character.  The fix is simply to return early if length is 0. 
234
235         * wtf/Hasher.h:
236         (WTF::StringHasher::addCharacters):
237
238 2016-11-18  Jeremy Jones  <jeremyj@apple.com>
239
240         Add runtime flag to enable pointer lock. Enable pointer lock feature for mac.
241         https://bugs.webkit.org/show_bug.cgi?id=163801
242
243         Reviewed by Simon Fraser.
244
245         * wtf/FeatureDefines.h: ENABLE_POINTER_LOCK true for Mac.
246
247 2016-11-17  Saam Barati  <sbarati@apple.com>
248
249         Remove async/await compile time flag and enable tests
250         https://bugs.webkit.org/show_bug.cgi?id=164828
251         <rdar://problem/28639334>
252
253         Reviewed by Yusuke Suzuki.
254
255         * wtf/FeatureDefines.h:
256
257 2016-11-17  Yusuke Suzuki  <utatane.tea@gmail.com>
258
259         [JSC] WTF::TemporaryChange with WTF::SetForScope
260         https://bugs.webkit.org/show_bug.cgi?id=164761
261
262         Reviewed by Saam Barati.
263
264         JavaScriptCore's bytecompiler/SetForScope.h is completely the same
265         to WTF::TemporaryChange. SetForScope sounds better name since it
266         says that this object works as Scope.
267
268         We rename WTF::TemporaryChange to WTF::SetForScope. And replace
269         all the use to this WTF::SetForScope.
270
271         * WTF.xcodeproj/project.pbxproj:
272         * wtf/SetForScope.h: Renamed from Source/WTF/wtf/TemporaryChange.h.
273         (WTF::SetForScope::SetForScope):
274         (WTF::SetForScope::~SetForScope):
275
276 2016-11-16  Yusuke Suzuki  <utatane.tea@gmail.com>
277
278         [ES6][WebCore] Change ES6_MODULES compile time flag to runtime flag
279         https://bugs.webkit.org/show_bug.cgi?id=164827
280
281         Reviewed by Ryosuke Niwa.
282
283         * wtf/FeatureDefines.h:
284
285 2016-11-16  Carlos Alberto Lopez Perez  <clopez@igalia.com>
286
287         [JSC] Build broken for 32-bit x86 after r208306 with GCC 4.9
288         https://bugs.webkit.org/show_bug.cgi?id=164588
289
290         Reviewed by Mark Lam.
291
292         Provide assembly for executing the cpuid instruction when compiling
293         in PIC mode with the GCC 4.9 EBX on 32-bit x86.
294
295         Note that the values returned by cpuid here are not used. The purpose
296         of calling this instruction is to force the CPU to complete and sync
297         any buffered modifications on registers, memory or flags before
298         fetching and executing the next instruction.
299
300         * wtf/Atomics.h:
301         (WTF::x86_cpuid):
302
303 2016-11-15  Filip Pizlo  <fpizlo@apple.com>
304
305         Rename CONCURRENT_JIT/ConcurrentJIT to CONCURRENT_JS/ConcurrentJS
306         https://bugs.webkit.org/show_bug.cgi?id=164791
307
308         Reviewed by Geoffrey Garen.
309         
310         Both the concurrent GC and the concurrent JIT rely on concurrency support in fundamental
311         JSC runtime components like JSValue. So, the thing that guards it should be a "feature"
312         called CONCURRENT_JS not CONCURRENT_JIT.
313
314         * wtf/Platform.h:
315
316 2016-11-15  Filip Pizlo  <fpizlo@apple.com>
317
318         The concurrent GC should have a timeslicing controller
319         https://bugs.webkit.org/show_bug.cgi?id=164783
320
321         Reviewed by Geoffrey Garen.
322
323         * wtf/LockAlgorithm.h: Added some comments.
324         * wtf/Seconds.h: Added support for modulo. It's necessary for timeslicing.
325         (WTF::Seconds::operator%):
326         (WTF::Seconds::operator%=):
327
328 2016-11-11  Filip Pizlo  <fpizlo@apple.com>
329
330         The GC should be optionally concurrent and disabled by default
331         https://bugs.webkit.org/show_bug.cgi?id=164454
332
333         Reviewed by Geoffrey Garen.
334         
335         The reason why I went to such great pains to make WTF::Lock fit in two bits is that I
336         knew that I would eventually need to stuff one into some miscellaneous bits of the
337         JSCell header. That time has come, because the concurrent GC has numerous race
338         conditions in visitChildren that can be trivially fixed if each object just has an
339         internal lock. Some cell types might use it to simply protect their entire visitChildren
340         function and anything that mutates the fields it touches, while other cell types might
341         use it as a "lock of last resort" to handle corner cases of an otherwise wait-free or
342         lock-free algorithm. Right now, it's used to protect certain transformations involving
343         indexing storage.
344         
345         To make this happen, I factored the WTF::Lock algorithm into a LockAlgorithm struct that
346         is templatized on lock type (uint8_t for WTF::Lock), the isHeldBit value (1 for
347         WTF::Lock), and the hasParkedBit value (2 for WTF::Lock). This could have been done as
348         a templatized Lock class that basically contains Atomic<LockType>. You could then make
349         any field into a lock by bitwise_casting it to TemplateLock<field type, bit1, bit2>. But
350         this felt too dirty, so instead, LockAlgorithm has static methods that take
351         Atomic<LockType>& as their first argument. I think that this makes it more natural to
352         project a LockAlgorithm onto an existing Atomic<> field. Sadly, some places have to cast
353         their non-Atomic<> field to Atomic<> in order for this to work. Like so many other things
354         we do, this just shows that the C++ style of labeling fields that are subject to atomic
355         ops as atomic is counterproductive. Maybe some day I'll change LockAlgorithm to use our
356         other Atomics API, which does not require Atomic<>.
357         
358         WTF::Lock now uses LockAlgorithm. The slow paths are still outlined. I don't feel too
359         bad about the LockAlgorithm.h header being included in so many places because we change
360         that algorithm so infrequently.
361         
362         Also, I added a hasElapsed(time) function. This function makes it so much more natural
363         to write timeslicing code, which the concurrent GC has to do a lot of.
364
365         * WTF.xcodeproj/project.pbxproj:
366         * wtf/CMakeLists.txt:
367         * wtf/ListDump.h:
368         * wtf/Lock.cpp:
369         (WTF::LockBase::lockSlow):
370         (WTF::LockBase::unlockSlow):
371         (WTF::LockBase::unlockFairlySlow):
372         (WTF::LockBase::unlockSlowImpl): Deleted.
373         * wtf/Lock.h:
374         (WTF::LockBase::lock):
375         (WTF::LockBase::tryLock):
376         (WTF::LockBase::unlock):
377         (WTF::LockBase::unlockFairly):
378         (WTF::LockBase::isHeld):
379         (): Deleted.
380         * wtf/LockAlgorithm.h: Added.
381         (WTF::LockAlgorithm::lockFastAssumingZero):
382         (WTF::LockAlgorithm::lockFast):
383         (WTF::LockAlgorithm::lock):
384         (WTF::LockAlgorithm::tryLock):
385         (WTF::LockAlgorithm::unlockFastAssumingZero):
386         (WTF::LockAlgorithm::unlockFast):
387         (WTF::LockAlgorithm::unlock):
388         (WTF::LockAlgorithm::unlockFairly):
389         (WTF::LockAlgorithm::isLocked):
390         (WTF::LockAlgorithm::lockSlow):
391         (WTF::LockAlgorithm::unlockSlow):
392         * wtf/TimeWithDynamicClockType.cpp:
393         (WTF::hasElapsed):
394         * wtf/TimeWithDynamicClockType.h:
395
396 2016-11-14  JF Bastien  <jfbastien@apple.com>
397
398         Expected: add missing `inline`
399         https://bugs.webkit.org/show_bug.cgi?id=164735
400
401         Reviewed by Yusuke Suzuki.
402
403         Free functions and full template specializations need to be
404         `inline`, or in a .cpp file, otherwise each .o creates a duplicate
405         symbol which makes the linker very sad.
406
407         * wtf/Expected.h:
408         (WTF::ExpectedDetail::Throw):
409         (WTF::makeExpected):
410
411 2016-11-14  Mark Lam  <mark.lam@apple.com>
412
413         Build fix after r208690.
414         https://bugs.webkit.org/show_bug.cgi?id=164681
415
416         Not reviewed.
417
418         * wtf/FastMalloc.h:
419
420 2016-11-13  Mark Lam  <mark.lam@apple.com>
421
422         Add debugging facility to limit the max single allocation size.
423         https://bugs.webkit.org/show_bug.cgi?id=164681
424
425         Reviewed by Keith Miller.
426
427         This is useful for simulating memory allocation failures on resource constraint
428         devices for testing purposes.
429
430         This facility is only conditionally compiled in on debug builds.  It does not
431         have any burden on release builds at all.  When in use, the max single allocation
432         size limit applies to individual allocations.  For malloc (and similar), the
433         allocation will crash in FastMalloc if the requested size exceeds the set max
434         single allocation size.  For tryMalloc (and similar), the allocation returns
435         nullptr if the requested size exceeds the set max single allocation size.  The
436         max single allocation size is set to std::numeric_limit<size_t>::max() by default
437         (i.e. when not set and no limit is in effect).
438
439         Also fixed non-bmalloc versions of fastAlignedMalloc() to crash when allocation
440         fails.
441
442         * wtf/FastMalloc.cpp:
443         (WTF::fastSetMaxSingleAllocationSize):
444         (WTF::fastAlignedMalloc):
445         (WTF::tryFastAlignedMalloc):
446         (WTF::tryFastMalloc):
447         (WTF::fastMalloc):
448         (WTF::tryFastCalloc):
449         (WTF::fastCalloc):
450         (WTF::fastRealloc):
451         * wtf/FastMalloc.h:
452
453 2016-11-13  JF Bastien  <jfbastien@apple.com>
454
455         Implement WTF::Expected
456         https://bugs.webkit.org/show_bug.cgi?id=164526
457
458         Reviewed by Yusuke Suzuki.
459
460         std::expected isn't in C++17, and may be in C++20. It's a nice
461         complement to std::any / std::optional because it's a type-tagged
462         union which has a single expected result but could also contain an
463         error.
464
465         This would be useful in the WebAssembly parser, for example.
466
467         Using this implementation will allow us to provide feedback to the
468         standards committee and guide std::expected's design before it
469         gets standardized. I've already sent a bunch of feedback to the
470         author based on my experience implementing this.
471
472         This could supplement WTF::Either and WTF::ExceptionOr.
473
474         * WTF.xcodeproj/project.pbxproj:
475         * wtf/Compiler.h: Add RELAXED_CONSTEXPR
476         * wtf/Expected.h: Added.
477         (WTF::UnexpectedType::UnexpectedType):
478         (WTF::UnexpectedType::value):
479         (WTF::operator==):
480         (WTF::operator!=):
481         (WTF::operator<):
482         (WTF::operator>):
483         (WTF::operator<=):
484         (WTF::operator>=):
485         (WTF::makeUnexpected):
486         (WTF::ExpectedDetail::Throw):
487         (WTF::ExpectedDetail::ConstexprBase::ConstexprBase):
488         (WTF::ExpectedDetail::Base::Base):
489         (WTF::ExpectedDetail::Base::~Base):
490         (WTF::Expected::Expected):
491         (WTF::Expected::operator=):
492         (WTF::Expected::swap):
493         (WTF::Expected::operator->):
494         (WTF::Expected::operator*):
495         (WTF::Expected::operator bool):
496         (WTF::Expected::hasValue):
497         (WTF::Expected::value):
498         (WTF::Expected::error):
499         (WTF::Expected::getUnexpected):
500         (WTF::Expected::valueOr):
501         (WTF::swap):
502         (WTF::makeExpected):
503         (WTF::makeExpectedFromError):
504
505 2016-11-11  Alex Christensen  <achristensen@webkit.org>
506
507         Allow mutable lambdas in HashMap::ensure
508         https://bugs.webkit.org/show_bug.cgi?id=164642
509
510         Reviewed by Sam Weinig.
511
512         * wtf/HashMap.h:
513         (WTF::HashMapEnsureTranslator::translate):
514         (WTF::X>::removeIf):
515
516 2016-11-11  Beth Dakin  <bdakin@apple.com>
517
518         Get touch bar code building for open source builds
519         https://bugs.webkit.org/show_bug.cgi?id=164610
520
521         Reviewed by Wenson Hsieh.
522
523         * wtf/Platform.h:
524
525 2016-11-10  JF Bastien  <jfbastien@apple.com>
526
527         ASSERTION FAILED: length > offset encountered with wasm.yaml/wasm/js-api/test_Module.js.default-wasm
528         https://bugs.webkit.org/show_bug.cgi?id=164597
529
530         Reviewed by Keith Miller.
531
532         Decoding at end of file should fail, not assert.
533
534         * wtf/LEBDecoder.h:
535         (WTF::LEBDecoder::decodeUInt):
536         (WTF::LEBDecoder::decodeInt32):
537
538 2016-11-10  Alex Christensen  <achristensen@webkit.org>
539
540         Remove unused CFURLCACHE code
541         https://bugs.webkit.org/show_bug.cgi?id=164551
542
543         Reviewed by Antti Koivisto.
544
545         * wtf/Platform.h:
546
547 2016-11-09  Alex Christensen  <achristensen@webkit.org>
548
549         Allow RefPtrs of const ThreadSafeRefCounted types
550         https://bugs.webkit.org/show_bug.cgi?id=164548
551
552         Reviewed by Tim Horton.
553
554         * wtf/ThreadSafeRefCounted.h:
555         Make m_refCount mutable like we did with RefCounted in r203257.
556
557 2016-11-09  Chris Dumez  <cdumez@apple.com>
558
559         [Mac] Stop using deprecated AppKit enumeration values
560         https://bugs.webkit.org/show_bug.cgi?id=164494
561
562         Reviewed by Darin Adler.
563
564         Stop using deprecated AppKit enumeration values.
565
566         * wtf/mac/AppKitCompatibilityDeclarations.h:
567
568 2016-11-05  Konstantin Tokarev  <annulen@yandex.ru>
569
570         Fixed compilation of LLInt with MinGW
571         https://bugs.webkit.org/show_bug.cgi?id=164449
572
573         Reviewed by Michael Catanzaro.
574
575         MinGW uses LLIntAssembly.h with GNU assembler syntax, just like GCC on
576         other platforms.
577
578         * wtf/InlineASM.h: Define LOCAL_LABEL_STRING as .L#name for MinGW.
579
580 2016-11-05  Konstantin Tokarev  <annulen@yandex.ru>
581
582         [MinGW] Fixed C99/C++11 format attributes in printf-like functions
583         https://bugs.webkit.org/show_bug.cgi?id=164448
584
585         Reviewed by Michael Catanzaro.
586
587         By default MinGW uses printf-like function provided in msvcrt.dll,
588         however they miss support for C99/C++11 format attributes. Use MinGW
589         implementations instead.
590
591         * wtf/Assertions.h: Use gnu_printf format in WTF_ATTRIBUTE_PRINTF
592
593 2016-11-05  Yusuke Suzuki  <utatane.tea@gmail.com>
594
595         [JSCOnly] RunLoopGeneric should adopt MonotonicTime / WallTime change
596         https://bugs.webkit.org/show_bug.cgi?id=164447
597
598         Reviewed by Csaba Osztrogon√°c.
599
600         Build fix for JSCOnly.
601
602         * wtf/generic/RunLoopGeneric.cpp:
603         (WTF::RunLoop::TimerBase::ScheduledTask::create):
604         (WTF::RunLoop::TimerBase::ScheduledTask::ScheduledTask):
605         (WTF::RunLoop::TimerBase::ScheduledTask::scheduledTimePoint):
606         (WTF::RunLoop::TimerBase::ScheduledTask::updateReadyTime):
607         (WTF::RunLoop::populateTasks):
608         (WTF::RunLoop::dispatchAfter):
609         (WTF::RunLoop::TimerBase::start):
610
611 2016-11-04  Filip Pizlo  <fpizlo@apple.com>
612
613         WTF::ParkingLot should stop using std::chrono because std::chrono::duration casts are prone to overflows
614         https://bugs.webkit.org/show_bug.cgi?id=152045
615
616         Reviewed by Andy Estes.
617         
618         We used to use 'double' for all time measurements. Sometimes it was milliseconds,
619         sometimes it was seconds. Sometimes we measured a span of time, sometimes we spoke of time
620         since some epoch. When we spoke of time since epoch, we either used a monotonic clock or
621         a wall clock. The type - always 'double' - never told us what kind of time we had, even
622         though there were roughly six of them (sec interval, ms interval, sec since epoch on wall,
623         ms since epoch on wall, sec since epoch monotonic, ms since epoch monotonic).
624         
625         At some point, we thought that it would be a good idea to replace these doubles with
626         std::chrono. But since replacing some things with std::chrono, we found it to be terribly
627         inconvenient:
628         
629         - Outrageous API. I never want to say std::chrono::milliseconds(blah). I never want to say
630           std::chrono::steady_clock::timepoint. The syntax for duration_cast is ugly, and ideally
631           duration_cast would not even be a thing.
632         
633         - No overflow protection. std::chrono uses integers by default and using anything else is
634           clumsy. But the integer math is done without regard for the rough edges of integer math,
635           so any cast between std::chrono types risks overflow. Any comparison risks overflow
636           because it may do conversions silently. We have even found bugs where some C++
637           implementations had more overflows than others, which ends up being a special kind of
638           hell. In many cases, the overflow also has nasal demons.
639         
640         It's an error to represent time using integers. It would have been excusable back when
641         floating point math was not guaranteed to be supported on all platforms, but that would
642         have been a long time ago. Time is a continuous, infinite concept and it's a perfect fit
643         for floating point:
644         
645         - Floating point preserves precision under multiplication in all but extreme cases, so
646           using floating point for time means that unit conversions are almost completely
647           lossless. This means that we don't have to think very hard about what units to use. In
648           this patch, we use seconds almost everywhere. We only convert at boundaries, like an API
649           boundary that wants something other than seconds.
650         
651         - Floating point makes it easy to reason about infinity, which is something that time code
652           wants to do a lot. Example: when would you like to timeout? Infinity please! This is the
653           most elegant way of having an API support both a timeout variant and a no-timeout
654           variant.
655
656         - Floating point does well-understood things when math goes wrong, and these things are
657           pretty well optimized to match what a mathematician would do when computing with real
658           numbers represented using scientific notation with a finite number of significant
659           digits. This means that time math under floating point looks like normal math. On the
660           other hand, std::chrono time math looks like garbage because you have to always check
661           for multiple possible UB corners whenever you touch large integers. Integers that
662           represent time are very likely to be large and you don't have to do much to overflow
663           them. At this time, based on the number of bugs we have already seen due to chrono
664           overflows, I am not certain that we even understand what are all of the corner cases
665           that we should even check for.
666         
667         This patch introduces a new set of timekeeping classes that are all based on double, and
668         all internally use seconds. These classes support algebraic typing. The classes are:
669         
670         - Seconds: this is for measuring a duration.
671         - WallTime: time since epoch according to a wall clock (aka real time clock).
672         - MonotonicTime: time since epoch according to a monotonic clock.
673         - ClockType: enum that says either Wall or Monotonic.
674         - TimeWithDynamicClockType: a tuple of double and ClockType, which represents either a
675           wall time or a monotonic time.
676         
677         All of these classes behave like C++ values and are cheap to copy around since they are
678         very nearly POD. This supports comprehensive conversions between the various time types.
679         Most of this is by way of algebra. Here are just some of the rules we recognize:
680         
681         WallTime = WallTime + Seconds
682         Seconds = WallTime - WallTime
683         MonotonicTime = MonotonicTime + Seconds
684         etc...
685         
686         We support negative, infinite, and NaN times because math.
687         
688         We support conversions between MonotonicTime and WallTime, like:
689         
690         WallTime wt = mt.approximateWallTime()
691         
692         This is called this "approximate" because the only way to do it is to get the current time
693         on both clocks and convert relative to that.
694         
695         Many of our APIs would be happy using whatever notion of time the user wanted to use. For
696         those APIs, which includes Condition and ParkingLot, we have TimeWithDynamicClockType. You
697         can automatically convert WallTime or MonotonicTime to TimeWithDynamicClockType. This
698         means that if you use a WallTime with Condition::waitUntil, then Condition's internal
699         logic for when it should wake up makes its decision based on the current WallTime - but if
700         you use MonotonicTime then waitUntil will make its decision based on current
701         MonotonicTime. This is a greater level of flexibility than chrono allowed, since chrono
702         did not have the concept of a dynamic clock type.
703         
704         This patch does not include conversions between std::chrono and these new time classes,
705         because past experience shows that we're quite bad at getting conversions between
706         std::chrono and anything else right. Also, I didn't need such conversion code because this
707         patch only converts code that transitively touches ParkingLot and Condition. It was easy
708         to get all of that code onto the new time classes.
709
710         * WTF.xcodeproj/project.pbxproj:
711         * wtf/AutomaticThread.cpp:
712         (WTF::AutomaticThread::start):
713         * wtf/CMakeLists.txt:
714         * wtf/ClockType.cpp: Added.
715         (WTF::printInternal):
716         * wtf/ClockType.h: Added.
717         * wtf/Condition.h:
718         (WTF::ConditionBase::waitUntil):
719         (WTF::ConditionBase::waitFor):
720         (WTF::ConditionBase::wait):
721         (WTF::ConditionBase::waitUntilWallClockSeconds): Deleted.
722         (WTF::ConditionBase::waitUntilMonotonicClockSeconds): Deleted.
723         (WTF::ConditionBase::waitForSeconds): Deleted.
724         (WTF::ConditionBase::waitForSecondsImpl): Deleted.
725         (WTF::ConditionBase::waitForImpl): Deleted.
726         (WTF::ConditionBase::absoluteFromRelative): Deleted.
727         * wtf/CrossThreadQueue.h:
728         (WTF::CrossThreadQueue<DataType>::waitForMessage):
729         * wtf/CurrentTime.cpp:
730         (WTF::sleep):
731         * wtf/MessageQueue.h:
732         (WTF::MessageQueue::infiniteTime): Deleted.
733         * wtf/MonotonicTime.cpp: Added.
734         (WTF::MonotonicTime::now):
735         (WTF::MonotonicTime::approximateWallTime):
736         (WTF::MonotonicTime::dump):
737         (WTF::MonotonicTime::sleep):
738         * wtf/MonotonicTime.h: Added.
739         (WTF::MonotonicTime::MonotonicTime):
740         (WTF::MonotonicTime::fromRawDouble):
741         (WTF::MonotonicTime::infinity):
742         (WTF::MonotonicTime::secondsSinceEpoch):
743         (WTF::MonotonicTime::approximateMonotonicTime):
744         (WTF::MonotonicTime::operator bool):
745         (WTF::MonotonicTime::operator+):
746         (WTF::MonotonicTime::operator-):
747         (WTF::MonotonicTime::operator+=):
748         (WTF::MonotonicTime::operator-=):
749         (WTF::MonotonicTime::operator==):
750         (WTF::MonotonicTime::operator!=):
751         (WTF::MonotonicTime::operator<):
752         (WTF::MonotonicTime::operator>):
753         (WTF::MonotonicTime::operator<=):
754         (WTF::MonotonicTime::operator>=):
755         * wtf/ParkingLot.cpp:
756         (WTF::ParkingLot::parkConditionallyImpl):
757         (WTF::ParkingLot::unparkOne):
758         (WTF::ParkingLot::unparkOneImpl):
759         (WTF::ParkingLot::unparkCount):
760         * wtf/ParkingLot.h:
761         (WTF::ParkingLot::parkConditionally):
762         (WTF::ParkingLot::compareAndPark):
763         * wtf/Seconds.cpp: Added.
764         (WTF::Seconds::operator+):
765         (WTF::Seconds::operator-):
766         (WTF::Seconds::dump):
767         (WTF::Seconds::sleep):
768         * wtf/Seconds.h: Added.
769         (WTF::Seconds::Seconds):
770         (WTF::Seconds::value):
771         (WTF::Seconds::seconds):
772         (WTF::Seconds::milliseconds):
773         (WTF::Seconds::microseconds):
774         (WTF::Seconds::nanoseconds):
775         (WTF::Seconds::fromMilliseconds):
776         (WTF::Seconds::fromMicroseconds):
777         (WTF::Seconds::fromNanoseconds):
778         (WTF::Seconds::infinity):
779         (WTF::Seconds::operator bool):
780         (WTF::Seconds::operator+):
781         (WTF::Seconds::operator-):
782         (WTF::Seconds::operator*):
783         (WTF::Seconds::operator/):
784         (WTF::Seconds::operator+=):
785         (WTF::Seconds::operator-=):
786         (WTF::Seconds::operator*=):
787         (WTF::Seconds::operator/=):
788         (WTF::Seconds::operator==):
789         (WTF::Seconds::operator!=):
790         (WTF::Seconds::operator<):
791         (WTF::Seconds::operator>):
792         (WTF::Seconds::operator<=):
793         (WTF::Seconds::operator>=):
794         * wtf/TimeWithDynamicClockType.cpp: Added.
795         (WTF::TimeWithDynamicClockType::now):
796         (WTF::TimeWithDynamicClockType::nowWithSameClock):
797         (WTF::TimeWithDynamicClockType::wallTime):
798         (WTF::TimeWithDynamicClockType::monotonicTime):
799         (WTF::TimeWithDynamicClockType::approximateWallTime):
800         (WTF::TimeWithDynamicClockType::approximateMonotonicTime):
801         (WTF::TimeWithDynamicClockType::operator-):
802         (WTF::TimeWithDynamicClockType::operator<):
803         (WTF::TimeWithDynamicClockType::operator>):
804         (WTF::TimeWithDynamicClockType::operator<=):
805         (WTF::TimeWithDynamicClockType::operator>=):
806         (WTF::TimeWithDynamicClockType::dump):
807         (WTF::TimeWithDynamicClockType::sleep):
808         * wtf/TimeWithDynamicClockType.h: Added.
809         (WTF::TimeWithDynamicClockType::TimeWithDynamicClockType):
810         (WTF::TimeWithDynamicClockType::fromRawDouble):
811         (WTF::TimeWithDynamicClockType::secondsSinceEpoch):
812         (WTF::TimeWithDynamicClockType::clockType):
813         (WTF::TimeWithDynamicClockType::withSameClockAndRawDouble):
814         (WTF::TimeWithDynamicClockType::operator bool):
815         (WTF::TimeWithDynamicClockType::operator+):
816         (WTF::TimeWithDynamicClockType::operator-):
817         (WTF::TimeWithDynamicClockType::operator+=):
818         (WTF::TimeWithDynamicClockType::operator-=):
819         (WTF::TimeWithDynamicClockType::operator==):
820         (WTF::TimeWithDynamicClockType::operator!=):
821         * wtf/WallTime.cpp: Added.
822         (WTF::WallTime::now):
823         (WTF::WallTime::approximateMonotonicTime):
824         (WTF::WallTime::dump):
825         (WTF::WallTime::sleep):
826         * wtf/WallTime.h: Added.
827         (WTF::WallTime::WallTime):
828         (WTF::WallTime::fromRawDouble):
829         (WTF::WallTime::infinity):
830         (WTF::WallTime::secondsSinceEpoch):
831         (WTF::WallTime::approximateWallTime):
832         (WTF::WallTime::operator bool):
833         (WTF::WallTime::operator+):
834         (WTF::WallTime::operator-):
835         (WTF::WallTime::operator+=):
836         (WTF::WallTime::operator-=):
837         (WTF::WallTime::operator==):
838         (WTF::WallTime::operator!=):
839         (WTF::WallTime::operator<):
840         (WTF::WallTime::operator>):
841         (WTF::WallTime::operator<=):
842         (WTF::WallTime::operator>=):
843         * wtf/threads/BinarySemaphore.cpp:
844         (WTF::BinarySemaphore::wait):
845         * wtf/threads/BinarySemaphore.h:
846
847 2016-11-03  Filip Pizlo  <fpizlo@apple.com>
848
849         DFG plays fast and loose with the shadow values of a Phi
850         https://bugs.webkit.org/show_bug.cgi?id=164309
851
852         Reviewed by Saam Barati.
853         
854         Made this API use size rather than maxIndex as its initialization parameter, because that's
855         less confusing.
856
857         * wtf/IndexSparseSet.h:
858         (WTF::IndexSparseSet<OverflowHandler>::IndexSparseSet):
859
860 2016-11-03  Commit Queue  <commit-queue@webkit.org>
861
862         Unreviewed, rolling out r208364.
863         https://bugs.webkit.org/show_bug.cgi?id=164402
864
865         broke the build (Requested by smfr on #webkit).
866
867         Reverted changeset:
868
869         "DFG plays fast and loose with the shadow values of a Phi"
870         https://bugs.webkit.org/show_bug.cgi?id=164309
871         http://trac.webkit.org/changeset/208364
872
873 2016-11-03  Filip Pizlo  <fpizlo@apple.com>
874
875         DFG plays fast and loose with the shadow values of a Phi
876         https://bugs.webkit.org/show_bug.cgi?id=164309
877
878         Reviewed by Saam Barati.
879         
880         Made this API use size rather than maxIndex as its initialization parameter, because that's
881         less confusing.
882
883         * wtf/IndexSparseSet.h:
884         (WTF::IndexSparseSet<OverflowHandler>::IndexSparseSet):
885
886 2016-11-03  Konstantin Tokarev  <annulen@yandex.ru>
887
888         Fixes to build JSCOnly on macOS
889         https://bugs.webkit.org/show_bug.cgi?id=164379
890
891         Reviewed by Michael Catanzaro.
892
893         * wtf/Platform.h: JSCOnly port should not provide any PLATFORM() macro
894
895 2016-11-03  Brady Eidson  <beidson@apple.com>
896
897         IndexedDB 2.0: Support binary keys.
898         <rdar://problem/28806927> and https://bugs.webkit.org/show_bug.cgi?id=164359
899
900         Reviewed by Alex Christensen.
901
902         * wtf/Hasher.h:
903         (WTF::StringHasher::hashMemory): Teach hashMemory() to handle buffers with odd lengths.
904
905 2016-11-02  Filip Pizlo  <fpizlo@apple.com>
906
907         The GC should be in a thread
908         https://bugs.webkit.org/show_bug.cgi?id=163562
909
910         Reviewed by Geoffrey Garen and Andreas Kling.
911         
912         This fixes some bugs and adds a few features.
913
914         * wtf/Atomics.h: The GC may do work on behalf of the JIT. If it does, the main thread needs to execute a cross-modifying code fence. This is cpuid on x86 and I believe it's isb on ARM. It would have been an isync on PPC and I think that isb is the ARM equivalent.
915         (WTF::arm_isb):
916         (WTF::crossModifyingCodeFence):
917         (WTF::x86_ortop):
918         (WTF::x86_cpuid):
919         * wtf/AutomaticThread.cpp: I accidentally had AutomaticThreadCondition inherit from ThreadSafeRefCounted<AutomaticThread> [sic]. This never crashed before because all of our prior AutomaticThreadConditions were immortal.
920         (WTF::AutomaticThread::AutomaticThread):
921         (WTF::AutomaticThread::~AutomaticThread):
922         (WTF::AutomaticThread::start):
923         * wtf/AutomaticThread.h:
924         * wtf/MainThread.cpp: Need to allow initializeGCThreads() to be called separately because it's now more than just a debugging thing.
925         (WTF::initializeGCThreads):
926
927 2016-11-02  Carlos Alberto Lopez Perez  <clopez@igalia.com>
928
929         Clean wrong comment about compositing on the UI process.
930         https://bugs.webkit.org/show_bug.cgi?id=164339
931
932         Reviewed by Michael Catanzaro.
933
934         * wtf/Platform.h: The comment about compositing on the UI process
935         was added on r109302 but was not removed properly when the Qt port
936         was removed from trunk.
937         USE_PROTECTION_SPACE_AUTH_CALLBACK has nothing to do with it.
938
939 2016-11-02  Alex Christensen  <achristensen@webkit.org>
940
941         Remove Battery Status API from the tree
942         https://bugs.webkit.org/show_bug.cgi?id=164213
943
944         Reviewed by Sam Weinig.
945
946         * wtf/FeatureDefines.h:
947
948 2016-11-02  Romain Bellessort  <romain.bellessort@crf.canon.fr>
949
950         [Readable Streams API] Enable creation of ReadableByteStreamController
951         https://bugs.webkit.org/show_bug.cgi?id=164014
952
953         Reviewed by Youenn Fablet.
954
955         Added flag for the byte stream part of Readable Streams API.
956
957         * wtf/FeatureDefines.h:
958
959 2016-11-02  Per Arne Vollan  <pvollan@apple.com>
960
961         [Win] Copy build results to AAS 'Program Files' folder.
962         https://bugs.webkit.org/show_bug.cgi?id=164273
963
964         Reviewed by Brent Fulgham.
965
966         The preferred location for the binaries is the AAS 'Program Files' folder.
967
968         * WTF.vcxproj/WTF.proj:
969
970 2016-10-29  Filip Pizlo  <fpizlo@apple.com>
971
972         JSC should support SharedArrayBuffer
973         https://bugs.webkit.org/show_bug.cgi?id=163986
974
975         Reviewed by Keith Miller.
976         
977         Adds some small things we need for SharedArrayBuffer.
978         
979         * wtf/Atomics.h:
980         (WTF::Atomic::compareExchangeWeakRelaxed):
981         (WTF::Atomic::exchangeAdd):
982         (WTF::Atomic::exchangeAnd):
983         (WTF::Atomic::exchangeOr):
984         (WTF::Atomic::exchangeSub):
985         (WTF::Atomic::exchangeXor):
986         (WTF::atomicLoad):
987         (WTF::atomicStore):
988         (WTF::atomicCompareExchangeWeak):
989         (WTF::atomicCompareExchangeWeakRelaxed):
990         (WTF::atomicCompareExchangeStrong):
991         (WTF::atomicExchangeAdd):
992         (WTF::atomicExchangeAnd):
993         (WTF::atomicExchangeOr):
994         (WTF::atomicExchangeSub):
995         (WTF::atomicExchangeXor):
996         (WTF::atomicExchange):
997         (WTF::Atomic::exchangeAndAdd): Deleted.
998         (WTF::weakCompareAndSwap): Deleted.
999         We need to be able to do atomics operations on naked pointers. We also need to be able to do
1000         all of the things that std::atomic does. This adds those things and renames
1001         weakCompareAndSwap to atomicCompareExchangeWeakRelaxed so that we're using consistent
1002         terminology.
1003         
1004         * wtf/Bitmap.h:
1005         (WTF::WordType>::concurrentTestAndSet): Renamed weakCompareAndSwap.
1006         (WTF::WordType>::concurrentTestAndClear): Renamed weakCompareAndSwap.
1007         * wtf/FastBitVector.h:
1008         (WTF::FastBitVector::atomicSetAndCheck): Renamed weakCompareAndSwap.
1009         * wtf/ParkingLot.cpp:
1010         (WTF::ParkingLot::unparkOne):
1011         (WTF::ParkingLot::unparkCount):
1012         * wtf/ParkingLot.h:
1013         Added unparkCount(), which lets you unpark some bounded number of threads and returns the
1014         number of threads unparked. This is just a modest extension of unparkAll(). unparkAll() now
1015         just calls unparkCount(ptr, UINT_MAX).
1016
1017 2016-10-30  Frederic Wang  <fwang@igalia.com>
1018
1019         Use HarfBuzz ot-math API to parse the OpenType MATH table
1020         https://bugs.webkit.org/show_bug.cgi?id=162671
1021
1022         Reviewed by Michael Catanzaro.
1023
1024         * wtf/Platform.h: By default, do not enable internal OpenType MATH parsing on GTK.
1025
1026 2016-10-25  Mark Lam  <mark.lam@apple.com>
1027
1028         String.prototype.replace() should throw an OutOfMemoryError when using too much memory.
1029         https://bugs.webkit.org/show_bug.cgi?id=163996
1030         <rdar://problem/28263117>
1031
1032         Reviewed by Geoffrey Garen.
1033
1034         * wtf/Vector.h:
1035         (WTF::minCapacity>::tryConstructAndAppend):
1036         (WTF::minCapacity>::tryConstructAndAppendSlowCase):
1037         - Added try versions of constructAndAppend() so that we can handle the failure
1038           to allocate more gracefully.
1039
1040 2016-10-25  Konstantin Tokarev  <annulen@yandex.ru>
1041
1042         Non-specialized version of deleteObject should not have template argument
1043         https://bugs.webkit.org/show_bug.cgi?id=163943
1044
1045         Reviewed by Anders Carlsson.
1046
1047         Fixes compilation of GDIObject.h with MinGW
1048
1049         * wtf/win/GDIObject.h:
1050         (WTF::deleteObject):
1051
1052 2016-10-24  Per Arne Vollan  <pvollan@apple.com>
1053
1054         [Win] CMake build type is not set.
1055         https://bugs.webkit.org/show_bug.cgi?id=163917
1056
1057         Reviewed by Alex Christensen.
1058
1059         The CMAKE_BUILD_TYPE variable should be set to Debug or Release.
1060
1061         * WTF.vcxproj/WTF.proj:
1062
1063 2016-10-23  Yusuke Suzuki  <utatane.tea@gmail.com>
1064
1065         [DOMJIT] Add a way for DOMJIT::Patchpoint to express effects
1066         https://bugs.webkit.org/show_bug.cgi?id=163657
1067
1068         Reviewed by Saam Barati.
1069
1070         Simplify nonEmptyRangesOverlap.
1071
1072         * wtf/MathExtras.h:
1073         (WTF::nonEmptyRangesOverlap):
1074
1075 2016-10-23  Chris Dumez  <cdumez@apple.com>
1076
1077         Another unreviewed attempt to fix the WatchOS / TvOS build after r207585.
1078         <rdar://problem/28902292>
1079
1080         Disable USE_CFURLCONNECTION on newer WatchOS / TvOS.
1081
1082         * wtf/Platform.h:
1083
1084 2016-10-20  Keith Miller  <keith_miller@apple.com>
1085
1086         Add support for WASM calls
1087         https://bugs.webkit.org/show_bug.cgi?id=161727
1088
1089         Reviewed by Filip Pizlo and Michael Saboff.
1090
1091         Added a new decodeUInt64. Also, added WTF::LEBDecoder namespace.
1092
1093         * wtf/LEBDecoder.h:
1094         (WTF::LEBDecoder::decodeUInt):
1095         (WTF::LEBDecoder::decodeUInt32):
1096         (WTF::LEBDecoder::decodeUInt64):
1097         (WTF::LEBDecoder::decodeInt32):
1098         (decodeUInt32): Deleted.
1099         (decodeInt32): Deleted.
1100
1101 2016-10-20  Filip Pizlo  <fpizlo@apple.com>
1102
1103         The tracking of the coarse-grain Heap state (allocating or not, collector or not, eden vs full) should respect the orthogonality between allocating and collecting
1104         https://bugs.webkit.org/show_bug.cgi?id=163738
1105
1106         Reviewed by Geoffrey Garen.
1107         
1108         There will soon be different kinds of GC threads, and WTF's "are you a GC thread" thing
1109         should know about this.
1110
1111         * wtf/MainThread.cpp:
1112         (WTF::initializeGCThreads):
1113         (WTF::registerGCThread):
1114         (WTF::mayBeGCThread):
1115         * wtf/MainThread.h:
1116
1117 2016-10-19  Sam Weinig  <sam@webkit.org>
1118
1119         Add convenience function that combines WTF::visit(...) with WTF::makeVisitor(...)
1120         https://bugs.webkit.org/show_bug.cgi?id=163713
1121
1122         Reviewed by Dan Bernstein.
1123
1124         - Add WTF::switchOn which merges WTF::visit with WTF::makeVisitor in the following
1125           way:
1126                 WTF::visit(WTF::makeVisitor(...), variant)
1127
1128         * wtf/Variant.h:
1129         (WTF::switchOn):
1130
1131 2016-10-19  Alex Christensen  <achristensen@webkit.org>
1132
1133         Revert r207151
1134         https://bugs.webkit.org/show_bug.cgi?id=163675
1135
1136         Reviewed by Brent Fulgham.
1137
1138         * wtf/Platform.h:
1139         * wtf/SchedulePair.h:
1140         * wtf/SchedulePairMac.mm:
1141
1142 2016-10-19  Filip Pizlo  <fpizlo@apple.com>
1143
1144         REGRESSION (r207480): 3 Dromaeo tests failing
1145         https://bugs.webkit.org/show_bug.cgi?id=163633
1146
1147         Reviewed by Mark Lam.
1148         
1149         It's a ParkingLot bug: if we timeout and get unparked at the same time, then the unparking
1150         thread will clear our address eventually - but not immediately. This causes a nasty
1151         assertion failure. The tricky thing is that when we detect this, we need to wait until that
1152         unparking thread does the deed. Otherwise, they will still do it at some later time.
1153         
1154         Alternatively, we could use some kind of versioning to detect this - increment the version
1155         when you park, so that unparking threads will know if they are time travelers. That seems
1156         more yucky.
1157         
1158         I don't think it matters too much what we do here, so long as it's simple and correct, since
1159         this requires a race that is rare enough that it didn't happen once in my testing, and I was
1160         pretty thorough. For example, it didn't happen once in 15 runs of JetStream. The race is
1161         rare because it requires the timeout to happen right as someone else is unparking. Since
1162         it's so rare, its probably OK that the unparked thread waits just a tiny moment until the
1163         unparking thread is done.
1164
1165         * wtf/ParkingLot.cpp:
1166         (WTF::ParkingLot::parkConditionallyImpl):
1167         (WTF::ParkingLot::unparkOneImpl):
1168
1169 2016-10-19  Filip Pizlo  <fpizlo@apple.com>
1170
1171         Baseline JIT should use AutomaticThread
1172         https://bugs.webkit.org/show_bug.cgi?id=163686
1173
1174         Reviewed by Geoffrey Garen.
1175         
1176         Added a AutomaticThreadCondition::wait() method, so that if you really want to use one
1177         common condition for your thread and something else, you can do it. This trivially works
1178         if you only use notifyAll(), and behaves as you'd expect for notifyOne() (i.e. it's
1179         dangerous, since you don't know who will wake up).
1180         
1181         The Baseline JIT used the one-true-Condition idiom because it used notifyAll() in an
1182         optimal way: there are just two threads talking to each other, so it wakes up at most one
1183         thread and that thread is exactly the one you want woken up. Adding wait() means that I did
1184         not have to change that code.
1185
1186         * wtf/AutomaticThread.cpp:
1187         (WTF::AutomaticThreadCondition::wait):
1188         * wtf/AutomaticThread.h:
1189
1190 2016-10-18  Filip Pizlo  <fpizlo@apple.com>
1191
1192         DFG worklist should use AutomaticThread
1193         https://bugs.webkit.org/show_bug.cgi?id=163615
1194
1195         Reviewed by Mark Lam.
1196         
1197         This adds new functionality to AutomaticThread to support DFG::Worklist:
1198         
1199         - AutomaticThread::threadDidStart/threadWillStop virtual methods called at the start and end
1200           of a thread's lifetime. This allows Worklist to tie some resources to the life of the
1201           thread, and also means that now those resources will naturally free up when the Worklist is
1202           not in use.
1203         
1204         - AutomaticThreadCondition::notifyOne(). This required changes to Condition::notifyOne(). We
1205           need to know if the Condition woke up anyone. If it didn't, then we need to launch one of
1206           our threads.
1207
1208         * wtf/AutomaticThread.cpp:
1209         (WTF::AutomaticThreadCondition::notifyOne):
1210         (WTF::AutomaticThread::ThreadScope::ThreadScope):
1211         (WTF::AutomaticThread::ThreadScope::~ThreadScope):
1212         (WTF::AutomaticThread::start):
1213         (WTF::AutomaticThread::threadDidStart):
1214         (WTF::AutomaticThread::threadWillStop):
1215         * wtf/AutomaticThread.h:
1216         * wtf/Condition.h:
1217         (WTF::ConditionBase::notifyOne):
1218
1219 2016-10-18  Sam Weinig  <sam@webkit.org>
1220
1221         Replace std::experimental::variant with WTF::Variant (or similar)
1222         https://bugs.webkit.org/show_bug.cgi?id=163626
1223
1224         Reviewed by Chris Dumez.
1225
1226         Rename std::experimental::variant, Variant. Move helpers get/holds_alternative/etc.
1227         into the WTF namespace.
1228
1229         * wtf/Forward.h:
1230         * wtf/Variant.h:
1231
1232 2016-10-18  Filip Pizlo  <fpizlo@apple.com>
1233
1234         WTF should make it easier to create threads that die automatically after inactivity
1235         https://bugs.webkit.org/show_bug.cgi?id=163576
1236
1237         Reviewed by Andreas Kling.
1238         
1239         For a long time now, I've been adding threads to WTF/JSC and each time I do this, I feel
1240         guilty because those threads don't shut down when they are inactive. For example, in bug
1241         163562, I need to add a new GC thread. There will be one of them per VM. This means that a
1242         JSC API client that starts a lot of VMs will have a lot of threads. I don't think that's
1243         good.
1244         
1245         A common pattern for all of these threads is that they have some well-defined trigger that
1246         causes them to run. This trigger has a lock, a condition variable, some logic that determines
1247         if there is work to do, and then of course the logic for the thread's actual work. The thread
1248         bodies usually look like this:
1249         
1250         void Thingy::runThread()
1251         {
1252             for (;;) {
1253                 Work work;
1254                 {
1255                     LockHolder locker(m_lock);
1256                     while (!hasWork())
1257                         m_cond.wait(m_lock);
1258                     work = takeWork();
1259                 }
1260                 doWork(work);
1261             }
1262         }
1263         
1264         If you look at ParallelHelperPool (the GC's threads) and DFG::Worklist (some of the JIT's
1265         threads), you will see this pattern.
1266         
1267         This change adds a new kind of thread, called AutomaticThread, that lets you write threads to
1268         this pattern while getting automatic thread shutdown for free: instead of just waiting on a
1269         condition variable, AutomaticThread will have a timeout that causes the thread to die. The
1270         condition variable associated with AutomaticThread, called AutomaticThreadCondition, is smart
1271         enough to restart any threads that have decided to stop due to inactivity. The inactivity
1272         threshold is current just 1 second.
1273         
1274         In this patch I only adopt AutomaticThread for ParallelHelperPool. I plan to adopt it in more
1275         places soon.
1276
1277         * WTF.xcodeproj/project.pbxproj:
1278         * wtf/AutomaticThread.cpp: Added.
1279         (WTF::AutomaticThreadCondition::create):
1280         (WTF::AutomaticThreadCondition::AutomaticThreadCondition):
1281         (WTF::AutomaticThreadCondition::~AutomaticThreadCondition):
1282         (WTF::AutomaticThreadCondition::notifyAll):
1283         (WTF::AutomaticThreadCondition::add):
1284         (WTF::AutomaticThreadCondition::remove):
1285         (WTF::AutomaticThreadCondition::contains):
1286         (WTF::AutomaticThread::AutomaticThread):
1287         (WTF::AutomaticThread::~AutomaticThread):
1288         (WTF::AutomaticThread::join):
1289         (WTF::AutomaticThread::start):
1290         * wtf/AutomaticThread.h: Added.
1291         * wtf/CMakeLists.txt:
1292         * wtf/ParallelHelperPool.cpp:
1293         (WTF::ParallelHelperClient::ParallelHelperClient):
1294         (WTF::ParallelHelperClient::~ParallelHelperClient):
1295         (WTF::ParallelHelperClient::setTask):
1296         (WTF::ParallelHelperClient::finish):
1297         (WTF::ParallelHelperClient::doSomeHelping):
1298         (WTF::ParallelHelperClient::runTask):
1299         (WTF::ParallelHelperPool::ParallelHelperPool):
1300         (WTF::ParallelHelperPool::~ParallelHelperPool):
1301         (WTF::ParallelHelperPool::ensureThreads):
1302         (WTF::ParallelHelperPool::doSomeHelping):
1303         (WTF::ParallelHelperPool::Thread::Thread):
1304         (WTF::ParallelHelperPool::didMakeWorkAvailable):
1305         (WTF::ParallelHelperPool::helperThreadBody): Deleted.
1306         (WTF::ParallelHelperPool::waitForClientWithTask): Deleted.
1307         * wtf/ParallelHelperPool.h:
1308
1309 2016-10-18  Said Abou-Hallawa  <sabouhallawa@apple.com>
1310
1311         SVGCSSParser: m_implicitShorthand value is not reset after adding the shorthand property
1312         https://bugs.webkit.org/show_bug.cgi?id=116470
1313
1314         Reviewed by Simon Fraser.
1315
1316         * wtf/TemporaryChange.h:
1317         (WTF::TemporaryChange::TemporaryChange):
1318         Add a new constructor to make TemporaryChange work as a restorer. The
1319         temporary change will happen after we construct the object.
1320
1321 2016-10-17  Simon Fraser  <simon.fraser@apple.com>
1322
1323         Implement DOMRect/DOMRectReadOnly
1324         https://bugs.webkit.org/show_bug.cgi?id=163464
1325
1326         Reviewed by Darin Adler.
1327         
1328         Implement min()/max() in a way that follows Math.min/Math.max, which return
1329         NaN if either argument is NaN.
1330
1331         * wtf/MathExtras.h:
1332         (WTF::nanPropagatingMin):
1333         (WTF::nanPropagatingMax):
1334
1335 2016-10-15  Sam Weinig  <sam@webkit.org>
1336
1337         MessageEvent's source property should be a (DOMWindow or MessagePort)? rather than a EventTarget?
1338         https://bugs.webkit.org/show_bug.cgi?id=163475
1339
1340         Reviewed by Simon Fraser.
1341
1342         * wtf/Variant.h:
1343         Add missing return statement that was tripping up some compilers.
1344
1345 2016-10-12  Ryan Haddad  <ryanhaddad@apple.com>
1346
1347         Unreviewed, rolling out r207225.
1348
1349         This change causes debug tests to exit early with crashes.
1350
1351         Reverted changeset:
1352
1353         "Optional's move-constructor and move-assignment operator
1354         don't disengage the value being moved from"
1355         https://bugs.webkit.org/show_bug.cgi?id=163309
1356         http://trac.webkit.org/changeset/207225
1357
1358 2016-10-11  Sam Weinig  <sam@webkit.org>
1359
1360         Optional's move-constructor and move-assignment operator don't disengage the value being moved from
1361         https://bugs.webkit.org/show_bug.cgi?id=163309
1362
1363         Reviewed by Anders Carlsson.
1364
1365         * wtf/Optional.h:
1366         (WTF::Optional::Optional):
1367         (WTF::Optional::operator=):
1368         Disengage 'other' on move-construction and move-assignment.
1369
1370 2016-10-08  Filip Pizlo  <fpizlo@apple.com>
1371
1372         MarkedBlock should know what objects are live during marking
1373         https://bugs.webkit.org/show_bug.cgi?id=162309
1374
1375         Reviewed by Geoffrey Garen.
1376         
1377         This removes the atomicity mode, because it's not really used: it only affects the
1378         concurrentBlah methods, but their only users turn on atomicity. This was useful because
1379         previously, some binary Bitmap methods (like merge(const Bitmap&)) couldn't be used
1380         effectively in the GC because some of the GC's bitmaps set the atomic mode and some didn't.
1381         Removing this useless mode is the best solution.
1382         
1383         Also added some new binary Bitmap methods: mergeAndClear(Bitmap& other) and
1384         setAndClear(Bitmap& other). They perform their action on 'this' (either merge or set,
1385         respectively) while also clearing the contents of 'other'. This is great for one of the GC
1386         hot paths.
1387
1388         * wtf/Bitmap.h:
1389         (WTF::WordType>::Bitmap):
1390         (WTF::WordType>::get):
1391         (WTF::WordType>::set):
1392         (WTF::WordType>::testAndSet):
1393         (WTF::WordType>::testAndClear):
1394         (WTF::WordType>::concurrentTestAndSet):
1395         (WTF::WordType>::concurrentTestAndClear):
1396         (WTF::WordType>::clear):
1397         (WTF::WordType>::clearAll):
1398         (WTF::WordType>::nextPossiblyUnset):
1399         (WTF::WordType>::findRunOfZeros):
1400         (WTF::WordType>::count):
1401         (WTF::WordType>::isEmpty):
1402         (WTF::WordType>::isFull):
1403         (WTF::WordType>::merge):
1404         (WTF::WordType>::filter):
1405         (WTF::WordType>::exclude):
1406         (WTF::WordType>::forEachSetBit):
1407         (WTF::WordType>::mergeAndClear):
1408         (WTF::WordType>::setAndClear):
1409         (WTF::=):
1410         (WTF::WordType>::hash):
1411
1412 2016-10-11  Said Abou-Hallawa  <sabouhallawa@apple.com>
1413
1414         Add SynchronizedFixedQueue class
1415         https://bugs.webkit.org/show_bug.cgi?id=162478
1416
1417         Reviewed by Geoffrey Garen.
1418
1419         This class represents a simple producer/consumer worker. It facilitates
1420         synchronizing enqueuing to and dequeuing from a fixed size-queue. It uses
1421         a single lock and a single condition to synchronize all its members among
1422         the working threads. This means a single thread is active at any time and
1423         and the other threads are blocked waiting for the lock to be released. Or
1424         they are sleeping waiting for the condition to be satisfied.
1425
1426         * WTF.xcodeproj/project.pbxproj:
1427         * wtf/SynchronizedFixedQueue.h: Added.
1428         (WTF::SynchronizedFixedQueue::SynchronizedFixedQueue):
1429         (WTF::SynchronizedFixedQueue::open): Restore the queue to its original state.
1430         (WTF::SynchronizedFixedQueue::close): Wake all the sleeping threads with a closing state.
1431         (WTF::SynchronizedFixedQueue::isOpen): Does the queue accept new items?
1432         (WTF::SynchronizedFixedQueue::enqueue): Enqueue an item into the queue.
1433         (WTF::SynchronizedFixedQueue::dequeue): Dequeue an item form the queue.
1434
1435 2016-10-11  Alex Christensen  <achristensen@webkit.org>
1436
1437         Remove dead networking code
1438         https://bugs.webkit.org/show_bug.cgi?id=163263
1439
1440         Reviewed by Daniel Bates.
1441
1442         * wtf/Platform.h:
1443         * wtf/SchedulePair.h:
1444         * wtf/SchedulePairMac.mm:
1445
1446 2016-10-10  Zan Dobersek  <zdobersek@igalia.com>
1447
1448         Add ENABLE_ENCRYPTED_MEDIA configuration option
1449         https://bugs.webkit.org/show_bug.cgi?id=163219
1450
1451         Reviewed by Darin Adler.
1452
1453         * wtf/FeatureDefines.h:
1454         If undefined, define the ENABLE_ENCRYPTED_MEDIA option to 0.
1455
1456 2016-10-10  Yusuke Suzuki  <utatane.tea@gmail.com>
1457
1458         [DOMJIT] Implement Node accessors in DOMJIT
1459         https://bugs.webkit.org/show_bug.cgi?id=163005
1460
1461         Reviewed by Filip Pizlo.
1462
1463         Add CAST_OFFSET. It is not necessary for JSCell thingy
1464         since we don't use virtual member functions. However, it
1465         is not true for WebCore DOM wrapped objects.
1466
1467         * wtf/StdLibExtras.h:
1468
1469 2016-10-07  Chris Dumez  <cdumez@apple.com>
1470
1471         window.navigator.language incorrectly returns all lowercase string
1472         https://bugs.webkit.org/show_bug.cgi?id=163096
1473
1474         Reviewed by Darin Adler.
1475
1476         Update platformUserPreferredLanguages() so that it no longer lowercases
1477         the string it returns. On Mac, we rely on CFLocale which returns
1478         BCP-47 language tags as per:
1479         - https://developer.apple.com/reference/corefoundation/1666963-cflocale?language=objc
1480
1481         * wtf/PlatformUserPreferredLanguagesMac.mm:
1482         (WTF::httpStyleLanguageCode):
1483         * wtf/PlatformUserPreferredLanguagesUnix.cpp:
1484         (WTF::platformLanguage):
1485
1486 2016-10-06  Brent Fulgham  <bfulgham@apple.com>
1487
1488         [Win][Direct2D] Add Direct2D CMake rules
1489         https://bugs.webkit.org/show_bug.cgi?id=162925
1490
1491         Reviewed by Brent Fulgham.
1492
1493         * wtf/Platform.h: Don't USE(CA) or USE(CG) if building
1494         with Direct2D.
1495
1496 2016-10-05  Yusuke Suzuki  <utatane.tea@gmail.com>
1497
1498         [DOMJIT] Add initial CheckDOM and CallDOM implementations
1499         https://bugs.webkit.org/show_bug.cgi?id=162941
1500
1501         Reviewed by Filip Pizlo.
1502
1503         * wtf/Box.h:
1504         (WTF::Box::Box):
1505
1506 2016-10-05  Zan Dobersek  <zdobersek@igalia.com>
1507
1508         Rename ENABLE_ENCRYPTED_MEDIA_V2 to ENABLE_LEGACY_ENCRYPTED_MEDIA
1509         https://bugs.webkit.org/show_bug.cgi?id=162903
1510
1511         Reviewed by Alex Christensen.
1512
1513         Rename build guards for the remaining implementation of the legacy EME API
1514         to ENABLE_LEGACY_ENCRYPTED_MEDIA. This will allow for the future implementation
1515         of the near-finished API to be guarded with the simple ENABLE_ENCRYPTED_MEDIA guards.
1516
1517         * wtf/FeatureDefines.h:
1518
1519 2016-10-04  Saam Barati  <sbarati@apple.com>
1520
1521         String.prototype.toLowerCase should be a DFG/FTL intrinsic
1522         https://bugs.webkit.org/show_bug.cgi?id=162887
1523
1524         Reviewed by Filip Pizlo and Yusuke Suzuki.
1525
1526         This patch exposes a new StringImpl function called convertToLowercaseWithoutLocaleStartingAtFailingIndex8Bit
1527         which extracts slow path for the 8-bit part of convertToLowercaseWithoutLocale
1528         into a helper function. I decided to extract this into its own function because
1529         it may be the case that JSCs JITs will want to continue the operation
1530         after it has already ensured that part of an 8-bit string is lower case.
1531
1532         * wtf/text/StringImpl.cpp:
1533         (WTF::StringImpl::convertToLowercaseWithoutLocale):
1534         (WTF::StringImpl::convertToLowercaseWithoutLocaleStartingAtFailingIndex8Bit):
1535         * wtf/text/StringImpl.h:
1536         * wtf/text/WTFString.cpp:
1537         (WTF::String::convertToLowercaseWithoutLocaleStartingAtFailingIndex8Bit):
1538         * wtf/text/WTFString.h:
1539
1540 2016-10-04  Chris Dumez  <cdumez@apple.com>
1541
1542         Implement KeyboardEvent.code from the UI Event spec
1543         https://bugs.webkit.org/show_bug.cgi?id=149584
1544
1545         Reviewed by Darin Adler.
1546
1547         Add build time flag to toggle support for the code attribute on
1548         KeyboardEvent and only enable it on Mac for now, given that the
1549         implementation is missing on other platforms.
1550
1551         * wtf/FeatureDefines.h:
1552
1553 2016-10-03  Chris Dumez  <cdumez@apple.com>
1554
1555         Add support for KeyboardEvent.key attribute
1556         https://bugs.webkit.org/show_bug.cgi?id=36267
1557
1558         Reviewed by Darin Adler.
1559
1560         Add compile time flag for the key attribute on KeyboardEvent and enable
1561         it on Cocoa only.
1562
1563         * wtf/FeatureDefines.h:
1564
1565 2016-09-29  Sam Weinig  <sam@webkit.org>
1566
1567         Add initial support for IDL union conversion
1568         https://bugs.webkit.org/show_bug.cgi?id=161576
1569
1570         Reviewed by Chris Dumez.
1571
1572         * WTF.xcodeproj/project.pbxproj:
1573         * wtf/CMakeLists.txt:
1574         Add Brigand.h
1575
1576         * wtf/Brigand.h: Added.
1577         Import a standalone copy of Edouard Alligand and Joel Falcou's 
1578         Brigand library for help with for help with list based meta programming
1579
1580         * wtf/StdLibExtras.h:
1581         Add a new three new type traits, IsTemplate, IsBaseOfTemplate and RemoveCVAndReference.
1582         - IsTemplate acts like std::is_class, but works with a generic base.
1583         - IsBaseOfTemplate acts like std::is_base_of, but works with a generic base.
1584         - RemoveCVAndReference combines std::remove_cv and std::remove_reference.
1585
1586 2016-09-30  Filip Pizlo  <fpizlo@apple.com>
1587
1588         B3::moveConstants should be able to edit code to minimize the number of constants
1589         https://bugs.webkit.org/show_bug.cgi?id=162764
1590
1591         Reviewed by Saam Barati.
1592         
1593         I thought it would be a good idea to document the fact that dominator traversal happens in a
1594         particular order for a reason.
1595
1596         * wtf/Dominators.h:
1597
1598 2016-09-29  Filip Pizlo  <fpizlo@apple.com>
1599
1600         Air should have a way of expressing additional instruction flags
1601         https://bugs.webkit.org/show_bug.cgi?id=162699
1602
1603         Reviewed by Mark Lam.
1604
1605         * wtf/CommaPrinter.h:
1606         (WTF::CommaPrinter::CommaPrinter):
1607         (WTF::CommaPrinter::dump):
1608         (WTF::CommaPrinter::didPrint):
1609
1610 2016-09-30  Youenn Fablet  <youenn@apple.com>
1611
1612         Add a way to go from a RefPtr<T> to Ref<const T>
1613         https://bugs.webkit.org/show_bug.cgi?id=162683
1614
1615         Reviewed by Alex Christensen.
1616
1617         * wtf/RefPtr.h:
1618         (WTF::RefPtr::releaseConstNonNull): Added.
1619
1620 2016-09-29  Mark Lam  <mark.lam@apple.com>
1621
1622         Re-enable StringView life-cycle checking.
1623         https://bugs.webkit.org/show_bug.cgi?id=160384
1624         <rdar://problem/28479434>
1625
1626         Reviewed by Saam Barati.
1627
1628         Re-landing after slow running tests have been resolved.
1629
1630         * wtf/text/StringView.h:
1631
1632 2016-09-29  Commit Queue  <commit-queue@webkit.org>
1633
1634         Unreviewed, rolling out r206563.
1635         https://bugs.webkit.org/show_bug.cgi?id=162732
1636
1637         Caused stress/op_*.js.ftl-no-cjit tests to time out (Requested
1638         by ryanhaddad on #webkit).
1639
1640         Reverted changeset:
1641
1642         "Re-enable StringView life-cycle checking."
1643         https://bugs.webkit.org/show_bug.cgi?id=160384
1644         http://trac.webkit.org/changeset/206563
1645
1646 2016-09-29  Fujii Hironori  <Hironori.Fujii@sony.com>
1647
1648         Clang 3.9 reports a compilation warning about ENABLE_EXCEPTION_SCOPE_VERIFICATION
1649         https://bugs.webkit.org/show_bug.cgi?id=162718
1650
1651         Reviewed by Alex Christensen.
1652
1653         Clang 3.9 reports a following compilation warning:
1654           Source/JavaScriptCore/runtime/VM.h:656:5: warning: macro expansion producing 'defined' has undefined behavior [-Wexpansion-to-defined]
1655
1656         * wtf/Platform.h: Changed the definition of ENABLE_EXCEPTION_SCOPE_VERIFICATION not to use 'defined'.
1657
1658 2016-09-28  Mark Lam  <mark.lam@apple.com>
1659
1660         Re-enable StringView life-cycle checking.
1661         https://bugs.webkit.org/show_bug.cgi?id=160384
1662         <rdar://problem/28479434>
1663
1664         Reviewed by Saam Barati.
1665
1666         * wtf/text/StringView.h:
1667
1668 2016-09-28  Filip Pizlo  <fpizlo@apple.com>
1669
1670         The write barrier should be down with TSO
1671         https://bugs.webkit.org/show_bug.cgi?id=162316
1672
1673         Reviewed by Geoffrey Garen.
1674         
1675         Added clearRange(), which quickly clears a range of bits. This turned out to be useful for
1676         a DFG optimization pass.
1677
1678         * wtf/FastBitVector.cpp:
1679         (WTF::FastBitVector::clearRange):
1680         * wtf/FastBitVector.h:
1681
1682 2016-09-28  Mark Lam  <mark.lam@apple.com>
1683
1684         Fix race condition in StringView's UnderlyingString lifecycle management.
1685         https://bugs.webkit.org/show_bug.cgi?id=162702
1686
1687         Reviewed by Geoffrey Garen.
1688
1689         There 2 relevant functions at play:
1690
1691         void StringView::setUnderlyingString(const StringImpl* string)
1692         {
1693             UnderlyingString* underlyingString;
1694             if (!string)
1695                 underlyingString = nullptr;
1696             else {
1697                 std::lock_guard<StaticLock> lock(underlyingStringsMutex);
1698                 auto result = underlyingStrings().add(string, nullptr);
1699                 if (result.isNewEntry)
1700                     result.iterator->value = new UnderlyingString(*string);
1701                 else
1702                     ++result.iterator->value->refCount;
1703                 underlyingString = result.iterator->value; // Point P2.
1704             }
1705             adoptUnderlyingString(underlyingString); // Point P5.
1706         }
1707
1708         ... and ...
1709
1710         void StringView::adoptUnderlyingString(UnderlyingString* underlyingString)
1711         {
1712             if (m_underlyingString) {
1713                 // Point P0.
1714                 if (!--m_underlyingString->refCount) {
1715                     if (m_underlyingString->isValid) { // Point P1.
1716                         std::lock_guard<StaticLock> lock(underlyingStringsMutex);
1717                         underlyingStrings().remove(&m_underlyingString->string); // Point P3.
1718                     }
1719                     delete m_underlyingString; // Point P4.
1720                 }
1721             }
1722             m_underlyingString = underlyingString;
1723         }
1724
1725         Imagine the following scenario:
1726
1727         1. Thread T1 has been using an UnderlyingString U1, and is now done with it.
1728            T1 runs up to point P1 in adoptUnderlyingString(), and is blocked waiting for
1729            the underlyingStringsMutex (which is currently being held by Thread T2).
1730         2. Context switch to Thread T2.
1731            T2 wants to use UnderlyingString U1, and runs up to point P2 in setUnderlyingString()
1732            and releases the underlyingStringsMutex.
1733            Note: T2 thinks it has successfully refCounted U1, and therefore U1 is safe to use.
1734         3. Context switch to Thread T1.
1735            T1 acquires the underlyingStringsMutex, and proceeds to remove it from the
1736            underlyingStrings() map (see Point P3).  It thinks it has successfully done so
1737            and proceeds to delete U1 (see Point P4).
1738         4. Context switch to Thread T2.
1739            T2 proceeds to use U1 (see Point P5 in setUnderlyingString()).
1740            Note: U1 has already been freed.  This is a use after free.
1741
1742         The fix is to acquire the underlyingStringsMutex at Point P0 in adoptUnderlyingString()
1743         instead of after P1.  This ensures that the decrementing of the UnderlyingString
1744         refCount and its removal from the underlyingStrings() map is done as an atomic unit.
1745
1746         Note: If you look in StringView.cpp, you see another setUnderlyingString() which
1747         takes a StringView otherString.  This version of setUnderlyingString() can only
1748         be called from within the same thread that created the other StringView.  As a
1749         result, here, we are guaranteed that the UnderlyingString refCount is never zero,
1750         and there's no other threat of another thread trying to delete the UnderlyingString
1751         while we adopt it.  Hence, we don't need to acquire the underlyingStringsMutex
1752         here.
1753
1754         This race condition was found when running layout tests fetch/fetch-worker-crash.html
1755         and storage/indexeddb/modern/opendatabase-versions.html when CHECK_STRINGVIEW_LIFETIME
1756         is enabled.  This issue resulted in those tests crashing due to a use-after-free.
1757
1758         * wtf/text/StringView.cpp:
1759         (WTF::StringView::adoptUnderlyingString):
1760         (WTF::StringView::setUnderlyingString):
1761
1762 2016-09-28  Brent Fulgham  <bfulgham@apple.com>
1763
1764         Correct 'safeCast' implementation
1765         https://bugs.webkit.org/show_bug.cgi?id=162679
1766         <rdar://problem/28518189>
1767
1768         Reviewed by Zalan Bujtas.
1769
1770         * wtf/StdLibExtras.h:
1771         (WTF::safeCast): Use a RELEASE_ASSERT.
1772
1773 2016-09-27  Don Olmstead  <don.olmstead@am.sony.com>
1774
1775         [CMake] Add HAVE_LOCALTIME_R definition
1776         https://bugs.webkit.org/show_bug.cgi?id=162636
1777
1778         Reviewed by Alex Christensen.
1779
1780         * wtf/DateMath.cpp:
1781         (WTF::getLocalTime):
1782         * wtf/GregorianDateTime.cpp:
1783         (WTF::GregorianDateTime::setToCurrentLocalTime):
1784         * wtf/Platform.h:
1785
1786 2016-09-27  JF Bastien  <jfbastien@apple.com>
1787
1788         Speed up Heap::isMarkedConcurrently
1789         https://bugs.webkit.org/show_bug.cgi?id=162095
1790
1791         Reviewed by Filip Pizlo.
1792
1793         Heap::isMarkedConcurrently had a load-load fence which is expensive on weak memory ISAs such as ARM.
1794
1795         This patch is fairly perf-neutral overall, but the GC's instrumentation reports:
1796           GC:Eden is 93% average runtime after change
1797           GC:Full is 76% average runtime after change
1798
1799         The fence was there because:
1800          1. If the read of m_markingVersion in MarkedBlock::areMarksStale isn't what's expected then;
1801          2. The read of m_marks in MarkedBlock::isMarked needs to observe the value that was stored *before* m_markingVersion was stored.
1802
1803         This ordering isn't guaranteed on ARM, which has a weak memory model.
1804
1805         There are 3 ways to guarantee this ordering:
1806          A. Use a barrier instruction.
1807          B. Use a load-acquire (new in ARMv8).
1808          C. use ARM's address dependency rule, which C++ calls memory_order_consume.
1809
1810         In general:
1811          A. is slow but orders all of memory in an intuitive manner.
1812          B. is faster-ish and has the same property-ish.
1813          C. should be faster still, but *only orders dependent loads*. This last part is critical! Consume isn't an all-out replacement for acquire (acquire is rather a superset of consume).
1814
1815         ARM explains the address dependency rule in their document "barrier litmus tests and cookbook":
1816
1817         > *Resolving by the use of barriers and address dependency*
1818         >
1819         > There is a rule within the ARM architecture that:
1820         > Where the value returned by a read is used to compute the virtual address of a subsequent read or write (this is known as an address dependency), then these two memory accesses will be observed in program order. An address dependency exists even if the value read by the first read has no effect in changing the virtual address (as might be the case if the value returned is masked off before it is used, or if it had no effect on changing a predicted address value).
1821         > This restriction applies only when the data value returned from one read is used as a data value to calculate the address of a subsequent read or write. This does not apply if the data value returned from one read is used to determine the condition code flags, and the values of the flags are used for condition code evaluation to determine the address of a subsequent reads, either through conditional execution or the evaluation of a branch. This is known as a control dependency.
1822         > Where both a control and address dependency exist, the ordering behaviour is consistent with the address dependency.
1823
1824         C++'s memory_order_consume is unfortunately unimplemented by C++ compilers, and maybe unimplementable as spec'd. I'm working with interested folks in the committee to fix this situation: http://wg21.link/p0190r2
1825
1826         * wtf/Atomics.h:
1827         (WTF::zeroWithConsumeDependency): a 0 which carries a dependency
1828         (WTF::consumeLoad): pixie magic
1829
1830 2016-09-27  JF Bastien  <jfbastien@apple.com>
1831
1832         Atomics.h on Windows: remove seq_cst hack
1833         https://bugs.webkit.org/show_bug.cgi?id=162022
1834
1835         Reviewed by Mark Lam.
1836
1837         No need to force access to seq_cst, always inlining fixes the MSVC warning.
1838
1839         * wtf/Atomics.h:
1840         (WTF::Atomic::compareExchangeWeak): remove seq_cst hack
1841         (WTF::Atomic::compareExchangeStrong): remove seq_cst hack
1842         (WTF::Atomic::exchangeAndAdd): remove seq_cst hack
1843         (WTF::Atomic::exchange): remove seq_cst hack
1844
1845 2016-09-27  Don Olmstead  <don.olmstead@am.sony.com>
1846
1847         [CMake] Use CMake to determine HAVE_* defines
1848         https://bugs.webkit.org/show_bug.cgi?id=162368
1849
1850         Reviewed by Alex Christensen.
1851
1852         * wtf/Platform.h:
1853
1854 2016-09-20  Anders Carlsson  <andersca@apple.com>
1855
1856         PlatformEvent::m_modifiers should be an OptionSet
1857         https://bugs.webkit.org/show_bug.cgi?id=162326
1858
1859         Reviewed by Daniel Bates.
1860
1861         * wtf/OptionSet.h:
1862         (WTF::OptionSet::operator!=):
1863         (WTF::OptionSet::operator-):
1864
1865 2016-09-27  Jer Noble  <jer.noble@apple.com>
1866
1867         Remove deprecated ENCRYPTED_MEDIA implementation.
1868         https://bugs.webkit.org/show_bug.cgi?id=161010
1869
1870         Reviewed by Eric Carlson.
1871
1872         Remove ENABLE_ENCRYPTED_MEDIA.
1873
1874         * wtf/FeatureDefines.h:
1875
1876 2016-09-27  Youenn Fablet  <youenn@apple.com>
1877
1878         [Fetch API] Use Ref<const T> in FetchBody::m_data variant
1879         https://bugs.webkit.org/show_bug.cgi?id=162599
1880
1881         Reviewed by Alex Christensen.
1882
1883         Enabling to use DeferrableRefCounted<const T> by making m_refCount mutable.
1884
1885         * wtf/DeferrableRefCounted.h:
1886         (WTF::DeferrableRefCountedBase::ref):
1887         (WTF::DeferrableRefCountedBase::derefBase):
1888         (WTF::DeferrableRefCounted::deref):
1889
1890 2016-09-26  Daniel Bates  <dabates@apple.com>
1891
1892         Rename IOS_TEXT_AUTOSIZING to TEXT_AUTOSIZING
1893         https://bugs.webkit.org/show_bug.cgi?id=162365
1894
1895         Reviewed by Simon Fraser.
1896
1897         * wtf/FeatureDefines.h:
1898
1899 2016-09-26  Benjamin Poulain  <benjamin@webkit.org>
1900
1901         [JSC] Shrink the Math inline caches some more
1902         https://bugs.webkit.org/show_bug.cgi?id=162485
1903
1904         Reviewed by Saam Barati.
1905
1906         * wtf/Bag.h:
1907         Don't copy the arguments before initializing the nodes.
1908
1909 2016-09-26  Michael Catanzaro  <mcatanzaro@igalia.com>
1910
1911         std::unique_ptr deleter functions should not check if pointer is null
1912         https://bugs.webkit.org/show_bug.cgi?id=162558
1913
1914         Reviewed by Alex Christensen.
1915
1916         std::unique_ptr already does this before calling the deleter.
1917
1918         * wtf/efl/UniquePtrEfl.h:
1919         * wtf/glib/GUniquePtr.h:
1920
1921 == Rolled over to ChangeLog-2016-09-26 ==