OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2014 Google Inc. All rights reserved. | 2 * Copyright (C) 2014 Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions are | 5 * modification, are permitted provided that the following conditions are |
6 * met: | 6 * met: |
7 * | 7 * |
8 * * Redistributions of source code must retain the above copyright | 8 * * Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * * Redistributions in binary form must reproduce the above | 10 * * Redistributions in binary form must reproduce the above |
(...skipping 492 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
503 ASSERT(this == static_cast<PersistentNode*>(this)); | 503 ASSERT(this == static_cast<PersistentNode*>(this)); |
504 const char* n = FieldAnnotationBase::fromAddress(this); | 504 const char* n = FieldAnnotationBase::fromAddress(this); |
505 return n ? n : "CollectionPersistent"; | 505 return n ? n : "CollectionPersistent"; |
506 } | 506 } |
507 #endif | 507 #endif |
508 | 508 |
509 private: | 509 private: |
510 Collection m_collection; | 510 Collection m_collection; |
511 }; | 511 }; |
512 | 512 |
513 // Template aliases for the transition period where we want to support | 513 // CPP-defined type names for the transition period where we want to |
514 // both reference counting and garbage collection based on a | 514 // support both reference counting and garbage collection based on a |
515 // compile-time flag. | 515 // compile-time flag. |
516 // | 516 // |
517 // With clang we can use c++11 template aliases which is really what | 517 // [ |
518 // we want. For GCC and MSVC we simulate the template aliases with | 518 // C++11 template aliases were initially used (with clang only, not |
519 // stylized macros until we can use template aliases. | 519 // with GCC nor MSVC.) However, supporting both CPP defines and |
| 520 // template aliases is problematic from outside a WebCore namespace |
| 521 // when Oilpan is disabled: e.g., |
| 522 // WebCore::RefCountedWillBeGarbageCollected as a template alias would |
| 523 // uniquely resolve from within any namespace, but if it is backed by |
| 524 // a CPP #define, it would expand to WebCore::RefCounted, and not the |
| 525 // required WTF::RefCounted. |
| 526 // |
| 527 // Having the CPP expansion instead be fully namespace qualified, and the |
| 528 // transition type be unqualified, would dually not work for template |
| 529 // aliases. So, slightly unfortunately, fall back/down to the lowest |
| 530 // commmon denominator of using CPP macros only. |
| 531 // ] |
520 #if ENABLE(OILPAN) | 532 #if ENABLE(OILPAN) |
521 | 533 #define PassRefPtrWillBeRawPtr WTF::RawPtr |
522 #if COMPILER(CLANG) | 534 #define RefCountedWillBeGarbageCollected WebCore::GarbageCollected |
523 template<typename T> using PassRefPtrWillBeRawPtr = RawPtr<T>; | 535 #define RefCountedWillBeGarbageCollectedFinalized WebCore::GarbageCollectedFinal
ized |
524 template<typename T> using RefCountedWillBeGarbageCollected = GarbageCollected<T
>; | 536 #define RefCountedWillBeRefCountedGarbageCollected WebCore::RefCountedGarbageCol
lected |
525 template<typename T> using RefCountedWillBeGarbageCollectedFinalized = GarbageCo
llectedFinalized<T>; | 537 #define RefPtrWillBePersistent WebCore::Persistent |
526 template<typename T> using RefCountedWillBeRefCountedGarbageCollected = RefCount
edGarbageCollected<T>; | 538 #define RefPtrWillBeRawPtr WTF::RawPtr |
527 template<typename T> using RefPtrWillBePersistent = Persistent<T>; | 539 #define RefPtrWillBeMember WebCore::Member |
528 template<typename T> using RefPtrWillBeRawPtr = RawPtr<T>; | 540 #define RawPtrWillBeMember WebCore::Member |
529 template<typename T> using RefPtrWillBeMember = Member<T>; | 541 #define RawPtrWillBeWeakMember WebCore::WeakMember |
530 template<typename T> using RawPtrWillBeMember = Member<T>; | 542 #define OwnPtrWillBeMember WebCore::Member |
531 template<typename T> using RawPtrWillBeWeakMember = WeakMember<T>; | 543 #define PassOwnPtrWillBeRawPtr WTF::RawPtr |
532 template<typename T> using OwnPtrWillBeMember = Member<T>; | 544 #define NoBaseWillBeGarbageCollected WebCore::GarbageCollected |
533 template<typename T> using PassOwnPtrWillBeRawPtr = RawPtr<T>; | 545 #define NoBaseWillBeGarbageCollectedFinalized WebCore::GarbageCollectedFinalized |
534 template<typename T> using NoBaseWillBeGarbageCollected = GarbageCollected<T>; | 546 #define WillBeHeapHashMap WebCore::HeapHashMap |
535 template<typename T> using NoBaseWillBeGarbageCollectedFinalized = GarbageCollec
tedFinalized<T>; | 547 #define WillBePersistentHeapHashMap WebCore::PersistentHeapHashMap |
536 template< | 548 #define WillBeHeapHashSet WebCore::HeapHashSet |
537 typename K, | 549 #define WillBePersistentHeapHashSet WebCore::PersistentHeapHashSet |
538 typename V, | 550 #define WillBeHeapVector WebCore::HeapVector |
539 typename H = typename DefaultHash<K>::Hash, | 551 #define WillBePersistentHeapVector WebCore::PersistentHeapVector |
540 typename KT = HashTraits<K>, | |
541 typename VT = HashTraits<V> > | |
542 using WillBeHeapHashMap = HeapHashMap<K, V, H, KT, VT>; | |
543 template< | |
544 typename K, | |
545 typename V, | |
546 typename H = typename DefaultHash<K>::Hash, | |
547 typename KT = HashTraits<K>, | |
548 typename VT = HashTraits<V> > | |
549 using WillBePersistentHeapHashMap = PersistentHeapHashMap<K, V, H, KT, VT>; | |
550 template< | |
551 typename V, | |
552 typename H = typename DefaultHash<V>::Hash, | |
553 typename T = HashTraits<V> > | |
554 using WillBeHeapHashSet = HeapHashSet<V, H, T>; | |
555 template< | |
556 typename V, | |
557 typename H = typename DefaultHash<V>::Hash, | |
558 typename T = HashTraits<V> > | |
559 using WillBePersistentHeapHashSet = PersistentHeapHashSet<V, H, T>; | |
560 template<typename T, size_t inlineCapacity = 0> | |
561 using WillBeHeapVector = HeapVector<T, inlineCapacity>; | |
562 template<typename T, size_t inlineCapacity = 0> | |
563 using WillBePersistentHeapVector = PersistentHeapVector<T, inlineCapacity>; | |
564 #else // !COMPILER(CLANG) | |
565 #define PassRefPtrWillBeRawPtr RawPtr | |
566 #define RefCountedWillBeGarbageCollected GarbageCollected | |
567 #define RefCountedWillBeGarbageCollectedFinalized GarbageCollectedFinalized | |
568 #define RefCountedWillBeRefCountedGarbageCollected RefCountedGarbageCollected | |
569 #define RefPtrWillBePersistent Persistent | |
570 #define RefPtrWillBeRawPtr RawPtr | |
571 #define RefPtrWillBeMember Member | |
572 #define RawPtrWillBeMember Member | |
573 #define RawPtrWillBeWeakMember WeakMember | |
574 #define OwnPtrWillBeMember Member | |
575 #define PassOwnPtrWillBeRawPtr RawPtr | |
576 #define NoBaseWillBeGarbageCollected GarbageCollected | |
577 #define NoBaseWillBeGarbageCollectedFinalized GarbageCollectedFinalized | |
578 #define WillBeHeapHashMap HeapHashMap | |
579 #define WillBePersistentHeapHashMap PersistentHeapHashMap | |
580 #define WillBeHeapHashSet HeapHashSet | |
581 #define WillBePersistentHeapHashSet PersistentHeapHashSet | |
582 #define WillBeHeapVector HeapVector | |
583 #define WillBePersistentHeapVector PersistentHeapVector | |
584 #endif // COMPILER(CLANG) | |
585 | 552 |
586 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefWillBeNoop(T* ptr) | 553 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefWillBeNoop(T* ptr) |
587 { | 554 { |
588 static const bool notRefCountedGarbageCollected = !WTF::IsSubclassOfTemplate
<T, RefCountedGarbageCollected>::value; | 555 static const bool notRefCountedGarbageCollected = !WTF::IsSubclassOfTemplate
<T, RefCountedGarbageCollected>::value; |
589 static const bool notRefCounted = !WTF::IsSubclassOfTemplate<T, RefCounted>:
:value; | 556 static const bool notRefCounted = !WTF::IsSubclassOfTemplate<T, RefCounted>:
:value; |
590 COMPILE_ASSERT(notRefCountedGarbageCollected, useAdoptRefCountedWillBeRefCou
ntedGarbageCollected); | 557 COMPILE_ASSERT(notRefCountedGarbageCollected, useAdoptRefCountedWillBeRefCou
ntedGarbageCollected); |
591 COMPILE_ASSERT(notRefCounted, youMustAdopt); | 558 COMPILE_ASSERT(notRefCounted, youMustAdopt); |
592 return PassRefPtrWillBeRawPtr<T>(ptr); | 559 return PassRefPtrWillBeRawPtr<T>(ptr); |
593 } | 560 } |
594 | 561 |
(...skipping 17 matching lines...) Expand all Loading... |
612 | 579 |
613 #else // !ENABLE(OILPAN) | 580 #else // !ENABLE(OILPAN) |
614 | 581 |
615 template<typename T> | 582 template<typename T> |
616 class DummyBase { | 583 class DummyBase { |
617 public: | 584 public: |
618 DummyBase() { } | 585 DummyBase() { } |
619 ~DummyBase() { } | 586 ~DummyBase() { } |
620 }; | 587 }; |
621 | 588 |
622 #if COMPILER(CLANG) | 589 #define PassRefPtrWillBeRawPtr WTF::PassRefPtr |
623 template<typename T> using PassRefPtrWillBeRawPtr = PassRefPtr<T>; | 590 #define RefCountedWillBeGarbageCollected WTF::RefCounted |
624 template<typename T> using RefCountedWillBeGarbageCollected = RefCounted<T>; | 591 #define RefCountedWillBeGarbageCollectedFinalized WTF::RefCounted |
625 template<typename T> using RefCountedWillBeGarbageCollectedFinalized = RefCounte
d<T>; | 592 #define RefCountedWillBeRefCountedGarbageCollected WTF::RefCounted |
626 template<typename T> using RefCountedWillBeRefCountedGarbageCollected = RefCount
ed<T>; | 593 #define RefPtrWillBePersistent WTF::RefPtr |
627 template<typename T> using RefPtrWillBePersistent = RefPtr<T>; | 594 #define RefPtrWillBeRawPtr WTF::RefPtr |
628 template<typename T> using RefPtrWillBeRawPtr = RefPtr<T>; | 595 #define RefPtrWillBeMember WTF::RefPtr |
629 template<typename T> using RefPtrWillBeMember = RefPtr<T>; | 596 #define RawPtrWillBeMember WTF::RawPtr |
630 template<typename T> using RawPtrWillBeMember = RawPtr<T>; | 597 #define RawPtrWillBeWeakMember WTF::RawPtr |
631 template<typename T> using RawPtrWillBeWeakMember = RawPtr<T>; | 598 #define OwnPtrWillBeMember WTF::OwnPtr |
632 template<typename T> using OwnPtrWillBeMember = OwnPtr<T>; | 599 #define PassOwnPtrWillBeRawPtr WTF::PassOwnPtr |
633 template<typename T> using PassOwnPtrWillBeRawPtr = PassOwnPtr<T>; | 600 #define NoBaseWillBeGarbageCollected WebCore::DummyBase |
634 template<typename T> using NoBaseWillBeGarbageCollected = DummyBase<T>; | 601 #define NoBaseWillBeGarbageCollectedFinalized WebCore::DummyBase |
635 template<typename T> using NoBaseWillBeGarbageCollectedFinalized = DummyBase<T>; | 602 #define WillBeHeapHashMap WTF::HashMap |
636 template< | 603 #define WillBePersistentHeapHashMap WTF::HashMap |
637 typename K, | 604 #define WillBeHeapHashSet WTF::HashSet |
638 typename V, | 605 #define WillBePersistentHeapHashSet WTF::HashSet |
639 typename H = typename DefaultHash<K>::Hash, | 606 #define WillBeHeapVector WTF::Vector |
640 typename KT = HashTraits<K>, | 607 #define WillBePersistentHeapVector WTF::Vector |
641 typename VT = HashTraits<V> > | |
642 using WillBeHeapHashMap = HashMap<K, V, H, KT, VT>; | |
643 template< | |
644 typename K, | |
645 typename V, | |
646 typename H = typename DefaultHash<K>::Hash, | |
647 typename KT = HashTraits<K>, | |
648 typename VT = HashTraits<V> > | |
649 using WillBePersistentHeapHashMap = HashMap<K, V, H, KT, VT>; | |
650 template< | |
651 typename V, | |
652 typename H = typename DefaultHash<V>::Hash, | |
653 typename T = HashTraits<V> > | |
654 using WillBeHeapHashSet = HashSet<V, H, T>; | |
655 template< | |
656 typename V, | |
657 typename H = typename DefaultHash<V>::Hash, | |
658 typename T = HashTraits<V> > | |
659 using WillBePersistentHeapHashSet = HashSet<V, H, T>; | |
660 template<typename T, size_t inlineCapacity = 0> | |
661 using WillBeHeapVector = Vector<T, inlineCapacity>; | |
662 template<typename T, size_t inlineCapacity = 0> | |
663 using WillBePersistentHeapVector = Vector<T, inlineCapacity>; | |
664 #else // !COMPILER(CLANG) | |
665 #define PassRefPtrWillBeRawPtr PassRefPtr | |
666 #define RefCountedWillBeGarbageCollected RefCounted | |
667 #define RefCountedWillBeGarbageCollectedFinalized RefCounted | |
668 #define RefCountedWillBeRefCountedGarbageCollected RefCounted | |
669 #define RefPtrWillBePersistent RefPtr | |
670 #define RefPtrWillBeRawPtr RefPtr | |
671 #define RefPtrWillBeMember RefPtr | |
672 #define RawPtrWillBeMember RawPtr | |
673 #define RawPtrWillBeWeakMember RawPtr | |
674 #define OwnPtrWillBeMember OwnPtr | |
675 #define PassOwnPtrWillBeRawPtr PassOwnPtr | |
676 #define NoBaseWillBeGarbageCollected DummyBase | |
677 #define NoBaseWillBeGarbageCollectedFinalized DummyBase | |
678 #define WillBeHeapHashMap HashMap | |
679 #define WillBePersistentHeapHashMap HashMap | |
680 #define WillBeHeapHashSet HashSet | |
681 #define WillBePersistentHeapHashSet HashSet | |
682 #define WillBeHeapVector Vector | |
683 #define WillBePersistentHeapVector Vector | |
684 #endif // COMPILER(CLANG) | |
685 | 608 |
686 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefWillBeNoop(T* ptr) { retu
rn adoptRef(ptr); } | 609 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefWillBeNoop(T* ptr) { retu
rn adoptRef(ptr); } |
687 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefCountedWillBeRefCountedGa
rbageCollected(T* ptr) { return adoptRef(ptr); } | 610 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefCountedWillBeRefCountedGa
rbageCollected(T* ptr) { return adoptRef(ptr); } |
688 template<typename T> PassOwnPtrWillBeRawPtr<T> adoptPtrWillBeNoop(T* ptr) { retu
rn adoptPtr(ptr); } | 611 template<typename T> PassOwnPtrWillBeRawPtr<T> adoptPtrWillBeNoop(T* ptr) { retu
rn adoptPtr(ptr); } |
689 | 612 |
690 #define WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED WTF_MAKE_FAST_ALLOCATED | 613 #define WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED WTF_MAKE_FAST_ALLOCATED |
691 | 614 |
692 #endif // ENABLE(OILPAN) | 615 #endif // ENABLE(OILPAN) |
693 | 616 |
694 } // namespace WebCore | 617 } // namespace WebCore |
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
800 }; | 723 }; |
801 | 724 |
802 template<typename T> inline T* getPtr(const WebCore::Member<T>& p) | 725 template<typename T> inline T* getPtr(const WebCore::Member<T>& p) |
803 { | 726 { |
804 return p.get(); | 727 return p.get(); |
805 } | 728 } |
806 | 729 |
807 } // namespace WTF | 730 } // namespace WTF |
808 | 731 |
809 #endif | 732 #endif |
OLD | NEW |