0

Remove Purify and Quantify.Doing so will reduce substantially the size of the project files.

BUG=92102
Review URL: http://codereview.chromium.org/7528010

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@97156 0039d316-1c4b-4281-b951-d872f2087c98
This commit is contained in:
jeanluc@chromium.org
2011-08-17 17:41:02 +00:00
parent d44583b743
commit 64e95e1c7b
39 changed files with 23 additions and 534 deletions

@@ -133,8 +133,6 @@
'mach_ipc_mac.h', 'mach_ipc_mac.h',
'mach_ipc_mac.mm', 'mach_ipc_mac.mm',
'memory/linked_ptr.h', 'memory/linked_ptr.h',
'memory/memory_debug.cc',
'memory/memory_debug.h',
'memory/mru_cache.h', 'memory/mru_cache.h',
'memory/raw_scoped_refptr_mismatch_checker.h', 'memory/raw_scoped_refptr_mismatch_checker.h',
'memory/ref_counted.cc', 'memory/ref_counted.cc',
@@ -542,7 +540,6 @@
[ 'OS != "win"', { [ 'OS != "win"', {
'dependencies': ['../third_party/libevent/libevent.gyp:libevent'], 'dependencies': ['../third_party/libevent/libevent.gyp:libevent'],
'sources!': [ 'sources!': [
'third_party/purify/pure_api.c',
'event_recorder.cc', 'event_recorder.cc',
'resource_util.cc', 'resource_util.cc',
], ],
@@ -561,8 +558,6 @@
'third_party/nspr/prcpucfg.h', 'third_party/nspr/prcpucfg.h',
'third_party/nspr/prcpucfg_win.h', 'third_party/nspr/prcpucfg_win.h',
'third_party/nspr/prtypes.h', 'third_party/nspr/prtypes.h',
'third_party/purify/pure.h',
'third_party/purify/pure_api.c',
'third_party/xdg_user_dirs/xdg_user_dir_lookup.cc', 'third_party/xdg_user_dirs/xdg_user_dir_lookup.cc',
'third_party/xdg_user_dirs/xdg_user_dir_lookup.h', 'third_party/xdg_user_dirs/xdg_user_dir_lookup.h',
'auto_reset.h', 'auto_reset.h',

@@ -1,54 +0,0 @@
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/memory/memory_debug.h"
#ifdef PURIFY
// this #define is used to prevent people from directly using pure.h
// instead of memory_debug.h
#define PURIFY_PRIVATE_INCLUDE
#include "base/third_party/purify/pure.h"
#endif
namespace base {
bool MemoryDebug::memory_in_use_ = false;
void MemoryDebug::SetMemoryInUseEnabled(bool enabled) {
memory_in_use_ = enabled;
}
void MemoryDebug::DumpAllMemoryInUse() {
#ifdef PURIFY
if (memory_in_use_)
PurifyAllInuse();
#endif
}
void MemoryDebug::DumpNewMemoryInUse() {
#ifdef PURIFY
if (memory_in_use_)
PurifyNewInuse();
#endif
}
void MemoryDebug::DumpAllLeaks() {
#ifdef PURIFY
PurifyAllLeaks();
#endif
}
void MemoryDebug::DumpNewLeaks() {
#ifdef PURIFY
PurifyNewLeaks();
#endif
}
void MemoryDebug::MarkAsInitialized(void* addr, size_t size) {
#ifdef PURIFY
PurifyMarkAsInitialized(addr, size);
#endif
}
} // namespace base

@@ -1,48 +0,0 @@
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Functions used to debug memory usage, leaks, and other memory issues.
// All methods are effectively no-ops unless this program is being run through
// a supported memory tool (currently, only Purify)
#ifndef BASE_MEMORY_MEMORY_DEBUG_H_
#define BASE_MEMORY_MEMORY_DEBUG_H_
#pragma once
#include "base/base_export.h"
#include "base/basictypes.h"
namespace base {
class BASE_EXPORT MemoryDebug {
public:
// Since MIU messages are a lot of data, and we don't always want this data,
// we have a global switch. If disabled, *MemoryInUse are no-ops.
static void SetMemoryInUseEnabled(bool enabled);
// Dump information about all memory in use.
static void DumpAllMemoryInUse();
// Dump information about new memory in use since the last
// call to DumpAllMemoryInUse() or DumpNewMemoryInUse().
static void DumpNewMemoryInUse();
// Dump information about all current memory leaks.
static void DumpAllLeaks();
// Dump information about new memory leaks since the last
// call to DumpAllLeaks() or DumpNewLeaks()
static void DumpNewLeaks();
// Mark |size| bytes of memory as initialized, so it doesn't produce any UMRs
// or UMCs.
static void MarkAsInitialized(void* addr, size_t size);
private:
static bool memory_in_use_;
DISALLOW_IMPLICIT_CONSTRUCTORS(MemoryDebug);
};
} // namespace base
#endif // BASE_MEMORY_MEMORY_DEBUG_H_

@@ -223,8 +223,7 @@ TEST_F(SingletonTest, Basic) {
// Verify that only the expected callback has been called. // Verify that only the expected callback has been called.
VerifiesCallbacks(); VerifiesCallbacks();
// Delete the leaky singleton. It is interesting to note that Purify does // Delete the leaky singleton.
// *not* detect the leak when this call is commented out. :(
DeleteLeakySingleton(); DeleteLeakySingleton();
// The static singleton can't be acquired post-atexit. // The static singleton can't be acquired post-atexit.

@@ -532,12 +532,11 @@ void MessageLoop::ReloadWorkQueue() {
bool MessageLoop::DeletePendingTasks() { bool MessageLoop::DeletePendingTasks() {
bool did_work = !work_queue_.empty(); bool did_work = !work_queue_.empty();
// TODO(darin): Delete all tasks once it is safe to do so. // TODO(darin): Delete all tasks once it is safe to do so.
// Until it is totally safe, just do it when running Purify or // Until it is totally safe, just do it when running Valgrind.
// Valgrind.
// //
// See http://crbug.com/61131 // See http://crbug.com/61131
// //
#if defined(PURIFY) || defined(USE_HEAPCHECKER) #if defined(USE_HEAPCHECKER)
should_leak_tasks_ = false; should_leak_tasks_ = false;
#else #else
if (RunningOnValgrind()) if (RunningOnValgrind())

@@ -40,7 +40,7 @@ class FieldTrialTest : public testing::Test {
}; };
// Test registration, and also check that destructors are called for trials // Test registration, and also check that destructors are called for trials
// (and that Purify doesn't catch us leaking). // (and that Valgrind doesn't catch us leaking).
TEST_F(FieldTrialTest, Registration) { TEST_F(FieldTrialTest, Registration) {
const char* name1 = "name 1 test"; const char* name1 = "name 1 test";
const char* name2 = "name 2 test"; const char* name2 = "name 2 test";

@@ -394,7 +394,7 @@ char* Pickle::BeginWrite(size_t length) {
} }
void Pickle::EndWrite(char* dest, int length) { void Pickle::EndWrite(char* dest, int length) {
// Zero-pad to keep tools like purify from complaining about uninitialized // Zero-pad to keep tools like valgrind from complaining about uninitialized
// memory. // memory.
if (length % sizeof(uint32)) if (length % sizeof(uint32))
memset(dest + length, 0, sizeof(uint32) - (length % sizeof(uint32))); memset(dest + length, 0, sizeof(uint32) - (length % sizeof(uint32)));

@@ -1,2 +0,0 @@
(C) Copyright IBM Corporation. 2006, 2006. All Rights Reserved.
You may recompile and redistribute these definitions as required.

@@ -1,2 +0,0 @@
Name: purify headers
URL: http://www-01.ibm.com/software/awdtools/purify/

@@ -1,145 +0,0 @@
/*
* Header file of Pure API function declarations.
*
* (C) Copyright IBM Corporation. 2006, 2006. All Rights Reserved.
* You may recompile and redistribute these definitions as required.
*
* Version 1.0
*/
#if defined(PURIFY) || defined(QUANTIFY)
#if defined(c_plusplus) || defined(__cplusplus)
extern "C" {
#endif
// Don't include this file directly, use purify.h instead.
// If you need something that's not there, add it.
#ifdef PURIFY_PRIVATE_INCLUDE
#define PURE_H_VERSION 1
#include <stddef.h>
//////////////////////////////
// API's Specific to Purify //
//////////////////////////////
// TRUE when Purify is running.
int __cdecl PurifyIsRunning(void) ;
//
// Print a string to the viewer.
//
int __cdecl PurePrintf(const char *fmt, ...) ;
int __cdecl PurifyPrintf(const char *fmt, ...) ;
//
// Purify functions for leak and memory-in-use functionalty.
//
size_t __cdecl PurifyNewInuse(void) ;
size_t __cdecl PurifyAllInuse(void) ;
size_t __cdecl PurifyClearInuse(void) ;
size_t __cdecl PurifyNewLeaks(void) ;
size_t __cdecl PurifyAllLeaks(void) ;
size_t __cdecl PurifyClearLeaks(void) ;
//
// Purify functions for handle leakage.
//
size_t __cdecl PurifyAllHandlesInuse(void) ;
size_t __cdecl PurifyNewHandlesInuse(void) ;
//
// Functions that tell you about the state of memory.
//
size_t __cdecl PurifyDescribe(void *addr) ;
size_t __cdecl PurifyWhatColors(void *addr, size_t size) ;
//
// Functions to test the state of memory. If the memory is not
// accessable, an error is signaled just as if there were a memory
// reference and the function returns false.
//
int __cdecl PurifyAssertIsReadable(const void *addr, size_t size) ; // size used to be an int, until IA64 came along
int __cdecl PurifyAssertIsWritable(const void *addr, size_t size) ;
//
// Functions to test the state of memory. If the memory is not
// accessable, these functions return false. No error is signaled.
//
int __cdecl PurifyIsReadable(const void *addr, size_t size) ;
int __cdecl PurifyIsWritable(const void *addr, size_t size) ;
int __cdecl PurifyIsInitialized(const void *addr, size_t size) ;
//
// Functions to set the state of memory.
//
void __cdecl PurifyMarkAsInitialized(void *addr, size_t size) ;
void __cdecl PurifyMarkAsUninitialized(void *addr, size_t size) ;
//
// Functions to do late detection of ABWs, FMWs, IPWs.
//
#define PURIFY_HEAP_CRT (HANDLE) ~(__int64) 1 /* 0xfffffffe */
#define PURIFY_HEAP_ALL (HANDLE) ~(__int64) 2 /* 0xfffffffd */
#define PURIFY_HEAP_BLOCKS_LIVE 0x80000000
#define PURIFY_HEAP_BLOCKS_DEFERRED_FREE 0x40000000
#define PURIFY_HEAP_BLOCKS_ALL (PURIFY_HEAP_BLOCKS_LIVE|PURIFY_HEAP_BLOCKS_DEFERRED_FREE)
int __cdecl PurifyHeapValidate(unsigned int hHeap, unsigned int dwFlags, const void *addr) ;
int __cdecl PurifySetLateDetectScanCounter(int counter);
int __cdecl PurifySetLateDetectScanInterval(int seconds);
//
// Functions to support pool allocators
//
void __cdecl PurifySetPoolId(const void *mem, int id);
int __cdecl PurifyGetPoolId(const void *mem);
void __cdecl PurifySetUserData(const void *mem, void *data);
void * __cdecl PurifyGetUserData(const void *mem);
void __cdecl PurifyMapPool(int id, void(*fn)());
////////////////////////////////
// API's Specific to Quantify //
////////////////////////////////
// TRUE when Quantify is running.
int __cdecl QuantifyIsRunning(void) ;
//
// Functions for controlling collection
//
int __cdecl QuantifyDisableRecordingData(void) ;
int __cdecl QuantifyStartRecordingData(void) ;
int __cdecl QuantifyStopRecordingData(void) ;
int __cdecl QuantifyClearData(void) ;
int __cdecl QuantifyIsRecordingData(void) ;
// Add a comment to the dataset
int __cdecl QuantifyAddAnnotation(char *) ;
// Save the current data, creating a "checkpoint" dataset
int __cdecl QuantifySaveData(void) ;
// Set the name of the current thread in the viewer
int __cdecl QuantifySetThreadName(char *) ;
////////////////////////////////
// API's Specific to Coverage //
////////////////////////////////
// TRUE when Coverage is running.
int __cdecl CoverageIsRunning(void) ;
//
// Functions for controlling collection
//
int __cdecl CoverageDisableRecordingData(void) ;
int __cdecl CoverageStartRecordingData(void) ;
int __cdecl CoverageStopRecordingData(void) ;
int __cdecl CoverageClearData(void) ;
int __cdecl CoverageIsRecordingData(void) ;
// Add a comment to the dataset
int __cdecl CoverageAddAnnotation(char *) ;
// Save the current data, creating a "checkpoint" dataset
int __cdecl CoverageSaveData(void) ;
#endif // PURIFY_PRIVATE_INCLUDE
#if defined(c_plusplus) || defined(__cplusplus)
}
#endif
#endif // defined(PURIFY) || defined(QUANTIFY)

@@ -1,152 +0,0 @@
/*
* Header file of Pure API function declarations.
*
* Explicitly no copyright.
* You may recompile and redistribute these definitions as required.
*
* NOTE1: In some situations when compiling with MFC, you should
* enable the setting 'Not using precompiled headers' in Visual C++
* to avoid a compiler diagnostic.
*
* NOTE2: This file works through the use of deep magic. Calls to functions
* in this file are replaced with calls into the OCI runtime system
* when an instrumented version of this program is run.
*
* NOTE3: The static vars avoidGy_n (where n is a unique number) are used
* to prevent optimizing the functions away when compiler option
* /Gy is set. This is needed so that NOTE2 works properly.
*/
// Chromium note: We used to only compile this code if PURIFY was defined,
// because we did special builds with all optimizations turned off for Purify.
// However, for profiling with Quantify, we want most/all optimizations turned
// on so that we measure something closer to real execution.
#ifdef _WINDOWS // we only use Purify/Quantify on Windows
#pragma once
extern int errno;
typedef int ptrdiff_t;
typedef unsigned int size_t;
typedef unsigned short wchar_t;
static int avoidGy_1 = 0;
static int avoidGy_2 = 0;
static int avoidGy_3 = 0;
static int avoidGy_4 = 0;
static int avoidGy_5 = 0;
static int avoidGy_6 = 0;
static int avoidGy_7 = 0;
static int avoidGy_8 = 0;
static int avoidGy_9 = 0;
static int avoidGy_10 = 0;
static int avoidGy_11 = 0;
static int avoidGy_12 = 0;
static int avoidGy_13 = 0;
static int avoidGy_14 = 0;
static int avoidGy_15 = 0;
static int avoidGy_16 = 0;
static int avoidGy_17 = 0;
static int avoidGy_18 = 0;
static int avoidGy_19 = 0;
static int avoidGy_20 = 0;
static int avoidGy_21 = 0;
static int avoidGy_22 = 0;
static int avoidGy_23 = 0;
static int avoidGy_24 = 0;
static int avoidGy_25 = 0;
static int avoidGy_26 = 0;
static int avoidGy_27 = 0;
static int avoidGy_28 = 0;
static int avoidGy_29 = 0;
static int avoidGy_30 = 0;
static int avoidGy_31 = 0;
static int avoidGy_32 = 0;
static int avoidGy_33 = 0;
static int avoidGy_34 = 0;
static int avoidGy_35 = 0;
static int avoidGy_36 = 0;
static int avoidGy_37 = 0;
static int avoidGy_38 = 0;
static int avoidGy_39 = 0;
static int avoidGy_40 = 0;
static int avoidGy_41 = 0;
static int avoidGy_42 = 0;
static int avoidGy_43 = 0;
static int avoidGy_44 = 0;
static int avoidGy_45 = 0;
static int avoidGy_46 = 0;
static int avoidGy_47 = 0;
static int avoidGy_48 = 0;
static int avoidGy_49 = 0;
static int avoidGy_50 = 0;
static int avoidGy_51 = 0;
static int avoidGy_52 = 0;
static int avoidGy_53 = 0;
static int avoidGy_54 = 0;
static int avoidGy_55 = 0;
static int avoidGy_56 = 0;
static int avoidGy_57 = 0;
static int avoidGy_58 = 0;
static int avoidGy_59 = 0;
static int avoidGy_60 = 0;
static int avoidGy_61 = 0;
static int avoidGy_62 = 0;
static int avoidGy_63 = 0;
static int avoidGy_64 = 0;
static int avoidGy_65 = 0;
static int avoidGy_PL_01 = 0;
static int avoidGy_PL_02 = 0;
__declspec(dllexport) int __cdecl PurePrintf(const char *fmt, ...) { if(!++avoidGy_1); fmt; return 0; }
__declspec(dllexport) int __cdecl PurifyIsRunning(void) { if(!++avoidGy_2); return 0; }
__declspec(dllexport) int __cdecl PurifyPrintf(const char *fmt, ...) { if(!++avoidGy_3); fmt; return 0; }
__declspec(dllexport) size_t __cdecl PurifyNewInuse(void) { if(!++avoidGy_4); return 0; }
__declspec(dllexport) size_t __cdecl PurifyAllInuse(void) { if(!++avoidGy_5); return 0; }
__declspec(dllexport) size_t __cdecl PurifyClearInuse(void) { if(!++avoidGy_6); return 0; }
__declspec(dllexport) size_t __cdecl PurifyNewLeaks(void) { if(!++avoidGy_7); return 0; }
__declspec(dllexport) size_t __cdecl PurifyAllLeaks(void) { if(!++avoidGy_8); return 0; }
__declspec(dllexport) size_t __cdecl PurifyClearLeaks(void) { if(!++avoidGy_9); return 0; }
__declspec(dllexport) size_t __cdecl PurifyAllHandlesInuse(void) { if(!++avoidGy_10); return 0; }
__declspec(dllexport) size_t __cdecl PurifyNewHandlesInuse(void) { if(!++avoidGy_11); return 0; }
__declspec(dllexport) size_t __cdecl PurifyDescribe(void *addr) { if(!++avoidGy_12); addr; return 0; }
__declspec(dllexport) int __cdecl PurifyWhatColors(void *addr, size_t size) { if(!++avoidGy_13); addr; size; return 0; }
__declspec(dllexport) int __cdecl PurifyAssertIsReadable(const void *addr, size_t size) { if(!++avoidGy_14); addr; size; return 1; }
__declspec(dllexport) int __cdecl PurifyAssertIsWritable(const void *addr, size_t size) { if(!++avoidGy_15); addr; size; return 1; }
__declspec(dllexport) int __cdecl PurifyIsReadable(const void *addr, size_t size) { if(!++avoidGy_16); addr; size; return 1; }
__declspec(dllexport) int __cdecl PurifyIsWritable(const void *addr, size_t size) { if(!++avoidGy_17); addr; size; return 1; }
__declspec(dllexport) int __cdecl PurifyIsInitialized(const void *addr, size_t size) { if(!++avoidGy_18); addr; size; return 1; }
__declspec(dllexport) int __cdecl PurifyRed(void *addr, size_t size) { if(!++avoidGy_19); addr; size; return 0; }
__declspec(dllexport) int __cdecl PurifyGreen(void *addr, size_t size) { if(!++avoidGy_20); addr; size; return 0; }
__declspec(dllexport) int __cdecl PurifyYellow(void *addr, size_t size) { if(!++avoidGy_21); addr; size; return 0; }
__declspec(dllexport) int __cdecl PurifyBlue(void *addr, size_t size) { if(!++avoidGy_22); addr; size; return 0; }
__declspec(dllexport) int __cdecl PurifyMarkAsInitialized(void *addr, size_t size) { if(!++avoidGy_23); addr; size; return 0; }
__declspec(dllexport) int __cdecl PurifyMarkAsUninitialized(void *addr, size_t size) { if(!++avoidGy_24); addr; size; return 0; }
__declspec(dllexport) int __cdecl PurifyMarkForTrap(void *addr, size_t size) { if(!++avoidGy_25); addr; size; return 0; }
__declspec(dllexport) int __cdecl PurifyMarkForNoTrap(void *addr, size_t size) { if(!++avoidGy_26); addr; size; return 0; }
__declspec(dllexport) int __cdecl PurifyHeapValidate(unsigned int hHeap, unsigned int dwFlags, const void *addr)
{ if(!++avoidGy_27); hHeap; dwFlags; addr; return 1; }
__declspec(dllexport) int __cdecl PurifySetLateDetectScanCounter(int counter) { if(!++avoidGy_28); counter; return 0; };
__declspec(dllexport) int __cdecl PurifySetLateDetectScanInterval(int seconds) { if(!++avoidGy_29); seconds; return 0; };
__declspec(dllexport) void __cdecl PurifySetPoolId(const void *mem, int id) { if(!++avoidGy_61); mem; id; return; };
__declspec(dllexport) int __cdecl PurifyGetPoolId(const void *mem) { if(!++avoidGy_62); mem; return 0; };
__declspec(dllexport) void __cdecl PurifySetUserData(const void *mem, void *data) { if(!++avoidGy_63); mem; data; return; };
__declspec(dllexport) void * __cdecl PurifyGetUserData(const void *mem) { if(!++avoidGy_64); mem; return 0; };
__declspec(dllexport) void __cdecl PurifyMapPool(int id, void(*fn)()) { if(!++avoidGy_65); id; fn; return; };
__declspec(dllexport) int __cdecl CoverageIsRunning(void) { if(!++avoidGy_30); return 0; }
__declspec(dllexport) int __cdecl CoverageDisableRecordingData(void) { if(!++avoidGy_31); return 0; }
__declspec(dllexport) int __cdecl CoverageStartRecordingData(void) { if(!++avoidGy_32); return 0; }
__declspec(dllexport) int __cdecl CoverageStopRecordingData(void) { if(!++avoidGy_33); return 0; }
__declspec(dllexport) int __cdecl CoverageClearData(void) { if(!++avoidGy_34); return 0; }
__declspec(dllexport) int __cdecl CoverageIsRecordingData(void) { if(!++avoidGy_35); return 0; }
__declspec(dllexport) int __cdecl CoverageAddAnnotation(char *str) { if(!++avoidGy_36); str; return 0; }
__declspec(dllexport) int __cdecl CoverageSaveData(void) { if(!++avoidGy_37); return 0; }
__declspec(dllexport) int __cdecl QuantifyIsRunning(void) { if(!++avoidGy_42); return 0; }
__declspec(dllexport) int __cdecl QuantifyDisableRecordingData(void) { if(!++avoidGy_43); return 0; }
__declspec(dllexport) int __cdecl QuantifyStartRecordingData(void) { if(!++avoidGy_44); return 0; }
__declspec(dllexport) int __cdecl QuantifyStopRecordingData(void) { if(!++avoidGy_45); return 0; }
__declspec(dllexport) int __cdecl QuantifyClearData(void) { if(!++avoidGy_46); return 0; }
__declspec(dllexport) int __cdecl QuantifyIsRecordingData(void) { if(!++avoidGy_47); return 0; }
__declspec(dllexport) int __cdecl QuantifyAddAnnotation(char *str) { if(!++avoidGy_48); str; return 0; }
__declspec(dllexport) int __cdecl QuantifySaveData(void) { if(!++avoidGy_49); return 0; }
__declspec(dllexport) int __cdecl QuantifySetThreadName(const char *szName) { if(!++avoidGy_50) ; szName; return 0; }
#endif // _WINDOWS

@@ -289,7 +289,7 @@ TEST(TimerTest, OneShotTimer_Cancel) {
} }
// If underline timer does not handle properly, we will crash or fail // If underline timer does not handle properly, we will crash or fail
// in full page heap or purify environment. // in full page heap environment.
TEST(TimerTest, OneShotSelfDeletingTimer) { TEST(TimerTest, OneShotSelfDeletingTimer) {
RunTest_OneShotSelfDeletingTimer(MessageLoop::TYPE_DEFAULT); RunTest_OneShotSelfDeletingTimer(MessageLoop::TYPE_DEFAULT);
RunTest_OneShotSelfDeletingTimer(MessageLoop::TYPE_UI); RunTest_OneShotSelfDeletingTimer(MessageLoop::TYPE_UI);
@@ -337,7 +337,7 @@ TEST(TimerTest, MessageLoopShutdown) {
// This test is designed to verify that shutdown of the // This test is designed to verify that shutdown of the
// message loop does not cause crashes if there were pending // message loop does not cause crashes if there were pending
// timers not yet fired. It may only trigger exceptions // timers not yet fired. It may only trigger exceptions
// if debug heap checking (or purify) is enabled. // if debug heap checking is enabled.
bool did_run = false; bool did_run = false;
{ {
OneShotTimerTester a(&did_run); OneShotTimerTester a(&did_run);

@@ -1221,24 +1221,6 @@
}], }],
], ],
}, },
'Purify_Base': {
'abstract': 1,
'defines': [
'PURIFY',
'NO_TCMALLOC',
],
'msvs_settings': {
'VCCLCompilerTool': {
'Optimization': '0',
'RuntimeLibrary': '0',
'BufferSecurityCheck': 'false',
},
'VCLinkerTool': {
'EnableCOMDATFolding': '1',
'LinkIncremental': '1',
},
},
},
# #
# Concrete configurations # Concrete configurations
# #
@@ -1256,18 +1238,12 @@
'conditions': [ 'conditions': [
[ 'OS=="win"', { [ 'OS=="win"', {
# TODO(bradnelson): add a gyp mechanism to make this more graceful. # TODO(bradnelson): add a gyp mechanism to make this more graceful.
'Purify': {
'inherit_from': ['Common_Base', 'x86_Base', 'Release_Base', 'Purify'],
},
'Debug_x64': { 'Debug_x64': {
'inherit_from': ['Common_Base', 'x64_Base', 'Debug_Base'], 'inherit_from': ['Common_Base', 'x64_Base', 'Debug_Base'],
}, },
'Release_x64': { 'Release_x64': {
'inherit_from': ['Common_Base', 'x64_Base', 'Release_Base'], 'inherit_from': ['Common_Base', 'x64_Base', 'Release_Base'],
}, },
'Purify_x64': {
'inherit_from': ['Common_Base', 'x64_Base', 'Release_Base', 'Purify_Base'],
},
}], }],
], ],
}, },

@@ -13,6 +13,5 @@
# dom_stats # dom_stats
# pgo_instrument # pgo_instrument
# pgo_optimize # pgo_optimize
# purify
], ],
} }

