#include <runtime/WeakGCPtr.h>
#include <wtf/HashMap.h>
-struct StaticValueEntry : FastAllocBase {
+struct StaticValueEntry {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
StaticValueEntry(JSObjectGetPropertyCallback _getProperty, JSObjectSetPropertyCallback _setProperty, JSPropertyAttributes _attributes)
: getProperty(_getProperty), setProperty(_setProperty), attributes(_attributes)
{
JSPropertyAttributes attributes;
};
-struct StaticFunctionEntry : FastAllocBase {
+struct StaticFunctionEntry {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
StaticFunctionEntry(JSObjectCallAsFunctionCallback _callAsFunction, JSPropertyAttributes _attributes)
: callAsFunction(_callAsFunction), attributes(_attributes)
{
// An OpaqueJSClass (JSClass) is created without a context, so it can be used with any context, even across context groups.
// This structure holds data members that vary across context groups.
-struct OpaqueJSClassContextData : Noncopyable {
+struct OpaqueJSClassContextData {
+ WTF_MAKE_NONCOPYABLE(OpaqueJSClassContextData); WTF_MAKE_FAST_ALLOCATED;
+public:
OpaqueJSClassContextData(OpaqueJSClass*);
~OpaqueJSClassContextData();
return result;
}
-struct OpaqueJSPropertyNameArray : FastAllocBase {
+struct OpaqueJSPropertyNameArray {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
OpaqueJSPropertyNameArray(JSGlobalData* globalData)
: refCount(0)
, globalData(globalData)
+2011-01-20 Zoltan Horvath <zoltan@webkit.org>
+
+ Reviewed by Csaba Osztrogonác.
+
+ Refactoring of the custom allocation framework
+ https://bugs.webkit.org/show_bug.cgi?id=49897
+
+ Inheriting from FastAllocBase can result in objects getting larger (bug #33896, #46589).
+ The modification replaces Noncopyable and FastAllocBase classes and these inherits with their
+ equivalent macro implementation at the necessary places.
+
+ * wtf/FastAllocBase.h: Turn FastAllocBase's implementation into a macro.
+
2011-01-20 Mark Rowe <mrowe@apple.com>
Reviewed by Maciej Stachowiak.
// * The address of a Label pointing into the code may be resolved.
// * The value referenced by a DataLabel may be set.
//
-class LinkBuffer : public Noncopyable {
+class LinkBuffer {
+ WTF_MAKE_NONCOPYABLE(LinkBuffer);
typedef MacroAssemblerCodeRef CodeRef;
typedef MacroAssemblerCodePtr CodePtr;
typedef MacroAssembler::Label Label;
}
#endif
- class CodeBlock : public FastAllocBase {
+ class CodeBlock {
+ WTF_MAKE_FAST_ALLOCATED;
friend class JIT;
protected:
CodeBlock(ScriptExecutable* ownerExecutable, CodeType, JSGlobalObject*, PassRefPtr<SourceProvider>, unsigned sourceOffset, SymbolTable* symbolTable, bool isConstructor);
SymbolTable* m_symbolTable;
- struct RareData : FastAllocBase {
+ struct RareData {
+ WTF_MAKE_FAST_ALLOCATED;
+ public:
Vector<HandlerInfo> m_exceptionHandlers;
// Rare Constants
Vector<CallReturnOffsetToBytecodeOffset> m_callReturnIndexVector;
#endif
};
+#if PLATFORM(WIN)
+ friend void WTF::deleteOwnedPtr<RareData>(RareData*);
+#endif
OwnPtr<RareData> m_rareData;
};
class StructureChain;
// Structure used by op_get_by_id_self_list and op_get_by_id_proto_list instruction to hold data off the main opcode stream.
- struct PolymorphicAccessStructureList : FastAllocBase {
+ struct PolymorphicAccessStructureList {
+ WTF_MAKE_FAST_ALLOCATED;
+ public:
struct PolymorphicStubInfo {
bool isChain;
PolymorphicAccessStructureListStubRoutineType stubRoutine;
friend class HostCallRecord;
#if ENABLE(OPCODE_SAMPLING)
- class CallRecord : public Noncopyable {
+ class CallRecord {
+ WTF_MAKE_NONCOPYABLE(CallRecord);
public:
CallRecord(SamplingTool* samplingTool)
: m_samplingTool(samplingTool)
}
};
#else
- class CallRecord : public Noncopyable {
+ class CallRecord {
+ WTF_MAKE_NONCOPYABLE(CallRecord);
public:
CallRecord(SamplingTool*)
{
#include "SymbolTable.h"
#include "Debugger.h"
#include "Nodes.h"
-#include <wtf/FastAllocBase.h>
#include <wtf/PassRefPtr.h>
#include <wtf/SegmentedVector.h>
#include <wtf/Vector.h>
RefPtr<RegisterID> propertyRegister;
};
- class BytecodeGenerator : public FastAllocBase {
+ class BytecodeGenerator {
+ WTF_MAKE_FAST_ALLOCATED;
public:
typedef DeclarationStacks::VarStack VarStack;
typedef DeclarationStacks::FunctionStack FunctionStack;
#define RegisterID_h
#include <wtf/Assertions.h>
-#include <wtf/Noncopyable.h>
#include <wtf/VectorTraits.h>
namespace JSC {
- class RegisterID : public Noncopyable {
+ class RegisterID {
+ WTF_MAKE_NONCOPYABLE(RegisterID);
public:
RegisterID()
: m_refCount(0)
#include "Interpreter.h"
namespace JSC {
- class CachedCall : public Noncopyable {
+ class CachedCall {
+ WTF_MAKE_NONCOPYABLE(CachedCall); WTF_MAKE_FAST_ALLOCATED;
public:
CachedCall(CallFrame* callFrame, JSFunction* function, int argCount)
: m_valid(false)
#define Interpreter_h
#include "ArgList.h"
-#include "FastAllocBase.h"
#include "JSCell.h"
#include "JSValue.h"
#include "JSObject.h"
enum { MaxLargeThreadReentryDepth = 256, MaxSmallThreadReentryDepth = 32 };
- class Interpreter : public FastAllocBase {
+ class Interpreter {
+ WTF_MAKE_FAST_ALLOCATED;
friend class JIT;
friend class CachedCall;
public:
#include "JSValue.h"
#include <wtf/Assertions.h>
-#include <wtf/FastAllocBase.h>
#include <wtf/VectorTraits.h>
namespace JSC {
typedef ExecState CallFrame;
- class Register : public WTF::FastAllocBase {
+ class Register {
+ WTF_MAKE_FAST_ALLOCATED;
public:
Register();
class JSGlobalObject;
- class RegisterFile : public Noncopyable {
+ class RegisterFile {
+ WTF_MAKE_NONCOPYABLE(RegisterFile);
friend class JIT;
public:
enum CallFrameHeaderEntry {
class RegExp;
- class Lexer : public Noncopyable {
+ class Lexer {
+ WTF_MAKE_NONCOPYABLE(Lexer); WTF_MAKE_FAST_ALLOCATED;
public:
// Character manipulation functions.
static bool isWhiteSpace(int character);
ParameterNode* m_next;
};
- struct ScopeNodeData : FastAllocBase {
+ struct ScopeNodeData {
+ WTF_MAKE_FAST_ALLOCATED;
+ public:
typedef DeclarationStacks::VarStack VarStack;
typedef DeclarationStacks::FunctionStack FunctionStack;
};
class FunctionParameters : public Vector<Identifier>, public RefCounted<FunctionParameters> {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static PassRefPtr<FunctionParameters> create(ParameterNode* firstParameter) { return adoptRef(new FunctionParameters(firstParameter)); }
template <typename T> struct ParserArenaData : ParserArenaDeletable { T data; };
- class Parser : public Noncopyable {
+ class Parser {
+ WTF_MAKE_NONCOPYABLE(Parser); WTF_MAKE_FAST_ALLOCATED;
public:
+ Parser() { }
template <class ParsedNode>
PassRefPtr<ParsedNode> parse(JSGlobalObject* lexicalGlobalObject, Debugger*, ExecState*, const SourceCode& source, FunctionParameters*, JSParserStrictness strictness, JSObject** exception);
class ParserArenaDeletable;
class ParserArenaRefCounted;
- class IdentifierArena : public FastAllocBase {
+ class IdentifierArena {
+ WTF_MAKE_FAST_ALLOCATED;
public:
ALWAYS_INLINE const Identifier& makeIdentifier(JSGlobalData*, const UChar* characters, size_t length);
const Identifier& makeNumericIdentifier(JSGlobalData*, double number);
return m_identifiers.last();
}
- class ParserArena : Noncopyable {
+ class ParserArena {
+ WTF_MAKE_NONCOPYABLE(ParserArena);
public:
ParserArena();
~ParserArena();
const UChar* bracketStart;
};
-struct MatchFrame : FastAllocBase {
+struct MatchFrame {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
ReturnLocation returnLocation;
struct MatchFrame* previousFrame;
#define CallIdentifier_h
#include <runtime/UString.h>
-#include "FastAllocBase.h"
#include <wtf/text/CString.h>
#include <wtf/text/StringHash.h>
namespace JSC {
- struct CallIdentifier : public FastAllocBase {
+ struct CallIdentifier {
+ WTF_MAKE_FAST_ALLOCATED;
+ public:
UString m_name;
UString m_url;
unsigned m_lineNumber;
class UString;
struct CallIdentifier;
- class Profiler : public FastAllocBase {
+ class Profiler {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static Profiler** enabledProfilerReference()
{
#include "CallFrame.h"
#include "Register.h"
#include <wtf/HashSet.h>
-#include <wtf/Noncopyable.h>
#include <wtf/Vector.h>
namespace JSC {
class MarkStack;
- class MarkedArgumentBuffer : public Noncopyable {
+ class MarkedArgumentBuffer {
+ WTF_MAKE_NONCOPYABLE(MarkedArgumentBuffer);
private:
static const unsigned inlineCapacity = 8;
typedef Vector<Register, inlineCapacity> VectorType;
namespace JSC {
- struct ArgumentsData : Noncopyable {
+ struct ArgumentsData {
+ WTF_MAKE_NONCOPYABLE(ArgumentsData); WTF_MAKE_FAST_ALLOCATED;
+ public:
+ ArgumentsData() { }
JSActivation* activation;
unsigned numParameters;
#ifndef BatchedTransitionOptimizer_h
#define BatchedTransitionOptimizer_h
-#include <wtf/Noncopyable.h>
#include "JSObject.h"
namespace JSC {
- class BatchedTransitionOptimizer : public Noncopyable {
+ class BatchedTransitionOptimizer {
+ WTF_MAKE_NONCOPYABLE(BatchedTransitionOptimizer);
public:
BatchedTransitionOptimizer(JSObject* object)
: m_object(object)
namespace JSC {
- class CommonIdentifiers : public Noncopyable {
+ class CommonIdentifiers {
+ WTF_MAKE_NONCOPYABLE(CommonIdentifiers); WTF_MAKE_FAST_ALLOCATED;
private:
CommonIdentifiers(JSGlobalData*);
friend class JSGlobalData;
enum OperationInProgress { NoOperation, Allocation, Collection };
- class Heap : public Noncopyable {
+ class Heap {
+ WTF_MAKE_NONCOPYABLE(Heap);
public:
void destroy();
return new (exec) JSArray(exec->lexicalGlobalObject()->arrayStructure(), values);
}
- class DynamicGlobalObjectScope : public Noncopyable {
+ class DynamicGlobalObjectScope {
+ WTF_MAKE_NONCOPYABLE(DynamicGlobalObjectScope);
public:
DynamicGlobalObjectScope(CallFrame* callFrame, JSGlobalObject* dynamicGlobalObject);
enum JSLockBehavior { SilenceAssertionsOnly, LockForReal };
- class JSLock : public Noncopyable {
+ class JSLock {
+ WTF_MAKE_NONCOPYABLE(JSLock);
public:
JSLock(ExecState*);
JSLock(JSGlobalData*);
JSLockBehavior m_lockBehavior;
- class DropAllLocks : public Noncopyable {
+ class DropAllLocks {
+ WTF_MAKE_NONCOPYABLE(DropAllLocks);
public:
DropAllLocks(ExecState* exec);
DropAllLocks(JSLockBehavior);
mutable JSValue m_value;
};
-class Stringifier : public Noncopyable {
+class Stringifier {
+ WTF_MAKE_NONCOPYABLE(Stringifier);
public:
Stringifier(ExecState*, JSValue replacer, JSValue space);
~Stringifier();
typedef PropertySlot::GetValueFunc GetFunction;
typedef void (*PutFunction)(ExecState*, JSObject* baseObject, JSValue value);
- class HashEntry : public FastAllocBase {
+ class HashEntry {
+ WTF_MAKE_FAST_ALLOCATED;
public:
void initialize(StringImpl* key, unsigned char attributes, intptr_t v1, intptr_t v2
#if ENABLE(JIT)
class Heap;
class MarkStack;
- class MachineStackMarker : public Noncopyable {
+ class MachineStackMarker {
+ WTF_MAKE_NONCOPYABLE(MachineStackMarker);
public:
MachineStackMarker(Heap*);
~MachineStackMarker();
enum MarkSetProperties { MayContainNullValues, NoNullValues };
- class MarkStack : Noncopyable {
+ class MarkStack {
+ WTF_MAKE_NONCOPYABLE(MarkStack);
public:
MarkStack(void* jsArrayVPtr)
: m_jsArrayVPtr(jsArrayVPtr)
}
};
- class MarkedSpace : public Noncopyable {
+ class MarkedSpace {
+ WTF_MAKE_NONCOPYABLE(MarkedSpace);
public:
MarkedSpace(JSGlobalData*);
void destroy(ProtectCountSet&);
class RegExpPrototype;
struct RegExpConstructorPrivate;
- struct RegExpConstructorPrivate : FastAllocBase {
+ struct RegExpConstructorPrivate {
+ WTF_MAKE_FAST_ALLOCATED;
+ public:
// Global search cache / settings
RegExpConstructorPrivate()
: lastNumSubPatterns(0)
private:
bool match(ExecState*);
- struct RegExpObjectData : FastAllocBase {
+ struct RegExpObjectData {
+ WTF_MAKE_FAST_ALLOCATED;
+ public:
RegExpObjectData(NonNullPassRefPtr<RegExp> regExp, double lastIndex)
: regExp(regExp)
, lastIndex(lastIndex)
RefPtr<RegExp> regExp;
double lastIndex;
};
-
+#if PLATFORM(WIN)
+ friend void WTF::deleteOwnedPtr<RegExpObjectData>(RegExpObjectData*);
+#endif
OwnPtr<RegExpObjectData> d;
};
#ifndef ScopeChain_h
#define ScopeChain_h
-#include "FastAllocBase.h"
+#include <wtf/FastAllocBase.h>
namespace JSC {
class MarkStack;
class ScopeChainIterator;
- class ScopeChainNode : public FastAllocBase {
+ class ScopeChainNode {
+ WTF_MAKE_FAST_ALLOCATED;
public:
ScopeChainNode(ScopeChainNode* next, JSObject* object, JSGlobalData* globalData, JSGlobalObject* globalObject, JSObject* globalThis)
: next(next)
return string && Heap::isCellMarked(string);
}
-class SmallStringsStorage : public Noncopyable {
+class SmallStringsStorage {
+ WTF_MAKE_NONCOPYABLE(SmallStringsStorage); WTF_MAKE_FAST_ALLOCATED;
public:
SmallStringsStorage();
class MarkStack;
class SmallStringsStorage;
- class SmallStrings : public Noncopyable {
+ class SmallStrings {
+ WTF_MAKE_NONCOPYABLE(SmallStrings); WTF_MAKE_FAST_ALLOCATED;
public:
SmallStrings();
~SmallStrings();
typedef HashMap<RefPtr<StringImpl>, SymbolTableEntry, IdentifierRepHash, HashTraits<RefPtr<StringImpl> >, SymbolTableIndexHashTraits> SymbolTable;
class SharedSymbolTable : public SymbolTable, public RefCounted<SharedSymbolTable> {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static PassRefPtr<SharedSymbolTable> create() { return adoptRef(new SharedSymbolTable); }
private:
// A HashMap whose get() function returns emptyValue() for cells awaiting destruction.
template<typename KeyType, typename MappedType>
-class WeakGCMap : public FastAllocBase {
+class WeakGCMap {
+ WTF_MAKE_FAST_ALLOCATED;
/*
Invariants:
* A value enters the WeakGCMap marked. (Guaranteed by set().)
#include "Heap.h"
#include "GCHandle.h"
-#include <wtf/Noncopyable.h>
namespace JSC {
// A smart pointer whose get() function returns 0 for cells awaiting destruction.
-template <typename T> class WeakGCPtr : Noncopyable {
+template <typename T> class WeakGCPtr {
+ WTF_MAKE_NONCOPYABLE(WeakGCPtr);
public:
WeakGCPtr()
: m_ptr(0)
// with respect to the original and any other copies. The underlying m_data is jointly
// owned by the original instance and all copies.
template<class T>
- class CrossThreadRefCounted : public Noncopyable {
+ class CrossThreadRefCounted {
+ WTF_MAKE_NONCOPYABLE(CrossThreadRefCounted);
public:
static PassRefPtr<CrossThreadRefCounted<T> > create(T* data)
{
#define DateMath_h
#include <math.h>
+#include <stdint.h>
#include <string.h>
#include <time.h>
#include <wtf/CurrentTime.h>
// Intentionally overridding the default tm of the system.
// The members of tm differ on various operating systems.
-struct GregorianDateTime : Noncopyable {
+struct GregorianDateTime {
+ WTF_MAKE_NONCOPYABLE(GregorianDateTime);
+public:
GregorianDateTime()
: second(0)
, minute(0)
template<typename T> class DequeConstReverseIterator;
template<typename T>
- class Deque : public FastAllocBase {
+ class Deque {
+ WTF_MAKE_FAST_ALLOCATED;
public:
typedef DequeIterator<T> iterator;
typedef DequeConstIterator<T> const_iterator;
// Provides customizable overrides of fastMalloc/fastFree and operator new/delete
//
// Provided functionality:
+// Macro: WTF_MAKE_FAST_ALLOCATED
// namespace WTF {
-// class FastAllocBase;
//
// T* fastNew<T>();
// T* fastNew<T>(arg);
// FastDelete assumes that the underlying
//
// Example usage:
-// class Widget : public FastAllocBase { ... };
+// class Widget {
+// WTF_MAKE_FAST_ALLOCATED
+// ...
+// };
+//
+// struct Data {
+// WTF_MAKE_FAST_ALLOCATED
+// public:
+// ...
+// };
//
// char* charPtr = fastNew<char>();
// fastDelete(charPtr);
#include "FastMalloc.h"
#include "TypeTraits.h"
-namespace WTF {
-
#define WTF_MAKE_FAST_ALLOCATED \
public: \
void* operator new(size_t, void* p) { return p; } \
::WTF::fastMallocMatchValidateFree(p, ::WTF::Internal::AllocTypeClassNewArray); \
::WTF::fastFree(p); \
} \
-private:
+private: \
+typedef int ThisIsHereToForceASemicolonAfterThisMacro
-class FastAllocBase {
- WTF_MAKE_FAST_ALLOCATED
-};
+namespace WTF {
// fastNew / fastDelete
} // namespace WTF
-using WTF::FastAllocBase;
using WTF::fastDeleteSkippingDestructor;
#endif // FastAllocBase_h
#define WTF_HashCountedSet_h
#include "Assertions.h"
-#include "FastAllocBase.h"
#include "HashMap.h"
#include "Vector.h"
namespace WTF {
template<typename Value, typename HashFunctions = typename DefaultHash<Value>::Hash,
- typename Traits = HashTraits<Value> > class HashCountedSet : public FastAllocBase {
+ typename Traits = HashTraits<Value> > class HashCountedSet {
+ WTF_MAKE_FAST_ALLOCATED;
private:
typedef HashMap<Value, unsigned, HashFunctions, Traits> ImplType;
public:
template<typename KeyArg, typename MappedArg, typename HashArg = typename DefaultHash<KeyArg>::Hash,
typename KeyTraitsArg = HashTraits<KeyArg>, typename MappedTraitsArg = HashTraits<MappedArg> >
- class HashMap : public FastAllocBase {
+ class HashMap {
+ WTF_MAKE_FAST_ALLOCATED;
private:
typedef KeyTraitsArg KeyTraits;
typedef MappedTraitsArg MappedTraits;
template<typename T> struct IdentityExtractor;
template<typename ValueArg, typename HashArg = typename DefaultHash<ValueArg>::Hash,
- typename TraitsArg = HashTraits<ValueArg> > class HashSet : public FastAllocBase {
+ typename TraitsArg = HashTraits<ValueArg> > class HashSet {
+ WTF_MAKE_FAST_ALLOCATED;
private:
typedef HashArg HashFunctions;
typedef TraitsArg ValueTraits;
template<typename ValueArg, size_t inlineCapacity> struct ListHashSetNodeAllocator;
template<typename ValueArg, size_t inlineCapacity, typename HashArg> struct ListHashSetNodeHashFunctions;
- template<typename ValueArg, size_t inlineCapacity = 256, typename HashArg = typename DefaultHash<ValueArg>::Hash> class ListHashSet : public FastAllocBase {
+ template<typename ValueArg, size_t inlineCapacity = 256, typename HashArg = typename DefaultHash<ValueArg>::Hash> class ListHashSet {
+ WTF_MAKE_FAST_ALLOCATED;
private:
typedef ListHashSetNode<ValueArg, inlineCapacity> Node;
typedef ListHashSetNodeAllocator<ValueArg, inlineCapacity> NodeAllocator;
namespace WTF {
-template <typename T> class Locker : public Noncopyable {
+template <typename T> class Locker {
+ WTF_MAKE_NONCOPYABLE(Locker);
public:
Locker(T& lockable) : m_lockable(lockable) { m_lockable.lock(); }
~Locker() { m_lockable.unlock(); }
// when messages are fetched from the queue.
// Essentially, MessageQueue acts as a queue of OwnPtr<DataType>.
template<typename DataType>
- class MessageQueue : public Noncopyable {
+ class MessageQueue {
+ WTF_MAKE_NONCOPYABLE(MessageQueue);
public:
MessageQueue() : m_killed(false) { }
~MessageQueue();
ClassName& operator=(const ClassName&)
#endif
-// We don't want argument-dependent lookup to pull in everything from the WTF
-// namespace when you use Noncopyable, so put it in its own namespace.
-
-#include "FastAllocBase.h"
-
-namespace WTFNoncopyable {
-
- class Noncopyable : public FastAllocBase {
- Noncopyable(const Noncopyable&);
- Noncopyable& operator=(const Noncopyable&);
- protected:
- Noncopyable() { }
- ~Noncopyable() { }
- };
-
-} // namespace WTFNoncopyable
-
-using WTFNoncopyable::Noncopyable;
-
#endif // WTF_Noncopyable_h
template<typename T> class PassOwnArrayPtr;
template<typename T> PassOwnArrayPtr<T> adoptArrayPtr(T*);
-template <typename T> class OwnArrayPtr : public Noncopyable {
+template <typename T> class OwnArrayPtr {
public:
typedef T* PtrType;
#define OwnFastMallocPtr_h
#include "FastMalloc.h"
-#include "Noncopyable.h"
namespace WTF {
- template<class T> class OwnFastMallocPtr : public Noncopyable {
+ template<class T> class OwnFastMallocPtr {
+ WTF_MAKE_NONCOPYABLE(OwnFastMallocPtr);
public:
explicit OwnFastMallocPtr(T* ptr) : m_ptr(ptr)
{
#define WTF_OwnPtr_h
#include "Assertions.h"
-#include "Noncopyable.h"
#include "NullPtr.h"
#include "OwnPtrCommon.h"
#include "TypeTraits.h"
template<typename T> class PassOwnPtr;
template<typename T> PassOwnPtr<T> adoptPtr(T*);
- template<typename T> class OwnPtr : public Noncopyable {
+ template<typename T> class OwnPtr {
public:
typedef typename RemovePointer<T>::Type ValueType;
typedef ValueType* PtrType;
#define RefCounted_h
#include "Assertions.h"
+#include "FastAllocBase.h"
#include "Noncopyable.h"
namespace WTF {
#endif
-template<typename T> class RefCounted : public RefCountedBase, public Noncopyable {
+template<typename T> class RefCounted : public RefCountedBase {
+ WTF_MAKE_NONCOPYABLE(RefCounted); WTF_MAKE_FAST_ALLOCATED;
public:
void deref()
{
}
protected:
+ RefCounted() { }
~RefCounted()
{
}
enum HashTableDeletedValueType { HashTableDeletedValue };
- template<typename T> class RefPtr : public FastAllocBase {
+ template<typename T> class RefPtr {
+ WTF_MAKE_FAST_ALLOCATED;
public:
ALWAYS_INLINE RefPtr() : m_ptr(0) { }
ALWAYS_INLINE RefPtr(T* ptr) : m_ptr(ptr) { refIfNotNull(ptr); }
};
template<typename T, typename MappedArg, typename HashArg, typename KeyTraitsArg, typename MappedTraitsArg>
- class HashMap<RefPtr<T>, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg> : public FastAllocBase {
+ class HashMap<RefPtr<T>, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg> {
+ WTF_MAKE_FAST_ALLOCATED;
private:
typedef KeyTraitsArg KeyTraits;
typedef MappedTraitsArg MappedTraits;
#ifndef ThreadIdentifierDataPthreads_h
#define ThreadIdentifierDataPthreads_h
-#include <wtf/Noncopyable.h>
#include <wtf/Threading.h>
namespace WTF {
// Holds ThreadIdentifier in the thread-specific storage and employs pthreads-specific 2-pass destruction to reliably remove
// ThreadIdentifier from threadMap. It assumes regular ThreadSpecific types don't use multiple-pass destruction.
-class ThreadIdentifierData : public Noncopyable {
+class ThreadIdentifierData {
+ WTF_MAKE_NONCOPYABLE(ThreadIdentifierData);
public:
~ThreadIdentifierData();
#include "Platform.h"
#include <wtf/Atomics.h>
-#include <wtf/Noncopyable.h>
#include <wtf/ThreadingPrimitives.h>
namespace WTF {
-class ThreadSafeSharedBase : public Noncopyable {
+class ThreadSafeSharedBase {
+ WTF_MAKE_NONCOPYABLE(ThreadSafeSharedBase); WTF_MAKE_FAST_ALLOCATED;
public:
ThreadSafeSharedBase(int initialRefCount = 1)
: m_refCount(initialRefCount)
void ThreadSpecificThreadExit();
#endif
-template<typename T> class ThreadSpecific : public Noncopyable {
+template<typename T> class ThreadSpecific {
+ WTF_MAKE_NONCOPYABLE(ThreadSpecific);
public:
ThreadSpecific();
T* operator->();
void static destroy(void* ptr);
#if USE(PTHREADS) || PLATFORM(QT) || PLATFORM(GTK) || OS(WINDOWS)
- struct Data : Noncopyable {
+ struct Data {
+ WTF_MAKE_NONCOPYABLE(Data);
+ public:
Data(T* value, ThreadSpecific<T>* owner) : value(value), owner(owner) {}
#if PLATFORM(QT)
~Data() { owner->destroy(this); }
#include "config.h"
#include "ThreadSpecific.h"
-#include <wtf/Noncopyable.h>
#if USE(PTHREADS)
#error This file should not be compiled by ports that do not use Windows native ThreadSpecific implementation.
namespace WTF {
-struct NewThreadContext : FastAllocBase {
+struct NewThreadContext {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
NewThreadContext(ThreadFunction entryPoint, void* data, const char* name)
: entryPoint(entryPoint)
, data(data)
#include "Platform.h"
#include <wtf/Assertions.h>
+#include <wtf/FastAllocBase.h>
#include <wtf/Locker.h>
#include <wtf/Noncopyable.h>
typedef void* PlatformCondition;
#endif
-class Mutex : public Noncopyable {
+class Mutex {
+ WTF_MAKE_NONCOPYABLE(Mutex); WTF_MAKE_FAST_ALLOCATED;
public:
Mutex();
~Mutex();
typedef Locker<Mutex> MutexLocker;
-class ReadWriteLock : public Noncopyable {
+class ReadWriteLock {
+ WTF_MAKE_NONCOPYABLE(ReadWriteLock);
public:
ReadWriteLock();
~ReadWriteLock();
PlatformReadWriteLock m_readWriteLock;
};
-class ThreadCondition : public Noncopyable {
+class ThreadCondition {
+ WTF_MAKE_NONCOPYABLE(ThreadCondition);
public:
ThreadCondition();
~ThreadCondition();
};
template<typename T>
- class VectorBufferBase : public Noncopyable {
+ class VectorBufferBase {
+ WTF_MAKE_NONCOPYABLE(VectorBufferBase);
public:
void allocateBuffer(size_t newCapacity)
{
};
template<typename T, size_t inlineCapacity = 0>
- class Vector : public FastAllocBase {
+ class Vector {
+ WTF_MAKE_FAST_ALLOCATED;
private:
typedef VectorBuffer<T, inlineCapacity> Buffer;
typedef VectorTypeOperations<T> TypeOperations;
typedef HashMap<const char*, RefPtr<StringImpl>, PtrHash<const char*> > LiteralIdentifierTable;
-class IdentifierTable : public FastAllocBase {
+class IdentifierTable {
+ WTF_MAKE_FAST_ALLOCATED;
public:
~IdentifierTable();
typedef void (*AtomicStringTableDestructor)(AtomicStringTable*);
-class WTFThreadData : public Noncopyable {
+class WTFThreadData {
+ WTF_MAKE_NONCOPYABLE(WTFThreadData);
public:
WTFThreadData();
~WTFThreadData();
aRef = c;
}
-struct P5Node : Noncopyable {
+struct P5Node {
+ WTF_MAKE_NONCOPYABLE(P5Node); WTF_MAKE_FAST_ALLOCATED;
+public:
+ P5Node() { }
BigInt val;
P5Node* next;
};
template<> void freeOwnedGPtr<GDir>(GDir*);
template<> void freeOwnedGPtr<GFile>(GFile*);
-template <typename T> class GOwnPtr : public Noncopyable {
+template <typename T> class GOwnPtr {
+ WTF_MAKE_NONCOPYABLE(GOwnPtr);
public:
explicit GOwnPtr(T* ptr = 0) : m_ptr(ptr) { }
~GOwnPtr() { freeOwnedGPtr(m_ptr); }
#define StringBuffer_h
#include <wtf/Assertions.h>
-#include <wtf/Noncopyable.h>
#include <wtf/unicode/Unicode.h>
#include <limits>
namespace WTF {
-class StringBuffer : public Noncopyable {
+class StringBuffer {
+ WTF_MAKE_NONCOPYABLE(StringBuffer);
public:
explicit StringBuffer(unsigned length)
: m_length(length)
#ifndef StringImplBase_h
#define StringImplBase_h
-#include <wtf/Noncopyable.h>
#include <wtf/unicode/Unicode.h>
namespace WTF {
-class StringImplBase : public Noncopyable {
+class StringImplBase {
+ WTF_MAKE_NONCOPYABLE(StringImplBase); WTF_MAKE_FAST_ALLOCATED;
public:
bool isStringImpl() { return (m_refCountAndFlags & s_refCountInvalidForStringImpl) != s_refCountInvalidForStringImpl; }
unsigned length() const { return m_length; }
BufferShared,
};
- using Noncopyable::operator new;
- void* operator new(size_t, void* inPlace) { ASSERT(inPlace); return inPlace; }
-
// For SmallStringStorage, which allocates an array and uses an in-place new.
StringImplBase() { }
#ifndef WTF_Collator_h
#define WTF_Collator_h
+#include <wtf/FastAllocBase.h>
#include <wtf/Noncopyable.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/unicode/Unicode.h>
namespace WTF {
- class Collator : public Noncopyable {
+ class Collator {
+ WTF_MAKE_NONCOPYABLE(Collator); WTF_MAKE_FAST_ALLOCATED;
public:
enum Result { Equal = 0, Greater = 1, Less = -1 };
}
};
-class ByteDisjunction : public FastAllocBase {
+class ByteDisjunction {
+ WTF_MAKE_FAST_ALLOCATED;
public:
ByteDisjunction(unsigned numSubpatterns, unsigned frameSize)
: m_numSubpatterns(numSubpatterns)
unsigned m_frameSize;
};
-struct BytecodePattern : FastAllocBase {
+struct BytecodePattern {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
BytecodePattern(PassOwnPtr<ByteDisjunction> body, Vector<ByteDisjunction*> allParenthesesInfo, YarrPattern& pattern, BumpPointerAllocator* allocator)
: m_body(body)
, m_ignoreCase(pattern.m_ignoreCase)
}
};
-struct CharacterClass : FastAllocBase {
+struct CharacterClass {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
// All CharacterClass instances have to have the full set of matches and ranges,
// they may have an optional table for faster lookups (which must match the
// specified matches and ranges)
}
};
-struct PatternAlternative : FastAllocBase {
+struct PatternAlternative {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
PatternAlternative(PatternDisjunction* disjunction)
: m_parent(disjunction)
, m_onceThrough(false)
bool m_containsBOL : 1;
};
-struct PatternDisjunction : FastAllocBase {
+struct PatternDisjunction {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
PatternDisjunction(PatternAlternative* parent = 0)
: m_parent(parent)
, m_hasFixedSize(false)
+2011-01-20 Zoltan Horvath <zoltan@webkit.org>
+
+ Reviewed by Csaba Osztrogonác.
+
+ Refactoring of the custom allocation framework
+ https://bugs.webkit.org/show_bug.cgi?id=49897
+
+ Inheriting from FastAllocBase can result in objects getting larger (bug #33896, #46589).
+ The modification replaces Noncopyable and FastAllocBase classes and these inherits with their
+ equivalent macro implementation at the necessary places.
+
2011-01-20 Mikhail Naganov <mnaganov@chromium.org>
Reviewed by Pavel Feldman.
enum PostType { PostSynchronously, PostAsynchronously };
-class AXObjectCache : public Noncopyable {
+class AXObjectCache {
+ WTF_MAKE_NONCOPYABLE(AXObjectCache); WTF_MAKE_FAST_ALLOCATED;
public:
AXObjectCache(const Document*);
~AXObjectCache();
namespace WebCore {
class CachedScriptSourceProvider : public ScriptSourceProvider, public CachedResourceClient {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static PassRefPtr<CachedScriptSourceProvider> create(CachedScript* cachedScript) { return adoptRef(new CachedScriptSourceProvider(cachedScript)); }
#ifndef GCController_h
#define GCController_h
-#include <wtf/Noncopyable.h>
#include "Timer.h"
namespace WebCore {
- class GCController : public Noncopyable {
+ class GCController {
+ WTF_MAKE_NONCOPYABLE(GCController); WTF_MAKE_FAST_ALLOCATED;
friend GCController& gcController();
public:
// - wrappers being deleted without being removed from the cache
// - wrappers being cached twice
-class JSDebugWrapperSet : public Noncopyable {
+class JSDebugWrapperSet {
+ WTF_MAKE_NONCOPYABLE(JSDebugWrapperSet);
friend class WTF::ThreadSpecific<JSDebugWrapperSet>;
public:
static JSDebugWrapperSet& shared();
#ifndef NDEBUG
#include <wtf/MainThread.h>
#endif
-#include <wtf/Noncopyable.h>
namespace WebCore {
-class JSMainThreadExecState : public Noncopyable {
+class JSMainThreadExecState {
+ WTF_MAKE_NONCOPYABLE(JSMainThreadExecState);
public:
static JSC::ExecState* currentState()
{
* time interval, either once or repeatedly. Used for window.setTimeout()
* and window.setInterval()
*/
- class ScheduledAction : public Noncopyable {
+ class ScheduledAction {
+ WTF_MAKE_NONCOPYABLE(ScheduledAction); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<ScheduledAction> create(JSC::ExecState*, DOMWrapperWorld* isolatedWorld);
class DOMWindow;
class DOMWrapperWorld;
- class ScriptCachedFrameData : public Noncopyable {
+ class ScriptCachedFrameData {
+ WTF_MAKE_NONCOPYABLE(ScriptCachedFrameData); WTF_MAKE_FAST_ALLOCATED;
typedef HashMap< RefPtr<DOMWrapperWorld>, JSC::ProtectedPtr<JSDOMWindow> > JSDOMWindowSet;
public:
class ScriptDebugListener;
class JavaScriptCallFrame;
-class ScriptDebugServer : JSC::Debugger, public Noncopyable {
+class ScriptDebugServer : JSC::Debugger {
+ WTF_MAKE_NONCOPYABLE(ScriptDebugServer); WTF_MAKE_FAST_ALLOCATED;
public:
static ScriptDebugServer& shared();
#include "ScriptProfile.h"
#include "ScriptState.h"
-#include <wtf/Noncopyable.h>
namespace WebCore {
-class ScriptProfiler : public Noncopyable {
+class ScriptProfiler {
+ WTF_MAKE_NONCOPYABLE(ScriptProfiler);
public:
static void start(ScriptState* state, const String& title);
static PassRefPtr<ScriptProfile> stop(ScriptState* state, const String& title);
// For now, the separation is purely by convention.
typedef JSC::ExecState ScriptState;
-class ScriptStateProtectedPtr : public Noncopyable {
+class ScriptStateProtectedPtr {
+ WTF_MAKE_NONCOPYABLE(ScriptStateProtectedPtr);
public:
explicit ScriptStateProtectedPtr(ScriptState*);
~ScriptStateProtectedPtr();
#include "DOMWrapperWorld.h"
#include "DOMObjectHashTableMap.h"
-#include <wtf/Noncopyable.h>
#include <wtf/HashSet.h>
#include <wtf/RefPtr.h>
namespace WebCore {
-class WebCoreJSClientData : public JSC::JSGlobalData::ClientData, public Noncopyable {
+class WebCoreJSClientData : public JSC::JSGlobalData::ClientData {
+ WTF_MAKE_NONCOPYABLE(WebCoreJSClientData); WTF_MAKE_FAST_ALLOCATED;
friend class JSGlobalDataWorldIterator;
friend void initNormalWorldClientData(JSC::JSGlobalData*);
public:
+ WebCoreJSClientData() { }
virtual ~WebCoreJSClientData()
{
ASSERT(m_worldSet.contains(m_normalWorld.get()));
#include <runtime/Protect.h>
#include <wtf/Forward.h>
-#include <wtf/Noncopyable.h>
#include <wtf/Threading.h>
namespace JSC {
class ScriptValue;
class WorkerContext;
- class WorkerScriptController : public Noncopyable {
+ class WorkerScriptController {
+ WTF_MAKE_NONCOPYABLE(WorkerScriptController); WTF_MAKE_FAST_ALLOCATED;
public:
WorkerScriptController(WorkerContext*);
~WorkerScriptController();
// thread. The DOMData for the main thread and the DOMData for child threads
// use different subclasses.
//
- class DOMData : public Noncopyable {
+ class DOMData {
+ WTF_MAKE_NONCOPYABLE(DOMData);
public:
DOMData();
virtual ~DOMData();
// This class doesn't manage the lifetime of the store. The data store
// lifetime is managed by subclasses.
//
- class DOMDataStore : public Noncopyable {
+ class DOMDataStore {
+ WTF_MAKE_NONCOPYABLE(DOMDataStore);
public:
enum DOMWrapperMapType {
DOMNodeMap,
#include "OwnHandle.h"
#include <v8.h>
-#include <wtf/Noncopyable.h>
namespace WebCore {
class Frame;
class DOMWindow;
-class ScriptCachedFrameData : public Noncopyable {
+class ScriptCachedFrameData {
+ WTF_MAKE_NONCOPYABLE(ScriptCachedFrameData);
public:
ScriptCachedFrameData(Frame*);
~ScriptCachedFrameData() { }
class Page;
class ScriptDebugListener;
-class ScriptDebugServer : public Noncopyable {
+class ScriptDebugServer {
+ WTF_MAKE_NONCOPYABLE(ScriptDebugServer);
public:
static ScriptDebugServer& shared();
#include "ScriptProfile.h"
#include "ScriptState.h"
-#include <wtf/Noncopyable.h>
namespace WebCore {
class InspectorObject;
-class ScriptProfiler : public Noncopyable {
+class ScriptProfiler {
+ WTF_MAKE_NONCOPYABLE(ScriptProfiler);
public:
static void start(ScriptState* state, const String& title);
static PassRefPtr<ScriptProfile> stop(ScriptState* state, const String& title);
class Node;
class Page;
-class ScriptState : public Noncopyable {
+class ScriptState {
+ WTF_MAKE_NONCOPYABLE(ScriptState);
public:
bool hadException() { return !m_exception.IsEmpty(); }
void setException(v8::Local<v8::Value> exception)
~EmptyScriptState() { }
};
-class ScriptStateProtectedPtr : public Noncopyable {
+class ScriptStateProtectedPtr {
+ WTF_MAKE_NONCOPYABLE(ScriptStateProtectedPtr);
public:
ScriptStateProtectedPtr() : m_scriptState(0) { }
ScriptStateProtectedPtr(ScriptState* scriptState) : m_scriptState(scriptState)
// Writer is responsible for serializing primitive types and storing
// information used to reconstruct composite types.
-class Writer : Noncopyable {
+class Writer {
+ WTF_MAKE_NONCOPYABLE(Writer);
public:
Writer()
: m_position(0)
}
private:
- class StateBase : public Noncopyable {
+ class StateBase {
+ WTF_MAKE_NONCOPYABLE(StateBase);
public:
virtual ~StateBase() { }
#define Bridge_h
#include "BridgeJSC.h"
-#include <wtf/Noncopyable.h>
namespace JSC {
namespace Bindings {
-class Method : public Noncopyable {
+class Method {
+ WTF_MAKE_NONCOPYABLE(Method); WTF_MAKE_FAST_ALLOCATED;
public:
+ Method() { }
virtual int numParameters() const = 0;
virtual ~Method() { }
namespace WebCore {
-class IdentifierRep : public FastAllocBase {
+class IdentifierRep {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static IdentifierRep* get(int);
static IdentifierRep* get(const char*);
virtual ~Field() { }
};
-class Class : public Noncopyable {
+class Class {
+ WTF_MAKE_NONCOPYABLE(Class); WTF_MAKE_FAST_ALLOCATED;
public:
+ Class() { }
virtual MethodList methodsNamed(const Identifier&, Instance*) const = 0;
virtual Field* fieldNamed(const Identifier&, Instance*) const = 0;
virtual JSValue fallbackObject(ExecState*, Instance*, const Identifier&) { return jsUndefined(); }
WeakGCPtr<RuntimeObject> m_runtimeObject;
};
-class Array : public Noncopyable {
+class Array {
+ WTF_MAKE_NONCOPYABLE(Array);
public:
Array(PassRefPtr<RootObject>);
virtual ~Array();
class StyleImage;
class CSSImageValue : public CSSPrimitiveValue, private CachedResourceClient {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static PassRefPtr<CSSImageValue> create() { return adoptRef(new CSSImageValue); }
static PassRefPtr<CSSImageValue> create(const String& url) { return adoptRef(new CSSImageValue(url)); }
class MediaList;
class CSSImportRule : public CSSRule, private CachedResourceClient {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static PassRefPtr<CSSImportRule> create(CSSStyleSheet* parent, const String& href, PassRefPtr<MediaList> media)
{
namespace WebCore {
- struct CSSNamespace : Noncopyable {
+ struct CSSNamespace {
+ WTF_MAKE_NONCOPYABLE(CSSNamespace); WTF_MAKE_FAST_ALLOCATED;
+ public:
AtomicString prefix;
AtomicString uri;
OwnPtr<CSSNamespace> parent;
int cssPropertyID(const String&);
int cssValueKeywordID(const CSSParserString&);
- class ShorthandScope : public FastAllocBase {
+ class ShorthandScope {
+ WTF_MAKE_FAST_ALLOCATED;
public:
ShorthandScope(CSSParser* parser, int propId) : m_parser(parser)
{
PassRefPtr<CSSValue> createCSSValue();
};
-class CSSParserValueList : public FastAllocBase {
+class CSSParserValueList {
+ WTF_MAKE_FAST_ALLOCATED;
public:
CSSParserValueList()
: m_current(0)
Vector<CSSParserValue, 4> m_values;
};
-struct CSSParserFunction : FastAllocBase {
+struct CSSParserFunction {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
CSSParserString name;
OwnPtr<CSSParserValueList> args;
};
namespace WebCore {
-class CSSProperty : public FastAllocBase {
+class CSSProperty {
+ WTF_MAKE_FAST_ALLOCATED;
public:
CSSProperty(int propID, PassRefPtr<CSSValue> value, bool important = false, int shorthandID = 0, bool implicit = false)
: m_id(propID)
using namespace HTMLNames;
-class CSSSelectorBag : public Noncopyable {
+class CSSSelectorBag {
+ WTF_MAKE_NONCOPYABLE(CSSSelectorBag);
public:
+ CSSSelectorBag() { }
~CSSSelectorBag()
{
ASSERT(isEmpty());
class CSSSelectorBag;
// this class represents a selector for a StyleRule
- class CSSSelector : public Noncopyable {
+ class CSSSelector {
+ WTF_MAKE_NONCOPYABLE(CSSSelector); WTF_MAKE_FAST_ALLOCATED;
public:
CSSSelector()
: m_relation(Descendant)
unsigned specificityForPage() const;
void extractPseudoType() const;
- struct RareData : Noncopyable {
+ struct RareData {
+ WTF_MAKE_NONCOPYABLE(RareData); WTF_MAKE_FAST_ALLOCATED;
+ public:
RareData(PassOwnPtr<CSSSelector> tagHistory)
: m_a(0)
, m_b(0)
#define CSSSelectorList_h
#include "CSSSelector.h"
-#include <wtf/Noncopyable.h>
namespace WebCore {
-class CSSSelectorList : public Noncopyable {
+class CSSSelectorList {
+ WTF_MAKE_NONCOPYABLE(CSSSelectorList); WTF_MAKE_FAST_ALLOCATED;
public:
CSSSelectorList() : m_selectorArray(0) { }
~CSSSelectorList();
return; \
}
-class CSSRuleData : public Noncopyable {
+class CSSRuleData {
+ WTF_MAKE_NONCOPYABLE(CSSRuleData);
public:
CSSRuleData(unsigned pos, CSSStyleRule* r, CSSSelector* sel, CSSRuleData* prev = 0)
: m_position(pos)
CSSRuleData* m_next;
};
-class CSSRuleDataList : public Noncopyable {
+class CSSRuleDataList {
+ WTF_MAKE_NONCOPYABLE(CSSRuleDataList);
public:
CSSRuleDataList(unsigned pos, CSSStyleRule* rule, CSSSelector* sel)
: m_first(new CSSRuleData(pos, rule, sel))
CSSRuleData* m_last;
};
-class CSSRuleSet : public Noncopyable {
+class CSSRuleSet {
+ WTF_MAKE_NONCOPYABLE(CSSRuleSet);
public:
CSSRuleSet();
~CSSRuleSet();
class WebKitCSSKeyframeRule;
class WebKitCSSKeyframesRule;
-class MediaQueryResult : public Noncopyable {
+class MediaQueryResult {
+ WTF_MAKE_NONCOPYABLE(MediaQueryResult); WTF_MAKE_FAST_ALLOCATED;
public:
MediaQueryResult(const MediaQueryExp& expr, bool result)
: m_expression(expr)
};
// This class selects a RenderStyle for a given element based on a collection of stylesheets.
- class CSSStyleSelector : public Noncopyable {
+ class CSSStyleSelector {
+ WTF_MAKE_NONCOPYABLE(CSSStyleSelector); WTF_MAKE_FAST_ALLOCATED;
public:
CSSStyleSelector(Document*, StyleSheetList* authorSheets, CSSStyleSheet* mappedElementSheet,
CSSStyleSheet* pageUserSheet, const Vector<RefPtr<CSSStyleSheet> >* pageGroupUserSheets,
public:
static RenderStyle* styleNotYetAvailable() { return s_styleNotYetAvailable; }
- class SelectorChecker : public Noncopyable {
+ class SelectorChecker {
+ WTF_MAKE_NONCOPYABLE(SelectorChecker);
public:
SelectorChecker(Document*, bool strictParsing);
namespace WebCore {
class MediaQueryExp;
-class MediaQuery : public Noncopyable {
+class MediaQuery {
+ WTF_MAKE_NONCOPYABLE(MediaQuery); WTF_MAKE_FAST_ALLOCATED;
public:
enum Restrictor {
Only, Not, None
* the device characteristics are not known. This can be used to prune the loading
* of stylesheets to only those which are probable to match.
*/
-class MediaQueryEvaluator : public Noncopyable {
+class MediaQueryEvaluator {
+ WTF_MAKE_NONCOPYABLE(MediaQueryEvaluator); WTF_MAKE_FAST_ALLOCATED;
public:
/** Creates evaluator which evaluates only simple media queries
* Evaluator returns true for "all", and returns value of \mediaFeatureResult
namespace WebCore {
class CSSParserValueList;
-class MediaQueryExp : public FastAllocBase {
+class MediaQueryExp {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<MediaQueryExp> create(const AtomicString& mediaFeature, CSSParserValueList* values);
~MediaQueryExp();
class PendingScript;
class ScriptElement;
-class AsyncScriptRunner : public Noncopyable {
+class AsyncScriptRunner {
+ WTF_MAKE_NONCOPYABLE(AsyncScriptRunner); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<AsyncScriptRunner> create(Document* document) { return new AsyncScriptRunner(document); }
~AsyncScriptRunner();
class Element;
typedef int ExceptionCode;
-class DOMStringMap : public Noncopyable {
+class DOMStringMap {
+ WTF_MAKE_NONCOPYABLE(DOMStringMap); WTF_MAKE_FAST_ALLOCATED;
public:
virtual ~DOMStringMap();
window->console()->addMessage(source, type, level, message, lineNumber, sourceURL, callStack);
}
-struct PerformTaskContext : Noncopyable {
+struct PerformTaskContext {
+ WTF_MAKE_NONCOPYABLE(PerformTaskContext); WTF_MAKE_FAST_ALLOCATED;
+public:
PerformTaskContext(PassRefPtr<DocumentWeakReference> documentReference, PassOwnPtr<ScriptExecutionContext::Task> task)
: documentReference(documentReference)
, task(task)
class Node;
class Range;
-class DocumentMarkerController : public Noncopyable {
+class DocumentMarkerController {
+ WTF_MAKE_NONCOPYABLE(DocumentMarkerController); WTF_MAKE_FAST_ALLOCATED;
public:
+ DocumentMarkerController() { }
~DocumentMarkerController() { detach(); }
void detach();
#ifndef Event_h
#define Event_h
+#include "Clipboard.h"
#include "DOMTimeStamp.h"
#include <wtf/RefCounted.h>
#include <wtf/text/AtomicString.h>
namespace WebCore {
- class Clipboard;
class EventTarget;
class Event : public RefCounted<Event> {
\
// end of DOM_EVENT_NAMES_FOR_EACH
- class EventNames : public Noncopyable {
+ class EventNames {
+ WTF_MAKE_NONCOPYABLE(EventNames); WTF_MAKE_FAST_ALLOCATED;
int dummy; // Needed to make initialization macro work.
// Private to prevent accidental call to EventNames() instead of eventNames()
EventNames();
typedef Vector<RegisteredEventListener, 1> EventListenerVector;
typedef HashMap<AtomicString, EventListenerVector*> EventListenerMap;
- struct EventTargetData : Noncopyable {
+ struct EventTargetData {
+ WTF_MAKE_NONCOPYABLE(EventTargetData); WTF_MAKE_FAST_ALLOCATED;
+ public:
EventTargetData();
~EventTargetData();
#define IgnoreDestructiveWriteCountIncrementer_h
#include "Document.h"
-#include <wtf/Noncopyable.h>
namespace WebCore {
-class IgnoreDestructiveWriteCountIncrementer : public Noncopyable {
+class IgnoreDestructiveWriteCountIncrementer {
+ WTF_MAKE_NONCOPYABLE(IgnoreDestructiveWriteCountIncrementer);
public:
explicit IgnoreDestructiveWriteCountIncrementer(Document* document)
: m_count(document ? &document->m_ignoreDestructiveWriteCount : 0)
// MessagePortChannel is a platform-independent interface to the remote side of a message channel.
// It acts as a wrapper around the platform-dependent PlatformMessagePortChannel implementation which ensures that the platform-dependent close() method is invoked before destruction.
- class MessagePortChannel : public Noncopyable {
+ class MessagePortChannel {
+ WTF_MAKE_NONCOPYABLE(MessagePortChannel); WTF_MAKE_FAST_ALLOCATED;
public:
static void createChannel(PassRefPtr<MessagePort>, PassRefPtr<MessagePort>);
// Returns true if the proxy currently contains messages for this port.
bool hasPendingActivity();
- class EventData : public Noncopyable {
+ class EventData {
+ WTF_MAKE_NONCOPYABLE(EventData); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<EventData> create(PassRefPtr<SerializedScriptValue>, PassOwnPtr<MessagePortChannelArray>);
namespace WebCore {
-struct NodeListsNodeData : Noncopyable {
+struct NodeListsNodeData {
+ WTF_MAKE_NONCOPYABLE(NodeListsNodeData); WTF_MAKE_FAST_ALLOCATED;
+public:
typedef HashSet<DynamicNodeList*> NodeListSet;
NodeListSet m_listsWithCaches;
}
};
-class NodeRareData : public Noncopyable {
+class NodeRareData {
+ WTF_MAKE_NONCOPYABLE(NodeRareData); WTF_MAKE_FAST_ALLOCATED;
public:
NodeRareData()
: m_tabIndex(0)
StringImpl* m_namespace;
};
-class QualifiedName : public FastAllocBase {
+class QualifiedName {
+ WTF_MAKE_FAST_ALLOCATED;
public:
class QualifiedNameImpl : public RefCounted<QualifiedNameImpl> {
public:
class ScriptSourceCode;
class ScriptElement : private CachedResourceClient {
+ WTF_MAKE_FAST_ALLOCATED;
public:
ScriptElement(Element*, bool createdByParser, bool isEvaluated);
virtual ~ScriptElement();
}
};
-class ScriptExecutionContext::PendingException : public Noncopyable {
+class ScriptExecutionContext::PendingException {
+ WTF_MAKE_NONCOPYABLE(PendingException);
public:
PendingException(const String& errorMessage, int lineNumber, const String& sourceURL, PassRefPtr<ScriptCallStack> callStack)
: m_errorMessage(errorMessage)
#include <wtf/Forward.h>
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>
+#include <wtf/Noncopyable.h>
#include <wtf/OwnPtr.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/PassRefPtr.h>
void ref() { refScriptExecutionContext(); }
void deref() { derefScriptExecutionContext(); }
- class Task : public Noncopyable {
+ class Task {
+ WTF_MAKE_NONCOPYABLE(Task); WTF_MAKE_FAST_ALLOCATED;
public:
+ Task() { }
virtual ~Task();
virtual void performTask(ScriptExecutionContext*) = 0;
// Certain tasks get marked specially so that they aren't discarded, and are executed, when the context is shutting down its message queue.
namespace WebCore {
- class SpaceSplitStringData : public Noncopyable {
+ class SpaceSplitStringData {
+ WTF_MAKE_NONCOPYABLE(SpaceSplitStringData); WTF_MAKE_FAST_ALLOCATED;
public:
SpaceSplitStringData(const String& string, bool shouldFoldCase)
: m_string(string), m_shouldFoldCase(shouldFoldCase), m_createdVector(false)
typedef void* PlatformTransformSource;
#endif
- class TransformSource : public Noncopyable {
+ class TransformSource {
+ WTF_MAKE_NONCOPYABLE(TransformSource); WTF_MAKE_FAST_ALLOCATED;
public:
TransformSource(const PlatformTransformSource& source);
~TransformSource();
DefinitelyNotProcessingUserGesture
};
-class UserGestureIndicator : public Noncopyable {
+class UserGestureIndicator {
+ WTF_MAKE_NONCOPYABLE(UserGestureIndicator);
public:
static bool processingUserGesture() { return s_processingUserGesture == DefinitelyProcessingUserGesture; }
static ProcessingUserGestureState getUserGestureState() { return s_processingUserGesture; }
class Frame;
class Node;
-class UserTypingGestureIndicator : public Noncopyable {
+class UserTypingGestureIndicator {
+ WTF_MAKE_NONCOPYABLE(UserTypingGestureIndicator);
public:
static bool processingUserTypingGesture();
static Node* focusedElementAtGestureStart();
#endif
class XMLDocumentParser : public ScriptableDocumentParser, public CachedResourceClient {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static PassRefPtr<XMLDocumentParser> create(Document* document, FrameView* view)
{
namespace WebCore {
-class PendingCallbacks : public Noncopyable {
+class PendingCallbacks {
+ WTF_MAKE_NONCOPYABLE(PendingCallbacks);
public:
+ PendingCallbacks() { }
~PendingCallbacks()
{
deleteAllValues(m_callbacks);
class CachedResourceLoader;
- class XMLDocumentParserScope : public Noncopyable {
+ class XMLDocumentParserScope {
+ WTF_MAKE_NONCOPYABLE(XMLDocumentParserScope);
public:
XMLDocumentParserScope(CachedResourceLoader* cachedResourceLoader);
~XMLDocumentParserScope();
class RenderObject;
class VisibleSelection;
-class DeleteButtonController : public Noncopyable {
+class DeleteButtonController {
+ WTF_MAKE_NONCOPYABLE(DeleteButtonController); WTF_MAKE_FAST_ALLOCATED;
public:
DeleteButtonController(Frame*);
// --- ReplacementFragment helper class
-class ReplacementFragment : public Noncopyable {
+class ReplacementFragment {
+ WTF_MAKE_NONCOPYABLE(ReplacementFragment);
public:
ReplacementFragment(Document*, DocumentFragment*, bool matchStyle, const VisibleSelection&);
enum DirectionalityPolicy { MakeNonDirectionalSelection, MakeDirectionalSelection };
-class SelectionController : public Noncopyable {
+class SelectionController {
+ WTF_MAKE_NONCOPYABLE(SelectionController); WTF_MAKE_FAST_ALLOCATED;
public:
enum EAlteration { AlterationMove, AlterationExtend };
enum CursorAlignOnScroll { AlignCursorOnScrollIfNeeded,
int m_length;
};
-class SpellChecker : public Noncopyable {
+class SpellChecker {
+ WTF_MAKE_NONCOPYABLE(SpellChecker);
public:
explicit SpellChecker(Frame*, EditorClient*);
~SpellChecker();
mutable int m_checkingLength;
};
-class TextCheckingHelper : public Noncopyable {
+class TextCheckingHelper {
+ WTF_MAKE_NONCOPYABLE(TextCheckingHelper);
public:
TextCheckingHelper(EditorClient*, PassRefPtr<Range>);
~TextCheckingHelper();
// Case folding is also done if the CaseInsensitive option is specified.
// Matches are further filtered if the AtWordStarts option is specified, although some
// matches inside a word are permitted if TreatMedialCapitalAsWordStart is specified as well.
-class SearchBuffer : public Noncopyable {
+class SearchBuffer {
+ WTF_MAKE_NONCOPYABLE(SearchBuffer);
public:
SearchBuffer(const String& target, FindOptions);
~SearchBuffer();
bool start();
void stop();
- class Task : public Noncopyable {
+ class Task {
+ WTF_MAKE_NONCOPYABLE(Task);
public:
virtual ~Task() { }
virtual void performTask() = 0;
class ScriptExecutionContext;
// Keeps per-process information and provides an entry point to open a file system.
-class LocalFileSystem : public Noncopyable {
+class LocalFileSystem {
+ WTF_MAKE_NONCOPYABLE(LocalFileSystem);
public:
// Returns a per-process instance of LocalFileSystem.
// Note that LocalFileSystem::initializeLocalFileSystem must be called before
// A helper template for FileSystemSync implementation.
template <typename SuccessCallback, typename ObserverType, typename CallbackArg, typename ResultType>
-class SyncCallbackHelper : public Noncopyable {
+class SyncCallbackHelper {
+ WTF_MAKE_NONCOPYABLE(SyncCallbackHelper);
public:
typedef SyncCallbackHelper<SuccessCallback, ObserverType, CallbackArg, ResultType> HelperType;
SyncCallbackHelper(ObserverType* observer = 0)
class HistoryItem;
class Page;
-class BackForwardController : public Noncopyable {
+class BackForwardController {
+ WTF_MAKE_NONCOPYABLE(BackForwardController); WTF_MAKE_FAST_ALLOCATED;
public:
BackForwardController(Page*, PassRefPtr<BackForwardList>);
~BackForwardController();
class HistoryItem;
class Page;
- class PageCache : public Noncopyable {
+ class PageCache {
+ WTF_MAKE_NONCOPYABLE(PageCache); WTF_MAKE_FAST_ALLOCATED;
public:
friend PageCache* pageCache();
class Element;
-struct CollectionCache : FastAllocBase {
+struct CollectionCache {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
CollectionCache();
CollectionCache(const CollectionCache&);
CollectionCache& operator=(const CollectionCache& other)
namespace WebCore {
class DOMSettableTokenList : public DOMTokenList, public RefCounted<DOMSettableTokenList> {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static PassRefPtr<DOMSettableTokenList> create()
{
#include "ExceptionCode.h"
#include <wtf/text/AtomicString.h>
-#include <wtf/Noncopyable.h>
#include <wtf/Vector.h>
namespace WebCore {
class Element;
-class DOMTokenList : public Noncopyable {
+class DOMTokenList {
+ WTF_MAKE_NONCOPYABLE(DOMTokenList); WTF_MAKE_FAST_ALLOCATED;
public:
+ DOMTokenList() { }
virtual ~DOMTokenList() {};
virtual void ref() = 0;
#define HTMLParserQuirks_h
#include <wtf/Forward.h>
-#include <wtf/Noncopyable.h>
namespace WebCore {
class Node;
-class HTMLParserQuirks : public Noncopyable {
+class HTMLParserQuirks {
+ WTF_MAKE_NONCOPYABLE(HTMLParserQuirks);
public:
HTMLParserQuirks() { }
virtual ~HTMLParserQuirks() { }
#define InputType_h
#include <wtf/Forward.h>
+#include <wtf/FastAllocBase.h>
#include <wtf/Noncopyable.h>
#include <wtf/RefPtr.h>
#include <wtf/Vector.h>
typedef int ExceptionCode;
struct ClickHandlingState {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
bool checked;
bool indeterminate;
RefPtr<HTMLInputElement> checkedRadioButton;
-
- WTF_MAKE_FAST_ALLOCATED
};
// An InputType object represents the type-specific part of an HTMLInputElement.
// Do not expose instances of InputType and classes derived from it to classes
// other than HTMLInputElement.
-class InputType : public Noncopyable {
+class InputType {
+ WTF_MAKE_NONCOPYABLE(InputType); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<InputType> create(HTMLInputElement*, const String&);
static PassOwnPtr<InputType> createText(HTMLInputElement*);
class HTMLInputElement;
-class StepRange : public Noncopyable {
+class StepRange {
+ WTF_MAKE_NONCOPYABLE(StepRange);
public:
bool hasStep;
double step;
class FormAssociatedElement;
class HTMLElement;
-class ValidationMessage : public Noncopyable {
+class ValidationMessage {
+ WTF_MAKE_NONCOPYABLE(ValidationMessage);
public:
static PassOwnPtr<ValidationMessage> create(FormAssociatedElement*);
~ValidationMessage();
namespace WebCore {
-class ValidityState : public Noncopyable {
+class ValidityState {
+ WTF_MAKE_NONCOPYABLE(ValidityState); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<ValidityState> create(FormAssociatedElement* control)
{
class KURL;
class WebGLObject;
-class CanvasRenderingContext : public Noncopyable {
+class CanvasRenderingContext {
+ WTF_MAKE_NONCOPYABLE(CanvasRenderingContext); WTF_MAKE_FAST_ALLOCATED;
public:
CanvasRenderingContext(HTMLCanvasElement*);
virtual ~CanvasRenderingContext() { }
class Document;
class HTMLToken;
-class CSSPreloadScanner : public Noncopyable {
+class CSSPreloadScanner {
+ WTF_MAKE_NONCOPYABLE(CSSPreloadScanner);
public:
CSSPreloadScanner(Document*);
class Document;
class Element;
-class HTMLConstructionSite : public Noncopyable {
+class HTMLConstructionSite {
+ WTF_MAKE_NONCOPYABLE(HTMLConstructionSite);
public:
HTMLConstructionSite(Document*, FragmentScriptingPermission, bool isParsingFragment);
~HTMLConstructionSite();
HTMLFormElement* form() const { return m_form.get(); }
PassRefPtr<HTMLFormElement> takeForm();
- class RedirectToFosterParentGuard : public Noncopyable {
+ class RedirectToFosterParentGuard {
+ WTF_MAKE_NONCOPYABLE(RedirectToFosterParentGuard);
public:
RedirectToFosterParentGuard(HTMLConstructionSite& tree)
: m_tree(tree)
class ScriptSourceCode;
class HTMLDocumentParser : public ScriptableDocumentParser, HTMLScriptRunnerHost, CachedResourceClient {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static PassRefPtr<HTMLDocumentParser> create(HTMLDocument* document, bool reportErrors)
{
// NOTE: The HTML5 spec uses a backwards (grows downward) stack. We're using
// more standard (grows upwards) stack terminology here.
-class HTMLElementStack : public Noncopyable {
+class HTMLElementStack {
+ WTF_MAKE_NONCOPYABLE(HTMLElementStack); WTF_MAKE_FAST_ALLOCATED;
public:
HTMLElementStack();
~HTMLElementStack();
- class ElementRecord : public Noncopyable {
+ class ElementRecord {
+ WTF_MAKE_NONCOPYABLE(ElementRecord);
public:
~ElementRecord(); // Public for ~PassOwnPtr()
class Element;
// This may end up merged into HTMLElementStack.
-class HTMLFormattingElementList : public Noncopyable {
+class HTMLFormattingElementList {
+ WTF_MAKE_NONCOPYABLE(HTMLFormattingElementList);
public:
HTMLFormattingElementList();
~HTMLFormattingElementList();
// m_last is a pointer to the last of the afterInsertionPoint strings.
// The network adds data at the end of the InputStream, which appends
// them to the "last" string.
-class HTMLInputStream : public Noncopyable {
+class HTMLInputStream {
+ WTF_MAKE_NONCOPYABLE(HTMLInputStream);
public:
HTMLInputStream()
: m_last(&m_first)
SegmentedString* m_last;
};
-class InsertionPointRecord : public Noncopyable {
+class InsertionPointRecord {
+ WTF_MAKE_NONCOPYABLE(InsertionPointRecord);
public:
explicit InsertionPointRecord(HTMLInputStream& inputStream)
: m_inputStream(&inputStream)
class HTMLTokenizer;
class TextCodec;
-class HTMLMetaCharsetParser : public Noncopyable {
+class HTMLMetaCharsetParser {
+ WTF_MAKE_NONCOPYABLE(HTMLMetaCharsetParser);
public:
static PassOwnPtr<HTMLMetaCharsetParser> create() { return adoptPtr(new HTMLMetaCharsetParser()); }
#include "Timer.h"
#include <wtf/CurrentTime.h>
-#include <wtf/Noncopyable.h>
#include <wtf/PassOwnPtr.h>
namespace WebCore {
class HTMLDocumentParser;
-class HTMLParserScheduler : public Noncopyable {
+class HTMLParserScheduler {
+ WTF_MAKE_NONCOPYABLE(HTMLParserScheduler); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<HTMLParserScheduler> create(HTMLDocumentParser* parser)
{
#include "CSSPreloadScanner.h"
#include "HTMLToken.h"
#include "SegmentedString.h"
-#include <wtf/Noncopyable.h>
namespace WebCore {
class HTMLTokenizer;
class SegmentedString;
-class HTMLPreloadScanner : public Noncopyable {
+class HTMLPreloadScanner {
+ WTF_MAKE_NONCOPYABLE(HTMLPreloadScanner); WTF_MAKE_FAST_ALLOCATED;
public:
HTMLPreloadScanner(Document*);
#include "PendingScript.h"
#include <wtf/Deque.h>
#include <wtf/text/TextPosition.h>
-#include <wtf/Noncopyable.h>
#include <wtf/PassRefPtr.h>
namespace WebCore {
class HTMLScriptRunnerHost;
class ScriptSourceCode;
-class HTMLScriptRunner : public Noncopyable {
+class HTMLScriptRunner {
+ WTF_MAKE_NONCOPYABLE(HTMLScriptRunner); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<HTMLScriptRunner> create(Document* document, HTMLScriptRunnerHost* host)
{
#define HTMLToken_h
#include "NamedNodeMap.h"
-#include <wtf/Noncopyable.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/Vector.h>
namespace WebCore {
-class HTMLToken : public Noncopyable {
+class HTMLToken {
+ WTF_MAKE_NONCOPYABLE(HTMLToken); WTF_MAKE_FAST_ALLOCATED;
public:
enum Type {
Uninitialized,
// want to end up with a cleaner interface between the two classes.
friend class AtomicHTMLToken;
- class DoctypeData : public Noncopyable {
+ class DoctypeData {
+ WTF_MAKE_NONCOPYABLE(DoctypeData);
public:
DoctypeData()
: m_hasPublicIdentifier(false)
// FIXME: This class should eventually be named HTMLToken once we move the
// exiting HTMLToken to be internal to the HTMLTokenizer.
-class AtomicHTMLToken : public Noncopyable {
+class AtomicHTMLToken {
+ WTF_MAKE_NONCOPYABLE(AtomicHTMLToken);
public:
AtomicHTMLToken(HTMLToken& token)
: m_type(token.type())
class Frame;
class HTMLToken;
-class HTMLTokenizer : public Noncopyable {
+class HTMLTokenizer {
+ WTF_MAKE_NONCOPYABLE(HTMLTokenizer); WTF_MAKE_FAST_ALLOCATED;
public:
enum State {
DataState,
private:
// http://www.whatwg.org/specs/web-apps/current-work/#preprocessing-the-input-stream
- class InputStreamPreprocessor : public Noncopyable {
+ class InputStreamPreprocessor {
+ WTF_MAKE_NONCOPYABLE(InputStreamPreprocessor);
public:
InputStreamPreprocessor(HTMLTokenizer* tokenizer)
: m_tokenizer(tokenizer)
} // namespace
-class HTMLTreeBuilder::ExternalCharacterTokenBuffer : public Noncopyable {
+class HTMLTreeBuilder::ExternalCharacterTokenBuffer {
+ WTF_MAKE_NONCOPYABLE(ExternalCharacterTokenBuffer);
public:
explicit ExternalCharacterTokenBuffer(AtomicHTMLToken& token)
: m_current(token.characters().data())
processEndTag(token);
}
-class HTMLTreeBuilder::FakeInsertionMode : public Noncopyable {
+class HTMLTreeBuilder::FakeInsertionMode {
+ WTF_MAKE_NONCOPYABLE(FakeInsertionMode);
public:
FakeInsertionMode(HTMLTreeBuilder* treeBuilder, InsertionMode mode)
: m_treeBuilder(treeBuilder)
class Node;
class HTMLDocumentParser;
-class HTMLTreeBuilder : public Noncopyable {
+class HTMLTreeBuilder {
+ WTF_MAKE_NONCOPYABLE(HTMLTreeBuilder); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<HTMLTreeBuilder> create(HTMLDocumentParser* parser, HTMLDocument* document, bool reportErrors, bool usePreHTML5ParserQuirks)
{
void processForeignContentUsingInBodyModeAndResetMode(AtomicHTMLToken& token);
void resetForeignInsertionMode();
- class FragmentParsingContext : public Noncopyable {
+ class FragmentParsingContext {
+ WTF_MAKE_NONCOPYABLE(FragmentParsingContext);
public:
FragmentParsingContext();
FragmentParsingContext(DocumentFragment*, Element* contextElement, FragmentScriptingPermission);
namespace WebCore {
-class NestingLevelIncrementer : public Noncopyable {
+class NestingLevelIncrementer {
+ WTF_MAKE_NONCOPYABLE(NestingLevelIncrementer);
public:
explicit NestingLevelIncrementer(unsigned& nestingLevel)
: m_nestingLevel(&nestingLevel)
class ScriptCallStack;
class ScriptValue;
-class ConsoleMessage : public Noncopyable {
+class ConsoleMessage {
+ WTF_MAKE_NONCOPYABLE(ConsoleMessage); WTF_MAKE_FAST_ALLOCATED;
public:
ConsoleMessage(MessageSource, MessageType, MessageLevel, const String& m, unsigned li, const String& u);
ConsoleMessage(MessageSource, MessageType, MessageLevel, const String& m, PassRefPtr<ScriptArguments>, PassRefPtr<ScriptCallStack>);
class InspectorValue;
class ResourceResponse;
-class InspectorApplicationCacheAgent : public Noncopyable {
+class InspectorApplicationCacheAgent {
+ WTF_MAKE_NONCOPYABLE(InspectorApplicationCacheAgent); WTF_MAKE_FAST_ALLOCATED;
public:
InspectorApplicationCacheAgent(InspectorController* inspectorController, InspectorFrontend* frontend);
~InspectorApplicationCacheAgent() { }
class InspectorObject;
class Node;
-class InspectorBrowserDebuggerAgent : public Noncopyable {
+class InspectorBrowserDebuggerAgent {
+ WTF_MAKE_NONCOPYABLE(InspectorBrowserDebuggerAgent);
public:
static PassOwnPtr<InspectorBrowserDebuggerAgent> create(InspectorController* inspectorController)
{
class ScriptCallStack;
class ScriptProfile;
-class InspectorConsoleAgent : public Noncopyable {
+class InspectorConsoleAgent {
+ WTF_MAKE_NONCOPYABLE(InspectorConsoleAgent);
public:
InspectorConsoleAgent(InspectorController*);
~InspectorConsoleAgent();
class WebSocketHandshakeResponse;
#endif
-class InspectorController : public Noncopyable {
+class InspectorController {
+ WTF_MAKE_NONCOPYABLE(InspectorController); WTF_MAKE_FAST_ALLOCATED;
public:
static const char* const ConsolePanel;
static const char* const ElementsPanel;
NativeBreakpointDebuggerEventType
};
-class InspectorDebuggerAgent : public ScriptDebugListener, public Noncopyable {
+class InspectorDebuggerAgent : public ScriptDebugListener {
+ WTF_MAKE_NONCOPYABLE(InspectorDebuggerAgent); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<InspectorDebuggerAgent> create(InspectorController*, InspectorFrontend*);
virtual ~InspectorDebuggerAgent();
class InspectorFrontendHost;
class Page;
-class InspectorFrontendClientLocal : public InspectorFrontendClient, public Noncopyable {
+class InspectorFrontendClientLocal : public InspectorFrontendClient {
+ WTF_MAKE_NONCOPYABLE(InspectorFrontendClientLocal); WTF_MAKE_FAST_ALLOCATED;
public:
InspectorFrontendClientLocal(InspectorController*, Page*);
virtual ~InspectorFrontendClientLocal();
class ScriptHeapSnapshot;
class ScriptProfile;
-class InspectorProfilerAgent : public Noncopyable {
+class InspectorProfilerAgent {
+ WTF_MAKE_NONCOPYABLE(InspectorProfilerAgent); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<InspectorProfilerAgent> create(InspectorController*);
virtual ~InspectorProfilerAgent();
class InspectorObject;
class InspectorValue;
-class InspectorRuntimeAgent : public Noncopyable {
+class InspectorRuntimeAgent {
+ WTF_MAKE_NONCOPYABLE(InspectorRuntimeAgent);
public:
static PassOwnPtr<InspectorRuntimeAgent> create(InjectedScriptHost* injectedScriptHost)
{
ScheduleResourceRequestTimelineRecordType = 20
};
-class InspectorTimelineAgent : ScriptGCEventListener, public Noncopyable {
+class InspectorTimelineAgent : ScriptGCEventListener {
+ WTF_MAKE_NONCOPYABLE(InspectorTimelineAgent); WTF_MAKE_FAST_ALLOCATED;
public:
InspectorTimelineAgent(InspectorFrontend* frontend);
~InspectorTimelineAgent();
class HTTPHeaderMap;
class ResourceResponse;
- class CrossOriginPreflightResultCacheItem : public Noncopyable {
+ class CrossOriginPreflightResultCacheItem {
+ WTF_MAKE_NONCOPYABLE(CrossOriginPreflightResultCacheItem); WTF_MAKE_FAST_ALLOCATED;
public:
CrossOriginPreflightResultCacheItem(bool credentials)
: m_absoluteExpiryTime(0)
HeadersSet m_headers;
};
- class CrossOriginPreflightResultCache : public Noncopyable {
+ class CrossOriginPreflightResultCache {
+ WTF_MAKE_NONCOPYABLE(CrossOriginPreflightResultCache); WTF_MAKE_FAST_ALLOCATED;
public:
static CrossOriginPreflightResultCache& shared();
class ThreadableLoaderClient;
class DocumentThreadableLoader : public RefCounted<DocumentThreadableLoader>, public ThreadableLoader, private SubresourceLoaderClient {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static void loadResourceSynchronously(Document*, const ResourceRequest&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
static PassRefPtr<DocumentThreadableLoader> create(Document*, ThreadableLoaderClient*, const ResourceRequest&, const ThreadableLoaderOptions&);
class SecurityOrigin;
class TextResourceDecoder;
-class DocumentWriter : public Noncopyable {
+class DocumentWriter {
+ WTF_MAKE_NONCOPYABLE(DocumentWriter);
public:
DocumentWriter(Frame*);
#endif
};
-class EmptyFrameLoaderClient : public FrameLoaderClient, public Noncopyable {
+class EmptyFrameLoaderClient : public FrameLoaderClient {
+ WTF_MAKE_NONCOPYABLE(EmptyFrameLoaderClient); WTF_MAKE_FAST_ALLOCATED;
public:
+ EmptyFrameLoaderClient() { }
virtual ~EmptyFrameLoaderClient() { }
virtual void frameLoaderDestroyed() { }
virtual PassRefPtr<FrameNetworkingContext> createNetworkingContext() { return PassRefPtr<FrameNetworkingContext>(); }
};
-class EmptyEditorClient : public EditorClient, public Noncopyable {
+class EmptyEditorClient : public EditorClient {
+ WTF_MAKE_NONCOPYABLE(EmptyEditorClient); WTF_MAKE_FAST_ALLOCATED;
public:
+ EmptyEditorClient() { }
virtual ~EmptyEditorClient() { }
virtual void pageDestroyed() { }
};
#if ENABLE(CONTEXT_MENUS)
-class EmptyContextMenuClient : public ContextMenuClient, public Noncopyable {
+class EmptyContextMenuClient : public ContextMenuClient {
+ WTF_MAKE_NONCOPYABLE(EmptyContextMenuClient); WTF_MAKE_FAST_ALLOCATED;
public:
+ EmptyContextMenuClient() { }
virtual ~EmptyContextMenuClient() { }
virtual void contextMenuDestroyed() { }
#endif // ENABLE(CONTEXT_MENUS)
#if ENABLE(DRAG_SUPPORT)
-class EmptyDragClient : public DragClient, public Noncopyable {
+class EmptyDragClient : public DragClient {
+ WTF_MAKE_NONCOPYABLE(EmptyDragClient); WTF_MAKE_FAST_ALLOCATED;
public:
+ EmptyDragClient() { }
virtual ~EmptyDragClient() {}
virtual void willPerformDragDestinationAction(DragDestinationAction, DragData*) { }
virtual void willPerformDragSourceAction(DragSourceAction, const IntPoint&, Clipboard*) { }
};
#endif // ENABLE(DRAG_SUPPORT)
-class EmptyInspectorClient : public InspectorClient, public Noncopyable {
+class EmptyInspectorClient : public InspectorClient {
+ WTF_MAKE_NONCOPYABLE(EmptyInspectorClient); WTF_MAKE_FAST_ALLOCATED;
public:
+ EmptyInspectorClient() { }
virtual ~EmptyInspectorClient() { }
virtual void inspectorDestroyed() { }
public:
enum Method { GetMethod, PostMethod };
- class Attributes : public Noncopyable {
+ class Attributes {
+ WTF_MAKE_NONCOPYABLE(Attributes);
public:
Attributes()
: m_method(GetMethod)
bool isBackForwardLoadType(FrameLoadType);
-class FrameLoader : public Noncopyable {
+class FrameLoader {
+ WTF_MAKE_NONCOPYABLE(FrameLoader);
public:
FrameLoader(Frame*, FrameLoaderClient*);
~FrameLoader();
// Encapsulates a state machine for FrameLoader. Note that this is different from FrameState,
// which stores the state of the current load that FrameLoader is executing.
-class FrameLoaderStateMachine : public Noncopyable {
+class FrameLoaderStateMachine {
+ WTF_MAKE_NONCOPYABLE(FrameLoaderStateMachine);
public:
FrameLoaderStateMachine();
class HistoryItem;
class SerializedScriptValue;
-class HistoryController : public Noncopyable {
+class HistoryController {
+ WTF_MAKE_NONCOPYABLE(HistoryController);
public:
enum HistoryUpdateType { UpdateAll, UpdateAllExceptBackForwardList };
namespace WebCore {
-class ImageEventSender : public Noncopyable {
+class ImageEventSender {
+ WTF_MAKE_NONCOPYABLE(ImageEventSender); WTF_MAKE_FAST_ALLOCATED;
public:
ImageEventSender(const AtomicString& eventType);
unsigned NavigationDisablerForBeforeUnload::s_navigationDisableCount = 0;
-class ScheduledNavigation : public Noncopyable {
+class ScheduledNavigation {
+ WTF_MAKE_NONCOPYABLE(ScheduledNavigation); WTF_MAKE_FAST_ALLOCATED;
public:
ScheduledNavigation(double delay, bool lockHistory, bool lockBackForwardList, bool wasDuringLoad, bool isLocationChange)
: m_delay(delay)
// to allow the load to live long enough to ensure the message was actually sent.
// Therefore, as soon as a callback is received from the ResourceHandle, this class
// will cancel the load and delete itself.
-class PingLoader : private ResourceHandleClient, public Noncopyable {
+class PingLoader : private ResourceHandleClient {
+ WTF_MAKE_NONCOPYABLE(PingLoader); WTF_MAKE_FAST_ALLOCATED;
public:
static void loadImage(Frame*, const KURL& url);
static void sendPing(Frame*, const KURL& pingURL, const KURL& destinationURL);
class ResourceError;
class ResourceResponse;
-class PolicyChecker : public Noncopyable {
+class PolicyChecker {
+ WTF_MAKE_NONCOPYABLE(PolicyChecker);
public:
PolicyChecker(Frame*);
static const int progressItemDefaultEstimatedLength = 1024 * 16;
-struct ProgressItem : Noncopyable {
+struct ProgressItem {
+ WTF_MAKE_NONCOPYABLE(ProgressItem); WTF_MAKE_FAST_ALLOCATED;
+public:
ProgressItem(long long length)
: bytesReceived(0)
, estimatedLength(length) { }
class ResourceResponse;
struct ProgressItem;
-class ProgressTracker : public Noncopyable {
+class ProgressTracker {
+ WTF_MAKE_NONCOPYABLE(ProgressTracker); WTF_MAKE_FAST_ALLOCATED;
public:
ProgressTracker();
~ProgressTracker();
class ResourceResponse;
class ResourceRequest;
-class ResourceLoadNotifier : public Noncopyable {
+class ResourceLoadNotifier {
+ WTF_MAKE_NONCOPYABLE(ResourceLoadNotifier);
public:
ResourceLoadNotifier(Frame*);
class SubresourceLoader;
class SubresourceLoaderClient;
-class ResourceLoadScheduler : public Noncopyable {
+class ResourceLoadScheduler {
+ WTF_MAKE_NONCOPYABLE(ResourceLoadScheduler);
public:
friend ResourceLoadScheduler* resourceLoadScheduler();
void scheduleServePendingRequests();
void requestTimerFired(Timer<ResourceLoadScheduler>*);
- class HostInformation : public Noncopyable {
+ class HostInformation {
+ WTF_MAKE_NONCOPYABLE(HostInformation);
public:
HostInformation(const String&, unsigned);
~HostInformation();
class Widget;
// This is a slight misnomer. It handles the higher level logic of loading both subframes and plugins.
-class SubframeLoader : public Noncopyable {
+class SubframeLoader {
+ WTF_MAKE_NONCOPYABLE(SubframeLoader);
public:
SubframeLoader(Frame*);
// Useful for doing loader operations from any thread (not threadsafe,
// just able to run on threads other than the main thread).
- class ThreadableLoader : public Noncopyable {
+ class ThreadableLoader {
+ WTF_MAKE_NONCOPYABLE(ThreadableLoader);
public:
static void loadResourceSynchronously(ScriptExecutionContext*, const ResourceRequest&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
static PassRefPtr<ThreadableLoader> create(ScriptExecutionContext*, ThreadableLoaderClient*, const ResourceRequest&, const ThreadableLoaderOptions&);
void deref() { derefThreadableLoader(); }
protected:
+ ThreadableLoader() { }
virtual ~ThreadableLoader() { }
virtual void refThreadableLoader() = 0;
virtual void derefThreadableLoader() = 0;
#ifndef ThreadableLoaderClient_h
#define ThreadableLoaderClient_h
-#include <wtf/Noncopyable.h>
namespace WebCore {
class ResourceError;
class ResourceResponse;
- class ThreadableLoaderClient : public Noncopyable {
+ class ThreadableLoaderClient {
+ WTF_MAKE_NONCOPYABLE(ThreadableLoaderClient); WTF_MAKE_FAST_ALLOCATED;
public:
virtual void didSendData(unsigned long long /*bytesSent*/, unsigned long long /*totalBytesToBeSent*/) { }
virtual void didReceiveAuthenticationCancellation(const ResourceResponse&) { }
protected:
+ ThreadableLoaderClient() { }
virtual ~ThreadableLoaderClient() { }
};
struct CrossThreadResourceRequestData;
class WorkerThreadableLoader : public RefCounted<WorkerThreadableLoader>, public ThreadableLoader {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static void loadResourceSynchronously(WorkerContext*, const ResourceRequest&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
static PassRefPtr<WorkerThreadableLoader> create(WorkerContext* workerContext, ThreadableLoaderClient* client, const String& taskMode, const ResourceRequest& request, const ThreadableLoaderOptions& options)
ApplicationCacheUpdateWithoutBrowsingContext
};
-class ApplicationCacheGroup : public Noncopyable, ResourceHandleClient {
+class ApplicationCacheGroup : ResourceHandleClient {
+ WTF_MAKE_NONCOPYABLE(ApplicationCacheGroup); WTF_MAKE_FAST_ALLOCATED;
public:
ApplicationCacheGroup(const KURL& manifestURL, bool isCopy = false);
~ApplicationCacheGroup();
class ApplicationCacheStorage;
#endif
- class ApplicationCacheHost : public Noncopyable {
+ class ApplicationCacheHost {
+ WTF_MAKE_NONCOPYABLE(ApplicationCacheHost); WTF_MAKE_FAST_ALLOCATED;
public:
// The Status numeric values are specified in the HTML5 spec.
enum Status {
class StorageIDJournal;
class SecurityOrigin;
-class ApplicationCacheStorage : public Noncopyable {
+class ApplicationCacheStorage {
+ WTF_MAKE_NONCOPYABLE(ApplicationCacheStorage); WTF_MAKE_FAST_ALLOCATED;
public:
enum FailureReason {
OriginQuotaReached,
namespace WebCore {
-class ArchiveResourceCollection : public Noncopyable {
+class ArchiveResourceCollection {
+ WTF_MAKE_NONCOPYABLE(ArchiveResourceCollection); WTF_MAKE_FAST_ALLOCATED;
public:
ArchiveResourceCollection();
// A resource that is held in the cache. Classes who want to use this object should derive
// from CachedResourceClient, to get the function calls in case the requested data has arrived.
// This class also does the actual communication with the loader to obtain the resource from the network.
-class CachedResource : public Noncopyable {
+class CachedResource {
+ WTF_MAKE_NONCOPYABLE(CachedResource); WTF_MAKE_FAST_ALLOCATED;
friend class MemoryCache;
friend class InspectorResource;
* inherit from this class and overload one of the 3 functions
*
*/
- class CachedResourceClient : public FastAllocBase
- {
+ class CachedResourceClient {
+ WTF_MAKE_FAST_ALLOCATED;
public:
virtual ~CachedResourceClient() { }
class KURL;
// The CachedResourceLoader manages the loading of scripts/images/stylesheets for a single document.
-class CachedResourceLoader : public Noncopyable {
+class CachedResourceLoader {
+ WTF_MAKE_NONCOPYABLE(CachedResourceLoader); WTF_MAKE_FAST_ALLOCATED;
friend class ImageLoader;
public:
// its member variables) are allocated in non-purgeable TC-malloc'd memory so we would see slightly
// more memory use due to this.
-class MemoryCache : public Noncopyable {
+class MemoryCache {
+ WTF_MAKE_NONCOPYABLE(MemoryCache); WTF_MAKE_FAST_ALLOCATED;
public:
friend MemoryCache* memoryCache();
IconLoadUnknown
};
-class IconDatabase : public Noncopyable {
-
+class IconDatabase {
+ WTF_MAKE_NONCOPYABLE(IconDatabase); WTF_MAKE_FAST_ALLOCATED;
// *** Main Thread Only ***
public:
void setClient(IconDatabaseClient*);
#ifndef IconDatabaseClient_h
#define IconDatabaseClient_h
+#include <wtf/FastAllocBase.h>
#include <wtf/Forward.h>
#include <wtf/Noncopyable.h>
namespace WebCore {
-class IconDatabaseClient : public Noncopyable {
+class IconDatabaseClient {
+ WTF_MAKE_NONCOPYABLE(IconDatabaseClient); WTF_MAKE_FAST_ALLOCATED;
public:
+ IconDatabaseClient() { }
virtual ~IconDatabaseClient() { }
virtual bool performImport() { return true; }
virtual void dispatchDidRemoveAllIcons() { }
class KURL;
class SharedBuffer;
-class IconLoader : private SubresourceLoaderClient, public Noncopyable {
+class IconLoader : private SubresourceLoaderClient {
+ WTF_MAKE_NONCOPYABLE(IconLoader); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<IconLoader> create(Frame*);
~IconLoader();
String iconURL;
};
-class PageURLRecord : public Noncopyable {
+class PageURLRecord {
+ WTF_MAKE_NONCOPYABLE(PageURLRecord); WTF_MAKE_FAST_ALLOCATED;
public:
PageURLRecord(const String& pageURL);
~PageURLRecord();
class WorkerContext;
class Notification : public RefCounted<Notification>, public ActiveDOMObject, public ThreadableLoaderClient, public EventTarget {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static PassRefPtr<Notification> create(const KURL& url, ScriptExecutionContext* context, ExceptionCode& ec, PassRefPtr<NotificationCenter> provider);
static PassRefPtr<Notification> create(const NotificationContents& contents, ScriptExecutionContext* context, ExceptionCode& ec, PassRefPtr<NotificationCenter> provider);
class Event;
class Page;
- class ContextMenuController : public Noncopyable {
+ class ContextMenuController {
+ WTF_MAKE_NONCOPYABLE(ContextMenuController); WTF_MAKE_FAST_ALLOCATED;
public:
ContextMenuController(Page*, ContextMenuClient*);
~ContextMenuController();
class Range;
class SelectionController;
- class DragController : public Noncopyable {
+ class DragController {
+ WTF_MAKE_NONCOPYABLE(DragController); WTF_MAKE_FAST_ALLOCATED;
public:
DragController(Page*, DragClient*);
~DragController();
enum HitTestScrollbars { ShouldHitTestScrollbars, DontHitTestScrollbars };
-class EventHandler : public Noncopyable {
+class EventHandler {
+ WTF_MAKE_NONCOPYABLE(EventHandler);
public:
EventHandler(Frame*);
~EventHandler();
PerformDragAndDrop
};
- struct EventHandlerDragState : Noncopyable {
+ struct EventHandlerDragState {
+ WTF_MAKE_NONCOPYABLE(EventHandlerDragState); WTF_MAKE_FAST_ALLOCATED;
+ public:
+ EventHandlerDragState() { }
RefPtr<Node> m_dragSrc; // element that may be a drag source, for the current mouse gesture
bool m_dragSrcIsLink;
bool m_dragSrcIsImage;
class ThreadableLoader;
class EventSource : public RefCounted<EventSource>, public EventTarget, private ThreadableLoaderClient, public ActiveDOMObject {
+ WTF_MAKE_FAST_ALLOCATED;
public:
static PassRefPtr<EventSource> create(const String& url, ScriptExecutionContext*, ExceptionCode&);
virtual ~EventSource();
class Node;
class Page;
-class FocusController : public Noncopyable {
+class FocusController {
+ WTF_MAKE_NONCOPYABLE(FocusController); WTF_MAKE_FAST_ALLOCATED;
public:
FocusController(Page*);
class Frame;
- class FrameTree : public Noncopyable {
+ class FrameTree {
+ WTF_MAKE_NONCOPYABLE(FrameTree);
public:
FrameTree(Frame* thisFrame, Frame* parentFrame)
: m_thisFrame(thisFrame)
// The maximum number of updateWidgets iterations that should be done before returning.
static const unsigned maxUpdateWidgetsIterations = 2;
-struct ScheduledEvent : Noncopyable {
+struct ScheduledEvent {
+ WTF_MAKE_NONCOPYABLE(ScheduledEvent); WTF_MAKE_FAST_ALLOCATED;
+public:
+ ScheduledEvent() { }
RefPtr<Event> m_event;
RefPtr<Node> m_eventTarget;
};
class GeolocationPosition;
class Page;
-class GeolocationController : public Noncopyable {
+class GeolocationController {
+ WTF_MAKE_NONCOPYABLE(GeolocationController);
public:
GeolocationController(Page*, GeolocationClient*);
~GeolocationController();
class PageGroup;
-class GroupSettings : public Noncopyable {
+class GroupSettings {
+ WTF_MAKE_NONCOPYABLE(GroupSettings); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<GroupSettings> create()
{
enum FindDirection { FindDirectionForward, FindDirectionBackward };
- class Page : public Noncopyable {
+ class Page {
+ WTF_MAKE_NONCOPYABLE(Page);
public:
static void scheduleForcedStyleRecalcForAllPages();
// It is up to the platform to ensure that non-null clients are provided where required.
- struct PageClients : Noncopyable {
+ struct PageClients {
+ WTF_MAKE_NONCOPYABLE(PageClients); WTF_MAKE_FAST_ALLOCATED;
+ public:
PageClients();
~PageClients();
class Page;
class StorageNamespace;
- class PageGroup : public Noncopyable {
+ class PageGroup {
+ WTF_MAKE_NONCOPYABLE(PageGroup); WTF_MAKE_FAST_ALLOCATED;
public:
PageGroup(const String& name);
PageGroup(Page*);
class Frame;
class Page;
- class PageGroupLoadDeferrer : public Noncopyable {
+ class PageGroupLoadDeferrer {
+ WTF_MAKE_NONCOPYABLE(PageGroupLoadDeferrer);
public:
PageGroupLoadDeferrer(Page*, bool deferSelf);
~PageGroupLoadDeferrer();
class HaltablePlugin;
-class PluginHalter : public Noncopyable {
+class PluginHalter {
+ WTF_MAKE_NONCOPYABLE(PluginHalter); WTF_MAKE_FAST_ALLOCATED;
public:
PluginHalter(PluginHalterClient*);
TextDirectionSubmenuAlwaysIncluded
};
- class Settings : public Noncopyable {
+ class Settings {
+ WTF_MAKE_NONCOPYABLE(Settings); WTF_MAKE_FAST_ALLOCATED;
public:
Settings(Page*);
#include "SpeechInputListener.h"
#include <wtf/Forward.h>
#include <wtf/HashMap.h>
-#include <wtf/Noncopyable.h>
namespace WebCore {
// This class connects the input elements requiring speech input with the platform specific
// speech recognition engine. It provides methods for the input elements to activate speech
// recognition and methods for the speech recognition engine to return back the results.
-class SpeechInput : public Noncopyable, public SpeechInputListener {
+class SpeechInput : public SpeechInputListener {
+ WTF_MAKE_NONCOPYABLE(SpeechInput);
public:
SpeechInput(SpeechInputClient*);
virtual ~SpeechInput();
namespace WebCore {
-class UserScript : public Noncopyable {
+class UserScript {
+ WTF_MAKE_NONCOPYABLE(UserScript); WTF_MAKE_FAST_ALLOCATED;
public:
UserScript(const String& source, const KURL& url,
PassOwnPtr<Vector<String> > whitelist, PassOwnPtr<Vector<String> > blacklist,
namespace WebCore {
-class UserStyleSheet : public Noncopyable {
+class UserStyleSheet {
+ WTF_MAKE_NONCOPYABLE(UserStyleSheet); WTF_MAKE_FAST_ALLOCATED;
public:
UserStyleSheet(const String& source, const KURL& url,
PassOwnPtr<Vector<String> > whitelist, PassOwnPtr<Vector<String> > blacklist,
// * HTMLDocumentParser::shouldLoadExternalScriptFromSrc - used to load external JavaScript scripts.
// * SubframeLoader::requestObject - used to load <object>/<embed> elements.
//
- class XSSAuditor : public Noncopyable {
+ class XSSAuditor {
+ WTF_MAKE_NONCOPYABLE(XSSAuditor); WTF_MAKE_FAST_ALLOCATED;
public:
XSSAuditor(Frame*);
~XSSAuditor();
static void addShorthandProperties();
static PropertyWrapperBase* wrapperForProperty(int propertyID);
-class PropertyWrapperBase : public Noncopyable {
+class PropertyWrapperBase {
+ WTF_MAKE_NONCOPYABLE(PropertyWrapperBase); WTF_MAKE_FAST_ALLOCATED;
public:
PropertyWrapperBase(int prop)
: m_prop(prop)
};
template <typename T>
-class FillLayerPropertyWrapperGetter : public FillLayerPropertyWrapperBase, public Noncopyable {
+class FillLayerPropertyWrapperGetter : public FillLayerPropertyWrapperBase {
+ WTF_MAKE_NONCOPYABLE(FillLayerPropertyWrapperGetter);
public:
FillLayerPropertyWrapperGetter(T (FillLayer::*getter)() const)
: m_getter(getter)
class RenderObject;
class RenderStyle;
-class AnimationControllerPrivate : public Noncopyable {
+class AnimationControllerPrivate {
+ WTF_MAKE_NONCOPYABLE(AnimationControllerPrivate); WTF_MAKE_FAST_ALLOCATED;
public:
AnimationControllerPrivate(Frame*);
~AnimationControllerPrivate();
return currentNSEventSlot().get();
}
-class CurrentEventScope : public Noncopyable {
+class CurrentEventScope {
+ WTF_MAKE_NONCOPYABLE(CurrentEventScope);
public:
CurrentEventScope(NSEvent *);
~CurrentEventScope();
class AsyncFileWriterClient;
// This class provides async interface for platform-specific file system implementation. Note that all the methods take platform paths.
-class AsyncFileSystem : public Noncopyable {
+class AsyncFileSystem {
+ WTF_MAKE_NONCOPYABLE(AsyncFileSystem);
public:
virtual ~AsyncFileSystem() { }
class AsyncFileWriter;
struct FileMetadata;
-class AsyncFileSystemCallbacks : public Noncopyable {
+class AsyncFileSystemCallbacks {
+ WTF_MAKE_NONCOPYABLE(AsyncFileSystemCallbacks);
public:
+ AsyncFileSystemCallbacks() { }
+
// Called when a requested operation is completed successfully.
virtual void didSucceed() = 0;
namespace WebCore {
-class AutodrainedPool : public Noncopyable {
+class AutodrainedPool {
+ WTF_MAKE_NONCOPYABLE(AutodrainedPool);
public:
AutodrainedPool(int iterationLimit = 1);
~AutodrainedPool();
class ContextMenuController;
- class ContextMenu : public Noncopyable
- {
+ class ContextMenu {
+ WTF_MAKE_NONCOPYABLE(ContextMenu); WTF_MAKE_FAST_ALLOCATED;
public:
ContextMenu();
typedef void* PlatformMenuItemDescription;
#endif
- class ContextMenuItem : public FastAllocBase {
+ class ContextMenuItem {
+ WTF_MAKE_FAST_ALLOCATED;
public:
ContextMenuItem(ContextMenuItemType, ContextMenuAction, const String&, ContextMenu* subMenu = 0);
ContextMenuItem(ContextMenuItemType, ContextMenuAction, const String&, bool enabled, bool checked);
template <class T> class DeprecatedPtrListIterator;
-template <class T> class DeprecatedPtrList : public FastAllocBase {
+template <class T> class DeprecatedPtrList {
+ WTF_MAKE_FAST_ALLOCATED;
public:
DeprecatedPtrList() : impl(deleteFunc), del_item(false) { }
~DeprecatedPtrList() { impl.clear(del_item); }
#include <cstddef>
#include <algorithm>
#include <wtf/Assertions.h>
+#include <wtf/FastAllocBase.h>
#include <wtf/Noncopyable.h>
namespace WebCore {
-class DeprecatedListNode : public Noncopyable
-{
+class DeprecatedListNode {
+ WTF_MAKE_NONCOPYABLE(DeprecatedListNode); WTF_MAKE_FAST_ALLOCATED;
public:
DeprecatedListNode(void *d) : data(d), next(0), prev(0) { }
namespace WebCore {
- class EventLoop : public Noncopyable {
+ class EventLoop {
+ WTF_MAKE_NONCOPYABLE(EventLoop);
public:
EventLoop()
: m_ended(false)
virtual void geolocationServiceErrorOccurred(GeolocationService*) = 0;
};
-class GeolocationService : public Noncopyable {
+class GeolocationService {
+ WTF_MAKE_NONCOPYABLE(GeolocationService);
public:
static GeolocationService* create(GeolocationServiceClient*);
virtual ~GeolocationService() { }
#ifndef HostWindow_h
#define HostWindow_h
-#include <wtf/Noncopyable.h>
#include "Widget.h"
namespace WebCore {
class Cursor;
-class HostWindow : public Noncopyable {
+class HostWindow {
+ WTF_MAKE_NONCOPYABLE(HostWindow); WTF_MAKE_FAST_ALLOCATED;
public:
+ HostWindow() { }
virtual ~HostWindow() { }
// Requests the host invalidate the window, not the contents. If immediate is true do so synchronously, otherwise async.
namespace WebCore {
class KillRing {
+ WTF_MAKE_FAST_ALLOCATED;
public:
void append(const String&);
void prepend(const String&);
enum LengthType { Auto, Relative, Percent, Fixed, Static, Intrinsic, MinIntrinsic };
-struct Length : FastAllocBase {
+struct Length {
+ WTF_MAKE_FAST_ALLOCATED;
+public:
Length()
: m_value(0)
{
class Range;
class ArchiveResource;
-class Pasteboard : public Noncopyable {
+class Pasteboard {
+ WTF_MAKE_NONCOPYABLE(Pasteboard); WTF_MAKE_FAST_ALLOCATED;
public:
#if PLATFORM(MAC)
//Helper functions to allow Clipboard to share code
namespace WebCore {
- class PlatformKeyboardEvent : public FastAllocBase {
+ class PlatformKeyboardEvent {
+ WTF_MAKE_FAST_ALLOCATED;
public:
enum Type {
// KeyDown is sent by platforms such as Mac OS X, gtk and Qt, and has information about both physical pressed key, and its translation.
#define PurgeableBuffer_h
#include "PurgePriority.h"
-#include <wtf/Noncopyable.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/Vector.h>
namespace WebCore {
- class PurgeableBuffer : public Noncopyable {
+ class PurgeableBuffer {
+ WTF_MAKE_NONCOPYABLE(PurgeableBuffer);
public:
static PassOwnPtr<PurgeableBuffer> create(const char* data, size_t);
#define RunLoopTimer_h
#include "SchedulePair.h"
-#include <wtf/Noncopyable.h>
#include <wtf/RetainPtr.h>
namespace WebCore {
// Time intervals are all in seconds.
-class RunLoopTimerBase : public Noncopyable {
+class RunLoopTimerBase {
+ WTF_MAKE_NONCOPYABLE(RunLoopTimerBase);
public:
+ RunLoopTimerBase() { }
virtual ~RunLoopTimerBase();
void schedule(const SchedulePair*);
class Scrollbar;
class ScrollView;
-class ScrollbarTheme : public Noncopyable {
+class ScrollbarTheme {
+ WTF_MAKE_NONCOPYABLE(ScrollbarTheme); WTF_MAKE_FAST_ALLOCATED;
public:
+ ScrollbarTheme() { }
virtual ~ScrollbarTheme() {};
virtual bool paint(Scrollbar*, GraphicsContext*, const IntRect& /*damageRect*/) { return false; }
#ifndef SharedTimer_h
#define SharedTimer_h
+#include <wtf/FastAllocBase.h>
#include <wtf/Noncopyable.h>
namespace WebCore {
// Each thread has its own single instance of shared timer, which implements this interface.
// This instance is shared by all timers in the thread.
// Not intended to be used directly; use the Timer class instead.
- class SharedTimer : public Noncopyable {
+ class SharedTimer {
+ WTF_MAKE_NONCOPYABLE(SharedTimer); WTF_MAKE_FAST_ALLOCATED;
public:
+ SharedTimer() { }
virtual ~SharedTimer() {}
virtual void setFiredFunction(void (*)()) = 0;
struct TECConverterWrapper;
class ThreadTimers;
- class ThreadGlobalData : public Noncopyable {
+ class ThreadGlobalData {
+ WTF_MAKE_NONCOPYABLE(ThreadGlobalData);
public:
ThreadGlobalData();
~ThreadGlobalData();
git://git.webkit.org / WebKit-https.git / commitdiff