Diff
Modified: trunk/Source/WTF/ChangeLog (138451 => 138452)
--- trunk/Source/WTF/ChangeLog 2012-12-25 06:16:43 UTC (rev 138451)
+++ trunk/Source/WTF/ChangeLog 2012-12-25 07:01:51 UTC (rev 138452)
@@ -1,3 +1,27 @@
+2012-12-24 Ilya Tikhonovsky <[email protected]>
+
+ Web Inspector: Native Memory Instrumentation: propagate member type as edge type to the serialized heap graph.
+ https://bugs.webkit.org/show_bug.cgi?id=105725
+
+ Reviewed by Yury Semikhatsky.
+
+ MemoryOwningType was renamed to MemberType.
+ Source argument were removed from reportEdge, reportLeaf and other edge related methods because it is not necessary.
+ MemberType argument was propagated from MemoryInstrumentation down to HeapGraphSerializer.
+
+ The changes covered by tests in TestWebKitAPI.
+
+ * wtf/MemoryInstrumentation.cpp:
+ (WTF::MemoryInstrumentation::reportEdge):
+ (WTF::MemoryInstrumentation::reportLinkToBuffer):
+ (WTF::MemoryClassInfo::addPrivateBuffer):
+ * wtf/MemoryInstrumentation.h:
+ (MemoryInstrumentationClient):
+ (MemoryInstrumentation):
+ (WTF::MemoryInstrumentation::addRawBuffer):
+ (WTF::MemoryInstrumentation::MemberTypeTraits::addObject):
+ (WTF::MemoryInstrumentation::addObjectImpl):
+
2012-12-21 Ilya Tikhonovsky <[email protected]>
Unreviewed. Another try to fix Apple Win Release build.
Modified: trunk/Source/WTF/wtf/MemoryInstrumentation.cpp (138451 => 138452)
--- trunk/Source/WTF/wtf/MemoryInstrumentation.cpp 2012-12-25 06:16:43 UTC (rev 138451)
+++ trunk/Source/WTF/wtf/MemoryInstrumentation.cpp 2012-12-25 07:01:51 UTC (rev 138452)
@@ -49,9 +49,9 @@
{
}
-void MemoryInstrumentation::reportEdge(MemoryObjectInfo* ownerObjectInfo, const void* target, const char* name)
+void MemoryInstrumentation::reportEdge(const void* target, const char* name, MemberType memberType)
{
- m_client->reportEdge(ownerObjectInfo->reportedPointer(), target, name);
+ m_client->reportEdge(target, name, memberType);
}
MemoryObjectType MemoryInstrumentation::getObjectType(MemoryObjectInfo* objectInfo)
@@ -64,12 +64,12 @@
memoryObjectInfo->reportObjectInfo(pointer, objectType, objectSize);
}
-void MemoryInstrumentation::reportLinkToBuffer(const void* owner, const void* buffer, MemoryObjectType ownerObjectType, size_t size, const char* nodeName, const char* edgeName)
+void MemoryInstrumentation::reportLinkToBuffer(const void* buffer, MemoryObjectType ownerObjectType, size_t size, const char* nodeName, const char* edgeName)
{
MemoryObjectInfo memoryObjectInfo(this, ownerObjectType, 0);
memoryObjectInfo.reportObjectInfo(buffer, ownerObjectType, size);
memoryObjectInfo.setName(nodeName);
- m_client->reportLeaf(owner, memoryObjectInfo, edgeName);
+ m_client->reportLeaf(memoryObjectInfo, edgeName);
}
MemoryInstrumentation::WrapperBase::WrapperBase(MemoryObjectType objectType, const void* pointer)
@@ -124,7 +124,7 @@
void MemoryClassInfo::addRawBuffer(const void* buffer, size_t size, const char* nodeName, const char* edgeName)
{
if (!m_skipMembers)
- m_memoryInstrumentation->addRawBuffer(m_memoryObjectInfo->reportedPointer(), buffer, m_objectType, size, nodeName, edgeName);
+ m_memoryInstrumentation->addRawBuffer(buffer, m_objectType, size, nodeName, edgeName);
}
void MemoryClassInfo::addPrivateBuffer(size_t size, MemoryObjectType ownerObjectType, const char* nodeName, const char* edgeName)
@@ -136,7 +136,7 @@
if (!ownerObjectType)
ownerObjectType = m_objectType;
m_memoryInstrumentation->countObjectSize(0, ownerObjectType, size);
- m_memoryInstrumentation->reportLinkToBuffer(m_memoryObjectInfo->reportedPointer(), 0, ownerObjectType, size, nodeName, edgeName);
+ m_memoryInstrumentation->reportLinkToBuffer(0, ownerObjectType, size, nodeName, edgeName);
}
void MemoryClassInfo::setCustomAllocation(bool customAllocation)
Modified: trunk/Source/WTF/wtf/MemoryInstrumentation.h (138451 => 138452)
--- trunk/Source/WTF/wtf/MemoryInstrumentation.h 2012-12-25 06:16:43 UTC (rev 138451)
+++ trunk/Source/WTF/wtf/MemoryInstrumentation.h 2012-12-25 07:01:51 UTC (rev 138452)
@@ -45,9 +45,12 @@
typedef const char* MemoryObjectType;
-enum MemoryOwningType {
- byPointer,
- byReference
+enum MemberType {
+ PointerMember,
+ ReferenceMember,
+ OwnPtrMember,
+ RefPtrMember,
+ LastMemberTypeEntry
};
template<typename T> void reportMemoryUsage(const T*, MemoryObjectInfo*);
@@ -60,8 +63,8 @@
virtual bool checkCountedObject(const void*) = 0;
virtual void reportNode(const MemoryObjectInfo&) = 0;
- virtual void reportEdge(const void* source, const void* target, const char* edgeName) = 0;
- virtual void reportLeaf(const void* source, const MemoryObjectInfo&, const char* edgeName) = 0;
+ virtual void reportEdge(const void* target, const char* edgeName, MemberType) = 0;
+ virtual void reportLeaf(const MemoryObjectInfo&, const char* edgeName) = 0;
virtual void reportBaseAddress(const void* base, const void* real) = 0;
};
@@ -72,7 +75,7 @@
template <typename T> void addRootObject(const T& t, MemoryObjectType objectType = 0)
{
- OwningTraits<T>::addRootObject(this, t, objectType);
+ MemberTypeTraits<T>::addRootObject(this, t, objectType);
processDeferredObjects();
}
@@ -105,7 +108,7 @@
bool visited(const void* pointer) { return m_client->visited(pointer); }
bool checkCountedObject(const void* pointer) { return m_client->checkCountedObject(pointer); }
- WTF_EXPORT_PRIVATE void reportEdge(MemoryObjectInfo* ownerObjectInfo, const void* target, const char* edgeName);
+ WTF_EXPORT_PRIVATE void reportEdge(const void* target, const char* edgeName, MemberType);
virtual void deferObject(PassOwnPtr<WrapperBase>) = 0;
virtual void processDeferredObjects() = 0;
@@ -164,21 +167,21 @@
virtual void callReportMemoryUsage(MemoryObjectInfo*) OVERRIDE;
};
- template<typename T> void addObject(const T& t, MemoryObjectInfo* ownerObjectInfo, const char* edgeName) { OwningTraits<T>::addObject(this, t, ownerObjectInfo, edgeName); }
- void addRawBuffer(const void* owner, const void* buffer, MemoryObjectType ownerObjectType, size_t size, const char* nodeName = 0, const char* edgeName = 0)
+ template<typename T> void addObject(const T& t, MemoryObjectInfo* ownerObjectInfo, const char* edgeName) { MemberTypeTraits<T>::addObject(this, t, ownerObjectInfo, edgeName); }
+ void addRawBuffer(const void* buffer, MemoryObjectType ownerObjectType, size_t size, const char* nodeName = 0, const char* edgeName = 0)
{
if (!buffer || visited(buffer))
return;
countObjectSize(buffer, ownerObjectType, size);
- reportLinkToBuffer(owner, buffer, ownerObjectType, size, nodeName, edgeName);
+ reportLinkToBuffer(buffer, ownerObjectType, size, nodeName, edgeName);
}
- WTF_EXPORT_PRIVATE void reportLinkToBuffer(const void* owner, const void* buffer, MemoryObjectType ownerObjectType, size_t, const char* nodeName, const char* edgeName);
+ WTF_EXPORT_PRIVATE void reportLinkToBuffer(const void* buffer, MemoryObjectType ownerObjectType, size_t, const char* nodeName, const char* edgeName);
template<typename T>
- struct OwningTraits { // Default byReference implementation.
+ struct MemberTypeTraits { // Default ReferenceMember implementation.
static void addObject(MemoryInstrumentation* instrumentation, const T& t, MemoryObjectInfo* ownerObjectInfo, const char* edgeName)
{
- instrumentation->addObjectImpl(&t, ownerObjectInfo, byReference, edgeName);
+ instrumentation->addObjectImpl(&t, ownerObjectInfo, ReferenceMember, edgeName);
}
static void addRootObject(MemoryInstrumentation* instrumentation, const T& t, MemoryObjectType objectType)
@@ -188,10 +191,10 @@
};
template<typename T>
- struct OwningTraits<T*> { // Custom byPointer implementation.
+ struct MemberTypeTraits<T*> { // Custom PointerMember implementation.
static void addObject(MemoryInstrumentation* instrumentation, const T* const& t, MemoryObjectInfo* ownerObjectInfo, const char* edgeName)
{
- instrumentation->addObjectImpl(t, ownerObjectInfo, byPointer, edgeName);
+ instrumentation->addObjectImpl(t, ownerObjectInfo, PointerMember, edgeName);
}
static void addRootObject(MemoryInstrumentation* instrumentation, const T* const& t, MemoryObjectType objectType)
@@ -201,9 +204,9 @@
}
};
- template<typename T> void addObjectImpl(const T*, MemoryObjectInfo*, MemoryOwningType, const char* edgeName);
- template<typename T> void addObjectImpl(const OwnPtr<T>*, MemoryObjectInfo*, MemoryOwningType, const char* edgeName);
- template<typename T> void addObjectImpl(const RefPtr<T>*, MemoryObjectInfo*, MemoryOwningType, const char* edgeName);
+ template<typename T> void addObjectImpl(const T*, MemoryObjectInfo*, MemberType, const char* edgeName);
+ template<typename T> void addObjectImpl(const OwnPtr<T>*, MemoryObjectInfo*, MemberType, const char* edgeName);
+ template<typename T> void addObjectImpl(const RefPtr<T>*, MemoryObjectInfo*, MemberType, const char* edgeName);
MemoryInstrumentationClient* m_client;
};
@@ -261,14 +264,14 @@
}
template<typename T>
-void MemoryInstrumentation::addObjectImpl(const T* object, MemoryObjectInfo* ownerObjectInfo, MemoryOwningType owningType, const char* edgeName)
+void MemoryInstrumentation::addObjectImpl(const T* object, MemoryObjectInfo* ownerObjectInfo, MemberType memberType, const char* edgeName)
{
- if (owningType == byReference)
+ if (memberType == ReferenceMember)
reportMemoryUsage(object, ownerObjectInfo);
else {
if (!object)
return;
- reportEdge(ownerObjectInfo, object, edgeName);
+ reportEdge(object, edgeName, memberType);
if (visited(object))
return;
deferObject(adoptPtr(new Wrapper<T>(object, getObjectType(ownerObjectInfo))));
@@ -276,19 +279,19 @@
}
template<typename T>
-void MemoryInstrumentation::addObjectImpl(const OwnPtr<T>* object, MemoryObjectInfo* ownerObjectInfo, MemoryOwningType owningType, const char* edgeName)
+void MemoryInstrumentation::addObjectImpl(const OwnPtr<T>* object, MemoryObjectInfo* ownerObjectInfo, MemberType memberType, const char* edgeName)
{
- if (owningType == byPointer && !visited(object))
+ if (memberType == PointerMember && !visited(object))
countObjectSize(object, getObjectType(ownerObjectInfo), sizeof(*object));
- addObjectImpl(object->get(), ownerObjectInfo, byPointer, edgeName);
+ addObjectImpl(object->get(), ownerObjectInfo, OwnPtrMember, edgeName);
}
template<typename T>
-void MemoryInstrumentation::addObjectImpl(const RefPtr<T>* object, MemoryObjectInfo* ownerObjectInfo, MemoryOwningType owningType, const char* edgeName)
+void MemoryInstrumentation::addObjectImpl(const RefPtr<T>* object, MemoryObjectInfo* ownerObjectInfo, MemberType memberType, const char* edgeName)
{
- if (owningType == byPointer && !visited(object))
+ if (memberType == PointerMember && !visited(object))
countObjectSize(object, getObjectType(ownerObjectInfo), sizeof(*object));
- addObjectImpl(object->get(), ownerObjectInfo, byPointer, edgeName);
+ addObjectImpl(object->get(), ownerObjectInfo, RefPtrMember, edgeName);
}
template<typename T>
Modified: trunk/Source/WebCore/ChangeLog (138451 => 138452)
--- trunk/Source/WebCore/ChangeLog 2012-12-25 06:16:43 UTC (rev 138451)
+++ trunk/Source/WebCore/ChangeLog 2012-12-25 07:01:51 UTC (rev 138452)
@@ -1,3 +1,29 @@
+2012-12-24 Ilya Tikhonovsky <[email protected]>
+
+ Web Inspector: Native Memory Instrumentation: propagate member type as edge type to the serialized heap graph.
+ https://bugs.webkit.org/show_bug.cgi?id=105725
+
+ Reviewed by Yury Semikhatsky.
+
+ MemoryOwningType was renamed to MemberType.
+ Source argument were removed from reportEdge, reportLeaf and other edge related methods because it is not necessary.
+ MemberType argument was propagated from MemoryInstrumentation down to HeapGraphSerializer.
+
+ * inspector/HeapGraphSerializer.cpp:
+ (WebCore::HeapGraphEdge::HeapGraphEdge):
+ (HeapGraphEdge):
+ (WebCore::HeapGraphSerializer::HeapGraphSerializer):
+ (WebCore::HeapGraphSerializer::reportEdge):
+ (WebCore::HeapGraphSerializer::reportLeaf):
+ (WebCore::HeapGraphSerializer::serialize):
+ * inspector/HeapGraphSerializer.h:
+ (HeapGraphSerializer):
+ * inspector/MemoryInstrumentationImpl.cpp:
+ (WebCore::MemoryInstrumentationClientImpl::reportEdge):
+ (WebCore::MemoryInstrumentationClientImpl::reportLeaf):
+ * inspector/MemoryInstrumentationImpl.h:
+ (MemoryInstrumentationClientImpl):
+
2012-12-24 Takashi Sakamoto <[email protected]>
::first-letter { overflow: -webkit-paged-y } causes crash
Modified: trunk/Source/WebCore/inspector/HeapGraphSerializer.cpp (138451 => 138452)
--- trunk/Source/WebCore/inspector/HeapGraphSerializer.cpp 2012-12-25 06:16:43 UTC (rev 138451)
+++ trunk/Source/WebCore/inspector/HeapGraphSerializer.cpp 2012-12-25 07:01:51 UTC (rev 138452)
@@ -85,6 +85,18 @@
: m_lastReportedEdgeIndex(0)
{
m_strings.append(String());
+
+ memset(m_edgeTypes, 0, sizeof(m_edgeTypes));
+
+ ASSERT(m_strings.size());
+ m_edgeTypes[WTF::PointerMember] = m_strings.size();
+ m_strings.append("weakRef");
+
+ m_edgeTypes[WTF::OwnPtrMember] = m_strings.size();
+ m_strings.append("ownRef");
+
+ m_edgeTypes[WTF::RefPtrMember] = m_strings.size();
+ m_strings.append("countRef");
}
HeapGraphSerializer::~HeapGraphSerializer()
@@ -106,16 +118,19 @@
m_nodes.append(node);
}
-void HeapGraphSerializer::reportEdge(const void*, const void* to, const char* name)
+void HeapGraphSerializer::reportEdge(const void* to, const char* name, WTF::MemberType memberType)
{
HeapGraphEdge edge;
ASSERT(to);
+ ASSERT(memberType >= 0);
+ ASSERT(memberType < WTF::LastMemberTypeEntry);
+ edge.m_type = m_edgeTypes[memberType];
edge.m_toObject = to;
edge.m_name = addString(name);
m_edges.append(edge);
}
-void HeapGraphSerializer::reportLeaf(const void*, const WTF::MemoryObjectInfo& info, const char* edgeName)
+void HeapGraphSerializer::reportLeaf(const WTF::MemoryObjectInfo& info, const char* edgeName)
{
HeapGraphNode node;
node.m_type = addString(info.objectType());
@@ -127,6 +142,7 @@
m_nodes.append(node);
HeapGraphEdge edge;
+ edge.m_type = m_edgeTypes[WTF::OwnPtrMember];
edge.m_toIndex = nodeIndex;
edge.m_targetIndexIsKnown = true;
edge.m_name = addString(edgeName);
Modified: trunk/Source/WebCore/inspector/HeapGraphSerializer.h (138451 => 138452)
--- trunk/Source/WebCore/inspector/HeapGraphSerializer.h 2012-12-25 06:16:43 UTC (rev 138451)
+++ trunk/Source/WebCore/inspector/HeapGraphSerializer.h 2012-12-25 07:01:51 UTC (rev 138452)
@@ -52,8 +52,8 @@
HeapGraphSerializer();
~HeapGraphSerializer();
void reportNode(const WTF::MemoryObjectInfo&);
- void reportEdge(const void*, const void*, const char*);
- void reportLeaf(const void*, const WTF::MemoryObjectInfo&, const char*);
+ void reportEdge(const void*, const char*, WTF::MemberType);
+ void reportLeaf(const WTF::MemoryObjectInfo&, const char*);
void reportBaseAddress(const void*, const void*);
PassRefPtr<InspectorObject> serialize();
@@ -77,6 +77,8 @@
Vector<HeapGraphNode> m_nodes;
Vector<HeapGraphEdge> m_edges;
+
+ size_t m_edgeTypes[WTF::LastMemberTypeEntry];
};
} // namespace WebCore
Modified: trunk/Source/WebCore/inspector/MemoryInstrumentationImpl.cpp (138451 => 138452)
--- trunk/Source/WebCore/inspector/MemoryInstrumentationImpl.cpp 2012-12-25 06:16:43 UTC (rev 138451)
+++ trunk/Source/WebCore/inspector/MemoryInstrumentationImpl.cpp 2012-12-25 07:01:51 UTC (rev 138452)
@@ -101,16 +101,16 @@
m_graphSerializer->reportNode(node);
}
-void MemoryInstrumentationClientImpl::reportEdge(const void* source, const void* target, const char* name)
+void MemoryInstrumentationClientImpl::reportEdge(const void* target, const char* name, MemberType memberType)
{
if (m_graphSerializer)
- m_graphSerializer->reportEdge(source, target, name);
+ m_graphSerializer->reportEdge(target, name, memberType);
}
-void MemoryInstrumentationClientImpl::reportLeaf(const void* owner, const MemoryObjectInfo& target, const char* edgeName)
+void MemoryInstrumentationClientImpl::reportLeaf(const MemoryObjectInfo& target, const char* edgeName)
{
if (m_graphSerializer)
- m_graphSerializer->reportLeaf(owner, target, edgeName);
+ m_graphSerializer->reportLeaf(target, edgeName);
}
void MemoryInstrumentationClientImpl::reportBaseAddress(const void* base, const void* real)
Modified: trunk/Source/WebCore/inspector/MemoryInstrumentationImpl.h (138451 => 138452)
--- trunk/Source/WebCore/inspector/MemoryInstrumentationImpl.h 2012-12-25 06:16:43 UTC (rev 138451)
+++ trunk/Source/WebCore/inspector/MemoryInstrumentationImpl.h 2012-12-25 07:01:51 UTC (rev 138452)
@@ -40,6 +40,7 @@
#include <wtf/text/StringHash.h>
using WTF::MemoryObjectType;
+using WTF::MemberType;
namespace WebCore {
@@ -85,8 +86,8 @@
virtual bool visited(const void*) OVERRIDE;
virtual bool checkCountedObject(const void*) OVERRIDE;
virtual void reportNode(const MemoryObjectInfo&) OVERRIDE;
- virtual void reportEdge(const void*, const void*, const char*) OVERRIDE;
- virtual void reportLeaf(const void*, const MemoryObjectInfo&, const char*) OVERRIDE;
+ virtual void reportEdge(const void*, const char*, MemberType) OVERRIDE;
+ virtual void reportLeaf(const MemoryObjectInfo&, const char*) OVERRIDE;
virtual void reportBaseAddress(const void*, const void*) OVERRIDE;
void reportMemoryUsage(MemoryObjectInfo*) const;
Modified: trunk/Tools/ChangeLog (138451 => 138452)
--- trunk/Tools/ChangeLog 2012-12-25 06:16:43 UTC (rev 138451)
+++ trunk/Tools/ChangeLog 2012-12-25 07:01:51 UTC (rev 138452)
@@ -1,3 +1,15 @@
+2012-12-24 Ilya Tikhonovsky <[email protected]>
+
+ Web Inspector: Native Memory Instrumentation: propagate member type as edge type to the serialized heap graph.
+ https://bugs.webkit.org/show_bug.cgi?id=105725
+
+ Reviewed by Yury Semikhatsky.
+
+ MemberType value names were adjusted according to Style Guide.
+ Existing tests were extended with link type validation.
+
+ * TestWebKitAPI/Tests/WTF/MemoryInstrumentationTest.cpp:
+
2012-12-24 Xiaobo Wang <[email protected]>
[BlackBerry] DRT - Crashed when running pixels tests
Modified: trunk/Tools/TestWebKitAPI/Tests/WTF/MemoryInstrumentationTest.cpp (138451 => 138452)
--- trunk/Tools/TestWebKitAPI/Tests/WTF/MemoryInstrumentationTest.cpp 2012-12-25 06:16:43 UTC (rev 138451)
+++ trunk/Tools/TestWebKitAPI/Tests/WTF/MemoryInstrumentationTest.cpp 2012-12-25 07:01:51 UTC (rev 138452)
@@ -79,11 +79,20 @@
using WTF::MemoryObjectInfo;
using WTF::MemoryClassInfo;
using WTF::MemoryObjectType;
+using WTF::MemberType;
MemoryObjectType TestType = "TestType";
class MemoryInstrumentationTestClient : public WTF::MemoryInstrumentationClient {
public:
+ MemoryInstrumentationTestClient() : m_links(WTF::LastMemberTypeEntry)
+ {
+ m_links[WTF::PointerMember] = 0;
+ m_links[WTF::ReferenceMember] = 0;
+ m_links[WTF::RefPtrMember] = 0;
+ m_links[WTF::OwnPtrMember] = 0;
+ }
+
virtual void countObjectSize(const void*, MemoryObjectType objectType, size_t size)
{
TypeToSizeMap::AddResult result = m_totalSizes.add(objectType, size);
@@ -93,8 +102,14 @@
virtual bool visited(const void* object) { return !m_visitedObjects.add(object).isNewEntry; }
virtual bool checkCountedObject(const void*) { return true; }
virtual void reportNode(const MemoryObjectInfo&) OVERRIDE { }
- virtual void reportEdge(const void*, const void*, const char*) OVERRIDE { }
- virtual void reportLeaf(const void*, const MemoryObjectInfo&, const char*) OVERRIDE { }
+ virtual void reportEdge(const void*, const char*, MemberType memberType) OVERRIDE
+ {
+ ++m_links[memberType];
+ }
+ virtual void reportLeaf(const MemoryObjectInfo&, const char*) OVERRIDE
+ {
+ ++m_links[WTF::OwnPtrMember];
+ }
virtual void reportBaseAddress(const void*, const void*) OVERRIDE { }
size_t visitedObjects() const { return m_visitedObjects.size(); }
@@ -104,6 +119,11 @@
return i == m_totalSizes.end() ? 0 : i->value;
}
+ size_t linksCount(const WTF::MemberType memberType) const
+ {
+ return m_links[memberType];
+ }
+
size_t reportedSizeForAllTypes() const
{
size_t size = 0;
@@ -116,6 +136,7 @@
typedef HashMap<MemoryObjectType, size_t> TypeToSizeMap;
TypeToSizeMap m_totalSizes;
WTF::HashSet<const void*> m_visitedObjects;
+ WTF::Vector<size_t, WTF::LastMemberTypeEntry> m_links;
};
class InstrumentationTestImpl : public WTF::MemoryInstrumentation {
@@ -130,6 +151,7 @@
size_t visitedObjects() const { return m_client->visitedObjects(); }
size_t reportedSizeForAllTypes() const { return m_client->reportedSizeForAllTypes(); }
size_t totalSize(const MemoryObjectType objectType) const { return m_client->totalSize(objectType); }
+ size_t linksCount(const WTF::MemberType memberType) const { return m_client->linksCount(memberType); }
private:
MemoryInstrumentationTestClient* m_client;
@@ -192,6 +214,7 @@
helper.addRootObject(instrumented);
EXPECT_EQ(sizeof(NotInstrumented), helper.reportedSizeForAllTypes());
EXPECT_EQ(1u, helper.visitedObjects());
+ EXPECT_EQ(1u, helper.linksCount(WTF::PointerMember));
}
TEST(MemoryInstrumentationTest, nullCheck)
@@ -201,6 +224,7 @@
helper.addRootObject(instrumented);
EXPECT_EQ(0u, helper.reportedSizeForAllTypes());
EXPECT_EQ(0u, helper.visitedObjects());
+ EXPECT_EQ(0u, helper.linksCount(WTF::PointerMember));
}
TEST(MemoryInstrumentationTest, ptrVsRef)
@@ -211,6 +235,7 @@
helper.addRootObject(&instrumented);
EXPECT_EQ(sizeof(Instrumented) + sizeof(NotInstrumented), helper.reportedSizeForAllTypes());
EXPECT_EQ(2u, helper.visitedObjects());
+ EXPECT_EQ(1u, helper.linksCount(WTF::PointerMember));
}
{
InstrumentationTestHelper helper;
@@ -218,6 +243,7 @@
helper.addRootObject(instrumented);
EXPECT_EQ(sizeof(NotInstrumented), helper.reportedSizeForAllTypes());
EXPECT_EQ(1u, helper.visitedObjects());
+ EXPECT_EQ(1u, helper.linksCount(WTF::PointerMember));
}
}
@@ -241,6 +267,8 @@
helper.addRootObject(instrumentedWithOwnPtr);
EXPECT_EQ(2u * sizeof(NotInstrumented), helper.reportedSizeForAllTypes());
EXPECT_EQ(2u, helper.visitedObjects());
+ EXPECT_EQ(1u, helper.linksCount(WTF::OwnPtrMember));
+ EXPECT_EQ(1u, helper.linksCount(WTF::PointerMember));
}
class InstrumentedUndefined {
@@ -760,6 +788,7 @@
helper.addRootObject(value);
EXPECT_EQ(sizeof(int) * 1000 + sizeof(ArrayBuffer), helper.reportedSizeForAllTypes());
EXPECT_EQ(2u, helper.visitedObjects());
+ EXPECT_EQ(1u, helper.linksCount(WTF::RefPtrMember));
}
class AncestorWithVirtualMethod {
@@ -851,7 +880,7 @@
class CountLinksFromInstrumentedObject : public MemoryInstrumentationTestClient {
public:
CountLinksFromInstrumentedObject() : m_linkCount(0) { }
- virtual void reportEdge(const void* source, const void* destination, const char* name) OVERRIDE
+ virtual void reportEdge(const void*, const char* name, MemberType) OVERRIDE
{
if (name && !strcmp("m_notInstrumented", name))
m_linkCount++;