@@ -188,11 +188,6 @@ MainDllLoader::MainDllLoader() : dll_(NULL) {
} }
MainDllLoader::~MainDllLoader() { MainDllLoader::~MainDllLoader() {
#ifdef PURIFY
// We should never unload the dll. There is only risk and no gain from
// doing so. The singleton dtors have been already run by AtExitManager.
::FreeLibrary(dll_);
#endif
} }
// Loading chrome is an interesting affair. First we try loading from the // Loading chrome is an interesting affair. First we try loading from the

@@ -70,7 +70,7 @@ class BookmarkContextMenuControllerTest : public TestingBrowserProcessTest {
BookmarkBarView::testing_ = false; BookmarkBarView::testing_ = false;
#endif #endif
// Flush the message loop to make Purify happy. // Flush the message loop to make application verifiers happy.
message_loop_.RunAllPending(); message_loop_.RunAllPending();
} }

@@ -41,7 +41,7 @@ void RecentlyUsedFoldersComboModelTest::SetUp() {
} }
void RecentlyUsedFoldersComboModelTest::TearDown() { void RecentlyUsedFoldersComboModelTest::TearDown() {
// Flush the message loop to make Purify happy. // Flush the message loop to make application verifiers happy.
message_loop_.RunAllPending(); message_loop_.RunAllPending();
} }

