[tracing] Set whitelist values for dump provider supporting background mode

base/trace_event/memory_infra_background_whitelist.cc

 // Copyright 2016 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/trace_event/memory_infra_background_whitelist.h"
 
 #include <ctype.h>
 #include <string.h>
 
 #include <string>
 
 namespace base {
 namespace trace_event {
 namespace {
 
 // The names of dump providers whitelisted for background tracing. Dump
 // providers can be added here only if the background mode dump has very
 // less performance and memory overhead.
 const char* const kDumpProviderWhitelist[] = {
-    // TODO(ssid): Fill this list with dump provider names which support
-    // background mode, crbug.com/613198.
+    "BlinkGC",
+    "ChildDiscardableSharedMemoryManager",
+    "DOMStorage",
+    "HostDiscardableSharedMemoryManager",
+    "IndexedDBBackingStore",
+    "JavaHeap",
+    "LeveldbValueStore",
+    "Malloc",
+    "PartitionAlloc",
+    "ProcessMemoryMetrics",
+    "Skia",
+    "Sql",
+    "V8Isolate",
+    "WinHeap",
     nullptr  // End of list marker.
 };
 
 // A list of string names that are allowed for the memory allocator dumps in
 // background mode.
 const char* const kAllocatorDumpNameWhitelist[] = {
-    // TODO(ssid): Fill this list with dump names, crbug.com/613198.
+    "blink_gc",
+    "blink_gc/allocated_objects",
+    "discardable",
+    "discardable/child_",
+    "dom_storage/cache_size",
+    "dom_storage/session_storage_",
+    "javaheap",
+    "javaheap/allocated_objects",
+    "leveldb/index_db/",
+    "leveldb/value_store/Extensions.Database.Open.Settings/",
+    "leveldb/value_store/Extensions.Database.Open.Rules/",
+    "leveldb/value_store/Extensions.Database.Open.State/",
+    "leveldb/value_store/Extensions.Database.Open/",
+    "leveldb/value_store/Extensions.Database.Restore/",
+    "leveldb/value_store/Extensions.Database.Value.Restore/",
+    "malloc",
+    "malloc/allocated_objects",
+    "malloc/metadata_fragmentation_caches",
+    "partition_alloc/allocated_objects",
+    "partition_alloc/partitions",
+    "partition_alloc/partitions/buffer",
+    "partition_alloc/partitions/fast_malloc",
+    "partition_alloc/partitions/layout",
+    "skia/sk_glyph_cache",
+    "skia/sk_resource_cache",
+    "sqlite",
+    "v/isolate_/heap_spaces",
+    "v/isolate_/heap_spaces/code_space",
+    "v/isolate_/heap_spaces/large_object_space",
+    "v/isolate_/heap_spaces/map_space",
+    "v/isolate_/heap_spaces/new_space",
+    "v/isolate_/heap_spaces/old_space",
+    "v/isolate_/heap_spaces/other_spaces",
+    "v/isolate_/malloc",
+    "v/isolate_/zapped_for_debug",
+    "winheap",
+    "winheap/allocated_objects",
     nullptr  // End of list marker.
 };
 
 const char* const* g_dump_provider_whitelist = kDumpProviderWhitelist;
 const char* const* g_allocator_dump_name_whitelist =
     kAllocatorDumpNameWhitelist;
 
 }  // namespace
 
 bool IsMemoryDumpProviderWhitelisted(const char* mdp_name) {
   for (size_t i = 0; g_dump_provider_whitelist[i] != nullptr; ++i) {
     if (strcmp(mdp_name, g_dump_provider_whitelist[i]) == 0)
       return true;
   }
   return false;
 }
 
 bool IsMemoryAllocatorDumpNameWhitelisted(const std::string& name) {
   // Remove special characters, numbers (including hexadecimal which are marked
   // by '0x') from the given string.
   const size_t length = name.size();
   std::string stripped_str;
   stripped_str.reserve(length);
   bool parsing_hex = false;
   for (size_t i = 0; i < length; ++i) {
     if (parsing_hex) {

[Primiano Tucci (use gerrit), 2016/06/09 18:11:59]

Sorry for the back an forths, trying to make this more easy to read and
maintain.
1) Do you really need to strip digits (on top of 0xpointers?) It doesn't seem to
be the case here. I'll defer that until we need it.
2) Can we make this more explicit and easy to read as follows:

for (i...)
   if (parsing_hex && isxdigit())
     continue
   parsing_hex = false;
    if (i + 1 < length && name[i] == '0' && name[i + 1] == 'x') {
      parsing_hex = true;
       push_back("0x?")
    } else {
     push_back(name[i])
     }

In this way:
- v8 will stay as v8
- the whitelist of the isolate will be less obscure, as it will look like
v8/isolate_0x?/...
- you don't have the double // problem on leveldb

WDYT?

[ssid, 2016/06/09 22:23:13]

No problem I was expecting suggestion on this.
Yeah I had to strip digits before I fixed dump providers for background mode.
Discardable was adding numbers.
Yeah makes sense, I do not have to worry about double puncts in the strings.
thanks, changed.

       if (isxdigit(name[i])) {
         continue;
       } else {
         parsing_hex = false;
       }
     }
     if (i + 1 < length && name[i] == '0' && name[i + 1] == 'x') {
       parsing_hex = true;
       ++i;
-    } else if (isalpha(name[i]) ||
-               (name[i] == '/' && stripped_str.back() != '/')) {
+    } else if (isalpha(name[i]) || ((ispunct(name[i]) || isblank(name[i])) &&
+                                    stripped_str.back() != '/')) {
       // Do not add successive '/'(s) in |stripped_str|.
       stripped_str.push_back(name[i]);
     }
   }
 
   for (size_t i = 0; g_allocator_dump_name_whitelist[i] != nullptr; ++i) {
     if (stripped_str == g_allocator_dump_name_whitelist[i]) {
       return true;
     }
   }
   return false;
 }
 
 void SetDumpProviderWhitelistForTesting(const char* const* list) {
   g_dump_provider_whitelist = list;
 }
 
 void SetAllocatorDumpNameWhitelistForTesting(const char* const* list) {
   g_allocator_dump_name_whitelist = list;
 }
 
 }  // namespace trace_event
 }  // namespace base