chromium/src
0
Fork 0
Code Activity

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

Browse Source 
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

5
base/base.gypi

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

54
base/memory/memory_debug.cc

@ -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

48
base/memory/memory_debug.h

@ -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_

3
base/memory/singleton_unittest.cc

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

5
base/message_loop.cc

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

2
base/metrics/field_trial_unittest.cc

@ -40,7 +40,7 @@ class FieldTrialTest : public testing::Test {
};
// 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) {
const char* name1 = "name 1 test";
const char* name2 = "name 2 test";

2
base/pickle.cc

@ -394,7 +394,7 @@ char* Pickle::BeginWrite(size_t 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.
if (length % sizeof(uint32))
memset(dest + length, 0, sizeof(uint32) - (length % sizeof(uint32)));

2
base/third_party/purify/LICENSE vendored

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

2
base/third_party/purify/README.chromium vendored

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

145
base/third_party/purify/pure.h vendored

@ -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)

152
base/third_party/purify/pure_api.c vendored

@ -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

4
base/timer_unittest.cc

@ -289,7 +289,7 @@ TEST(TimerTest, OneShotTimer_Cancel) {
}
// 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) {
RunTest_OneShotSelfDeletingTimer(MessageLoop::TYPE_DEFAULT);
RunTest_OneShotSelfDeletingTimer(MessageLoop::TYPE_UI);
@ -337,7 +337,7 @@ TEST(TimerTest, MessageLoopShutdown) {
// This test is designed to verify that shutdown of the
// message loop does not cause crashes if there were pending
// 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;
{
OneShotTimerTester a(&did_run);

24
build/common.gypi

@ -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
#
@ -1256,18 +1238,12 @@
'conditions': [
[ 'OS=="win"', {
# TODO(bradnelson): add a gyp mechanism to make this more graceful.
'Purify': {
'inherit_from': ['Common_Base', 'x86_Base', 'Release_Base', 'Purify'],
},
'Debug_x64': {
'inherit_from': ['Common_Base', 'x64_Base', 'Debug_Base'],
},
'Release_x64': {
'inherit_from': ['Common_Base', 'x64_Base', 'Release_Base'],
},
'Purify_x64': {
'inherit_from': ['Common_Base', 'x64_Base', 'Release_Base', 'Purify_Base'],
},
}],
],
},

1
build/release.gypi

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

5
chrome/app/client_util.cc

@ -188,11 +188,6 @@ MainDllLoader::MainDllLoader() : dll_(NULL) {
}
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

2
chrome/browser/bookmarks/bookmark_context_menu_controller_unittest.cc

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

2
chrome/browser/bookmarks/recently_used_folders_combo_model_unittest.cc

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

2
chrome/browser/net/network_stats_unittest.cc

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

2
chrome/browser/search_engines/template_url_service_test_util.cc

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

2
chrome/browser/ui/views/bookmarks/bookmark_context_menu_test.cc

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

2
chrome_frame/test/net/fake_external_tab.cc

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

2
content/browser/renderer_host/resource_dispatcher_host_unittest.cc

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

2
content/browser/resolve_proxy_msg_helper_unittest.cc

@ -232,5 +232,5 @@ TEST_F(ResolveProxyMsgHelperTest, CancelPendingRequests) {
EXPECT_TRUE(pending_result() == NULL);
// 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).
}

9
crypto/signature_verifier_unittest.cc

@ -238,14 +238,7 @@ TEST(SignatureVerifierTest, BasicTest) {
EXPECT_TRUE(ok);
verifier.VerifyUpdate(bad_tbs_certificate, sizeof(bad_tbs_certificate));
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);
#endif
// Test 4: verify a bad signature.
uint8 bad_signature[sizeof(signature)];
@ -261,8 +254,6 @@ TEST(SignatureVerifierTest, BasicTest) {
if (ok) {
verifier.VerifyUpdate(tbs_certificate, sizeof(tbs_certificate));
ok = verifier.VerifyFinal();
#ifndef PURIFY
EXPECT_FALSE(ok);
#endif
}
}

2
media/base/pipeline_impl_unittest.cc

@ -286,7 +286,7 @@ class PipelineImplTest : public ::testing::Test {
TEST_F(PipelineImplTest, NotStarted) {
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.
pipeline_->Stop(base::Bind(&CallbackHelper::OnStop,
base::Unretained(&callbacks_)));

5
net/disk_cache/backend_unittest.cc

@ -584,10 +584,9 @@ void DiskCacheBackendTest::BackendInvalidEntry() {
}
// This and the other intentionally leaky tests below are excluded from
// purify and valgrind runs by naming them in the files
// net/data/purify/net_unittests.exe.gtest.txt and
// valgrind runs by naming them in the files
// 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.
TEST_F(DiskCacheBackendTest, InvalidEntry) {
BackendInvalidEntry();

8
net/socket/tcp_client_socket_win.cc

@ -8,7 +8,6 @@
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/memory/memory_debug.h"
#include "base/metrics/stats_counters.h"
#include "base/string_util.h"
#include "base/win/object_watcher.h"
@ -690,13 +689,6 @@ int TCPClientSocketWin::Read(IOBuffer* buf,
&core_->read_overlapped_, NULL);
if (rv == 0) {
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");
read_bytes.Add(num);
num_bytes_read_ += num;

8
net/udp/udp_socket_win.cc

@ -8,7 +8,6 @@
#include "base/eintr_wrapper.h"
#include "base/logging.h"
#include "base/memory/memory_debug.h"
#include "base/message_loop.h"
#include "base/metrics/stats_counters.h"
#include "base/rand_util.h"
@ -324,13 +323,6 @@ int UDPSocketWin::InternalRecvFrom(IOBuffer* buf, int buf_len,
&recv_addr_len_, &read_overlapped_, NULL);
if (rv == 0) {
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))
return ERR_FAILED;
return static_cast<int>(num);

3
tools/heapcheck/heapcheck_test.py

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

2
views/focus/accelerator_handler_gtk_unittest.cc

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

2
views/focus/focus_manager_unittest.cc

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

24
webkit/extensions/v8/profiler_extension.cc

@ -6,13 +6,6 @@
#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)
#include "third_party/tcmalloc/chromium/src/google/profiler.h"
#endif
@ -69,9 +62,7 @@ class ProfilerWrapper : public v8::Extension {
static v8::Handle<v8::Value> ProfilerStart(
const v8::Arguments& args) {
#if defined(QUANTIFY)
QuantifyStartRecordingData();
#elif defined(USE_TCMALLOC) && defined(OS_POSIX) && !defined(OS_MACOSX)
#if defined(USE_TCMALLOC) && defined(OS_POSIX) && !defined(OS_MACOSX)
::ProfilerStart("chrome-profile");
#endif
return v8::Undefined();
@ -79,9 +70,7 @@ class ProfilerWrapper : public v8::Extension {
static v8::Handle<v8::Value> ProfilerStop(
const v8::Arguments& args) {
#if defined(QUANTIFY)
QuantifyStopRecordingData();
#elif defined(USE_TCMALLOC) && defined(OS_POSIX) && !defined(OS_MACOSX)
#if defined(USE_TCMALLOC) && defined(OS_POSIX) && !defined(OS_MACOSX)
::ProfilerStop();
#endif
return v8::Undefined();
@ -89,9 +78,6 @@ class ProfilerWrapper : public v8::Extension {
static v8::Handle<v8::Value> ProfilerClearData(
const v8::Arguments& args) {
#if defined(QUANTIFY)
QuantifyClearData();
#endif
return v8::Undefined();
}
@ -110,12 +96,6 @@ class ProfilerWrapper : public v8::Extension {
v8::Local<v8::String> inputString = args[0]->ToString();
char nameBuffer[256];
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();
}

2
webkit/tools/test_shell/run_all_tests.cc

@ -74,7 +74,7 @@ class TestShellTestSuite : public base::TestSuite {
// Some of the individual tests wind up calling TestShell::WaitTestFinished
// 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
// we hit those timeouts under Purify and Valgrind.
// we hit those timeouts under Valgrind.
TestShell::SetFileTestTimeout(10 * 60 * 60 * 1000); // Ten hours.
// Initialize test shell in layout test mode, which will let us load one

1
webkit/tools/test_shell/test_shell_mac.mm

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

7
webkit/tools/test_shell/test_shell_main.cc

@ -11,7 +11,6 @@
#include "base/file_path.h"
#include "base/file_util.h"
#include "base/i18n/icu_util.h"
#include "base/memory/memory_debug.h"
#include "base/message_loop.h"
#include "base/metrics/stats_table.h"
#include "base/path_service.h"
@ -325,12 +324,6 @@ int main(int argc, char* argv[]) {
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));
MessageLoop::current()->Run();

4
webkit/tools/test_shell/test_shell_platform_delegate.h

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

4
webkit/tools/test_shell/test_shell_switches.cc

@ -58,10 +58,6 @@ const char kDumpStatsTable[] = "stats";
// Use a specified cache directory.
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.
const char kEnableFileCookies[] = "enable-file-cookies";

1
webkit/tools/test_shell/test_shell_switches.h

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

5
webkit/tools/test_shell/test_shell_win.cc

@ -13,7 +13,6 @@
#include "base/command_line.h"
#include "base/debug/trace_event.h"
#include "base/file_util.h"
#include "base/memory/memory_debug.h"
#include "base/message_loop.h"
#include "base/path_service.h"
#include "base/resource_util.h"
@ -567,10 +566,6 @@ LRESULT CALLBACK TestShell::WndProc(HWND hwnd, UINT message, WPARAM wParam,
RemoveWindowFromList(hwnd);
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,
new MessageLoop::QuitTask());
}