@@ -19,7 +19,7 @@ class NetworkStatsTest : public PlatformTest {
NetworkStatsTest() {} NetworkStatsTest() {}
protected: protected:
virtual void TearDown() { virtual void TearDown() {
// Flush the message loop to make Purify happy. // Flush the message loop to make application verifiers happy.
message_loop_.RunAllPending(); message_loop_.RunAllPending();
} }
MessageLoopForIO message_loop_; MessageLoopForIO message_loop_;

@@ -166,7 +166,7 @@ void TemplateURLServiceTestUtil::TearDown() {
} }
TemplateURLRef::SetGoogleBaseURL(NULL); TemplateURLRef::SetGoogleBaseURL(NULL);
// Flush the message loop to make Purify happy. // Flush the message loop to make application verifiers happy.
message_loop_.RunAllPending(); message_loop_.RunAllPending();
} }

@@ -76,7 +76,7 @@ class BookmarkContextMenuTest : public TestingBrowserProcessTest {
BookmarkBarView::testing_ = false; BookmarkBarView::testing_ = false;
#endif #endif
// Flush the message loop to make Purify happy. // Flush the message loop to make application verifiers happy.
message_loop_.RunAllPending(); message_loop_.RunAllPending();
} }

@@ -352,9 +352,7 @@ void CFUrlRequestUnittestRunner::Initialize() {
SuppressErrorDialogs(); SuppressErrorDialogs();
base::debug::SetSuppressDebugUI(true); base::debug::SetSuppressDebugUI(true);
#if !defined(PURIFY)
logging::SetLogAssertHandler(UnitTestAssertHandler); logging::SetLogAssertHandler(UnitTestAssertHandler);
#endif // !defined(PURIFY)
// Next, do some initialization for NetTestSuite. // Next, do some initialization for NetTestSuite.
NetTestSuite::InitializeTestThread(); NetTestSuite::InitializeTestThread();

@@ -298,7 +298,7 @@ class ResourceDispatcherHostTest : public testing::Test,
ChildProcessSecurityPolicy::GetInstance()->Remove(0); ChildProcessSecurityPolicy::GetInstance()->Remove(0);
// Flush the message loop to make Purify happy. // Flush the message loop to make application verifiers happy.
message_loop_.RunAllPending(); message_loop_.RunAllPending();
} }

@@ -232,5 +232,5 @@ TEST_F(ResolveProxyMsgHelperTest, CancelPendingRequests) {
EXPECT_TRUE(pending_result() == NULL); EXPECT_TRUE(pending_result() == NULL);
// It should also be the case that msg1, msg2, msg3 were deleted by the // It should also be the case that msg1, msg2, msg3 were deleted by the
// cancellation. (Else will show up as a leak in Purify/Valgrind). // cancellation. (Else will show up as a leak in Valgrind).
} }

@@ -238,14 +238,7 @@ TEST(SignatureVerifierTest, BasicTest) {
EXPECT_TRUE(ok); EXPECT_TRUE(ok);
verifier.VerifyUpdate(bad_tbs_certificate, sizeof(bad_tbs_certificate)); verifier.VerifyUpdate(bad_tbs_certificate, sizeof(bad_tbs_certificate));
ok = verifier.VerifyFinal(); ok = verifier.VerifyFinal();
// Purify disables digital signature verification, causing the Windows
// CryptoAPI function CryptVerifySignature to always succeed. So we can't
// check the signature verification results of the negative tests when
// running inside Purify. See http://crbug.com/10031.
#ifndef PURIFY
EXPECT_FALSE(ok); EXPECT_FALSE(ok);
#endif
// Test 4: verify a bad signature. // Test 4: verify a bad signature.
uint8 bad_signature[sizeof(signature)]; uint8 bad_signature[sizeof(signature)];
@@ -261,8 +254,6 @@ TEST(SignatureVerifierTest, BasicTest) {
if (ok) { if (ok) {
verifier.VerifyUpdate(tbs_certificate, sizeof(tbs_certificate)); verifier.VerifyUpdate(tbs_certificate, sizeof(tbs_certificate));
ok = verifier.VerifyFinal(); ok = verifier.VerifyFinal();
#ifndef PURIFY
EXPECT_FALSE(ok); EXPECT_FALSE(ok);
#endif
} }
} }

@@ -286,7 +286,7 @@ class PipelineImplTest : public ::testing::Test {
TEST_F(PipelineImplTest, NotStarted) { TEST_F(PipelineImplTest, NotStarted) {
const base::TimeDelta kZero; const base::TimeDelta kZero;
// StrictMock<> will ensure these never get called, and valgrind/purify will // StrictMock<> will ensure these never get called, and valgrind will
// make sure the callbacks are instantly deleted. // make sure the callbacks are instantly deleted.
pipeline_->Stop(base::Bind(&CallbackHelper::OnStop, pipeline_->Stop(base::Bind(&CallbackHelper::OnStop,
base::Unretained(&callbacks_))); base::Unretained(&callbacks_)));

@@ -584,10 +584,9 @@ void DiskCacheBackendTest::BackendInvalidEntry() {
} }
// This and the other intentionally leaky tests below are excluded from // This and the other intentionally leaky tests below are excluded from
// purify and valgrind runs by naming them in the files // valgrind runs by naming them in the files
// net/data/purify/net_unittests.exe.gtest.txt and
// net/data/valgrind/net_unittests.gtest.txt // net/data/valgrind/net_unittests.gtest.txt
// The scripts tools/{purify,valgrind}/chrome_tests.sh // The scripts tools/valgrind/chrome_tests.sh
// read those files and pass the appropriate --gtest_filter to net_unittests. // read those files and pass the appropriate --gtest_filter to net_unittests.
TEST_F(DiskCacheBackendTest, InvalidEntry) { TEST_F(DiskCacheBackendTest, InvalidEntry) {
BackendInvalidEntry(); BackendInvalidEntry();

@@ -8,7 +8,6 @@
#include "base/basictypes.h" #include "base/basictypes.h"
#include "base/compiler_specific.h" #include "base/compiler_specific.h"
#include "base/memory/memory_debug.h"
#include "base/metrics/stats_counters.h" #include "base/metrics/stats_counters.h"
#include "base/string_util.h" #include "base/string_util.h"
#include "base/win/object_watcher.h" #include "base/win/object_watcher.h"
@@ -690,13 +689,6 @@ int TCPClientSocketWin::Read(IOBuffer* buf,
&core_->read_overlapped_, NULL); &core_->read_overlapped_, NULL);
if (rv == 0) { if (rv == 0) {
if (ResetEventIfSignaled(core_->read_overlapped_.hEvent)) { if (ResetEventIfSignaled(core_->read_overlapped_.hEvent)) {
// Because of how WSARecv fills memory when used asynchronously, Purify
// isn't able to detect that it's been initialized, so it scans for 0xcd
// in the buffer and reports UMRs (uninitialized memory reads) for those
// individual bytes. We override that in PURIFY builds to avoid the
// false error reports.
// See bug 5297.
base::MemoryDebug::MarkAsInitialized(core_->read_buffer_.buf, num);
base::StatsCounter read_bytes("tcp.read_bytes"); base::StatsCounter read_bytes("tcp.read_bytes");
read_bytes.Add(num); read_bytes.Add(num);
num_bytes_read_ += num; num_bytes_read_ += num;

@@ -8,7 +8,6 @@
#include "base/eintr_wrapper.h" #include "base/eintr_wrapper.h"
#include "base/logging.h" #include "base/logging.h"
#include "base/memory/memory_debug.h"
#include "base/message_loop.h" #include "base/message_loop.h"
#include "base/metrics/stats_counters.h" #include "base/metrics/stats_counters.h"
#include "base/rand_util.h" #include "base/rand_util.h"
@@ -324,13 +323,6 @@ int UDPSocketWin::InternalRecvFrom(IOBuffer* buf, int buf_len,
&recv_addr_len_, &read_overlapped_, NULL); &recv_addr_len_, &read_overlapped_, NULL);
if (rv == 0) { if (rv == 0) {
if (ResetEventIfSignaled(read_overlapped_.hEvent)) { if (ResetEventIfSignaled(read_overlapped_.hEvent)) {
// Because of how WSARecv fills memory when used asynchronously, Purify
// isn't able to detect that it's been initialized, so it scans for 0xcd
// in the buffer and reports UMRs (uninitialized memory reads) for those
// individual bytes. We override that in PURIFY builds to avoid the
// false error reports.
// See bug 5297.
base::MemoryDebug::MarkAsInitialized(read_buffer.buf, num);
if (!ProcessSuccessfulRead(num, address)) if (!ProcessSuccessfulRead(num, address))
return ERR_FAILED; return ERR_FAILED;
return static_cast<int>(num); return static_cast<int>(num);

@@ -58,8 +58,7 @@ class HeapcheckWrapper(object):
common.RunSubprocess(proc, self._timeout) common.RunSubprocess(proc, self._timeout)
# Always return true, even if running the subprocess failed. We depend on # Always return true, even if running the subprocess failed. We depend on
# Analyze to determine if the run was valid. (This behaviour copied from # Analyze to determine if the run was valid.
# the purify_test.py script.)
return True return True
def Analyze(self, log_lines, check_sanity=False): def Analyze(self, log_lines, check_sanity=False):

@@ -38,7 +38,7 @@ class AcceleratorHandlerGtkTest
virtual void TearDown() { virtual void TearDown() {
window_->Close(); window_->Close();
// Flush the message loop to make Purify happy. // Flush the message loop to make application verifiers happy.
message_loop_.RunAllPending(); message_loop_.RunAllPending();
} }

@@ -126,7 +126,7 @@ class FocusManagerTest : public testing::Test, public WidgetDelegate {
GetFocusManager()->RemoveFocusChangeListener(focus_change_listener_); GetFocusManager()->RemoveFocusChangeListener(focus_change_listener_);
window_->Close(); window_->Close();
// Flush the message loop to make Purify happy. // Flush the message loop to make application verifiers happy.
message_loop()->RunAllPending(); message_loop()->RunAllPending();
} }

@@ -6,13 +6,6 @@
#include "build/build_config.h" #include "build/build_config.h"
#if defined(QUANTIFY)
// this #define is used to prevent people from directly using pure.h
// instead of profiler.h
#define PURIFY_PRIVATE_INCLUDE
#include "base/third_party/purify/pure.h"
#endif // QUANTIFY
#if defined(USE_TCMALLOC) && defined(OS_POSIX) && !defined(OS_MACOSX) #if defined(USE_TCMALLOC) && defined(OS_POSIX) && !defined(OS_MACOSX)
#include "third_party/tcmalloc/chromium/src/google/profiler.h" #include "third_party/tcmalloc/chromium/src/google/profiler.h"
#endif #endif
@@ -69,9 +62,7 @@ class ProfilerWrapper : public v8::Extension {
static v8::Handle<v8::Value> ProfilerStart( static v8::Handle<v8::Value> ProfilerStart(
const v8::Arguments& args) { const v8::Arguments& args) {
#if defined(QUANTIFY) #if defined(USE_TCMALLOC) && defined(OS_POSIX) && !defined(OS_MACOSX)
QuantifyStartRecordingData();
#elif defined(USE_TCMALLOC) && defined(OS_POSIX) && !defined(OS_MACOSX)
::ProfilerStart("chrome-profile"); ::ProfilerStart("chrome-profile");
#endif #endif
return v8::Undefined(); return v8::Undefined();
@@ -79,9 +70,7 @@ class ProfilerWrapper : public v8::Extension {
static v8::Handle<v8::Value> ProfilerStop( static v8::Handle<v8::Value> ProfilerStop(
const v8::Arguments& args) { const v8::Arguments& args) {
#if defined(QUANTIFY) #if defined(USE_TCMALLOC) && defined(OS_POSIX) && !defined(OS_MACOSX)
QuantifyStopRecordingData();
#elif defined(USE_TCMALLOC) && defined(OS_POSIX) && !defined(OS_MACOSX)
::ProfilerStop(); ::ProfilerStop();
#endif #endif
return v8::Undefined(); return v8::Undefined();
@@ -89,9 +78,6 @@ class ProfilerWrapper : public v8::Extension {
static v8::Handle<v8::Value> ProfilerClearData( static v8::Handle<v8::Value> ProfilerClearData(
const v8::Arguments& args) { const v8::Arguments& args) {
#if defined(QUANTIFY)
QuantifyClearData();
#endif
return v8::Undefined(); return v8::Undefined();
} }
@@ -110,12 +96,6 @@ class ProfilerWrapper : public v8::Extension {
v8::Local<v8::String> inputString = args[0]->ToString(); v8::Local<v8::String> inputString = args[0]->ToString();
char nameBuffer[256]; char nameBuffer[256];
inputString->WriteAscii(nameBuffer, 0, sizeof(nameBuffer)-1); inputString->WriteAscii(nameBuffer, 0, sizeof(nameBuffer)-1);
#if defined(QUANTIFY)
// make a copy since the Quantify function takes a char*, not const char*
char buffer[512];
base::snprintf(buffer, arraysize(buffer)-1, "%s", name);
QuantifySetThreadName(buffer);
#endif
} }
return v8::Undefined(); return v8::Undefined();
} }

@@ -74,7 +74,7 @@ class TestShellTestSuite : public base::TestSuite {
// Some of the individual tests wind up calling TestShell::WaitTestFinished // Some of the individual tests wind up calling TestShell::WaitTestFinished
// which has a timeout in it. For these tests, we don't care about // which has a timeout in it. For these tests, we don't care about
// a timeout so just set it to be really large. This is necessary because // a timeout so just set it to be really large. This is necessary because
// we hit those timeouts under Purify and Valgrind. // we hit those timeouts under Valgrind.
TestShell::SetFileTestTimeout(10 * 60 * 60 * 1000); // Ten hours. TestShell::SetFileTestTimeout(10 * 60 * 60 * 1000); // Ten hours.
// Initialize test shell in layout test mode, which will let us load one // Initialize test shell in layout test mode, which will let us load one

@@ -17,7 +17,6 @@
#include "base/logging.h" #include "base/logging.h"
#include "base/mac/mac_util.h" #include "base/mac/mac_util.h"
#include "base/mac/scoped_nsautorelease_pool.h" #include "base/mac/scoped_nsautorelease_pool.h"
#include "base/memory/memory_debug.h"
#include "base/message_loop.h" #include "base/message_loop.h"
#include "base/path_service.h" #include "base/path_service.h"
#include "base/string16.h" #include "base/string16.h"

@@ -11,7 +11,6 @@
#include "base/file_path.h" #include "base/file_path.h"
#include "base/file_util.h" #include "base/file_util.h"
#include "base/i18n/icu_util.h" #include "base/i18n/icu_util.h"
#include "base/memory/memory_debug.h"
#include "base/message_loop.h" #include "base/message_loop.h"
#include "base/metrics/stats_table.h" #include "base/metrics/stats_table.h"
#include "base/path_service.h" #include "base/path_service.h"
@@ -325,12 +324,6 @@ int main(int argc, char* argv[]) {
base::EventRecorder::current()->StartPlayback(script_path); base::EventRecorder::current()->StartPlayback(script_path);
} }
if (parsed_command_line.HasSwitch(test_shell::kDebugMemoryInUse)) {
base::MemoryDebug::SetMemoryInUseEnabled(true);
// Dump all in use memory at startup
base::MemoryDebug::DumpAllMemoryInUse();
}
webkit_glue::SetJavaScriptFlags(TestShell::GetJSFlagsForLoad(0)); webkit_glue::SetJavaScriptFlags(TestShell::GetJSFlagsForLoad(0));
MessageLoop::current()->Run(); MessageLoop::current()->Run();

@@ -17,10 +17,6 @@ class TestShellPlatformDelegate {
TestShellPlatformDelegate(const CommandLine& command_line); TestShellPlatformDelegate(const CommandLine& command_line);
~TestShellPlatformDelegate(); ~TestShellPlatformDelegate();
// EnableMemoryDebugging: turn on platform memory debugging assistance
// (console messages, heap checking, leak detection, etc.).
void EnableMemoryDebugging();
// CheckLayoutTestSystemDependencies: check for any system dependencies that // CheckLayoutTestSystemDependencies: check for any system dependencies that
// can't be easily overridden from within an application (for example, UI or // can't be easily overridden from within an application (for example, UI or
// display settings). Returns false if any dependencies are not met. // display settings). Returns false if any dependencies are not met.

@@ -58,10 +58,6 @@ const char kDumpStatsTable[] = "stats";
// Use a specified cache directory. // Use a specified cache directory.
const char kCacheDir[] = "cache-dir"; const char kCacheDir[] = "cache-dir";
// When being run through a memory profiler, trigger memory in use dumps at
// startup and just prior to shutdown.
const char kDebugMemoryInUse[] = "debug-memory-in-use";
// Enable cookies on the file:// scheme. --layout-tests also enables this. // Enable cookies on the file:// scheme. --layout-tests also enables this.
const char kEnableFileCookies[] = "enable-file-cookies"; const char kEnableFileCookies[] = "enable-file-cookies";

@@ -25,7 +25,6 @@ extern const char kPlaybackMode[];
extern const char kNoEvents[]; extern const char kNoEvents[];
extern const char kDumpStatsTable[]; extern const char kDumpStatsTable[];
extern const char kCacheDir[]; extern const char kCacheDir[];
extern const char kDebugMemoryInUse[];
extern const char kEnableFileCookies[]; extern const char kEnableFileCookies[];
extern const char kAllowScriptsToCloseWindows[]; extern const char kAllowScriptsToCloseWindows[];
extern const char kCheckLayoutTestSystemDeps[]; extern const char kCheckLayoutTestSystemDeps[];

@@ -13,7 +13,6 @@
#include "base/command_line.h" #include "base/command_line.h"
#include "base/debug/trace_event.h" #include "base/debug/trace_event.h"
#include "base/file_util.h" #include "base/file_util.h"
#include "base/memory/memory_debug.h"
#include "base/message_loop.h" #include "base/message_loop.h"
#include "base/path_service.h" #include "base/path_service.h"
#include "base/resource_util.h" #include "base/resource_util.h"
@@ -567,10 +566,6 @@ LRESULT CALLBACK TestShell::WndProc(HWND hwnd, UINT message, WPARAM wParam,
RemoveWindowFromList(hwnd); RemoveWindowFromList(hwnd);
if (TestShell::windowList()->empty() || shell->is_modal()) { if (TestShell::windowList()->empty() || shell->is_modal()) {
// Dump all in use memory just before shutdown if in use memory
// debugging has been enabled.
base::MemoryDebug::DumpAllMemoryInUse();
MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::current()->PostTask(FROM_HERE,
new MessageLoop::QuitTask()); new MessageLoop::QuitTask());
} }