[Fuchsia] Grab the number of malloc'd bytes from jemalloc

runtime/vm/malloc_hooks_tcmalloc.cc

 // Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 
-#if defined(DART_USE_TCMALLOC) && !defined(PRODUCT) &&                         \
-    !defined(TARGET_ARCH_DBC) && !defined(HOST_OS_FUCHSIA)
+#if defined(DART_USE_TCMALLOC) && !defined(PRODUCT) && !defined(TARGET_ARCH_DBC)
 
 #include "vm/malloc_hooks.h"
 
 #include "gperftools/malloc_hook.h"
 
 #include "platform/assert.h"
 #include "vm/hash_map.h"
 #include "vm/json_stream.h"
 #include "vm/os_thread.h"
 #include "vm/profiler.h"
@@ skipping 236 matching lines @@
   ASSERT(malloc_hook_mutex()->IsOwnedByCurrentThread());
   active_ = false;
   original_pid_ = kInvalidPid;
   ResetStats();
   delete address_map_;
   address_map_ = NULL;
 }
 
 
 void MallocHooks::InitOnce() {
-  if (!FLAG_enable_malloc_hooks || MallocHooks::Active()) {
+  if (!FLAG_profiler_native_memory || MallocHooks::Active()) {
     return;
   }
   MallocLocker ml(MallocHooksState::malloc_hook_mutex(),
                   MallocHooksState::malloc_hook_mutex_owner());
   ASSERT(!MallocHooksState::Active());
 
   MallocHooksState::Init();
 
   // Register malloc hooks.
   bool success = false;
   success = MallocHook::AddNewHook(&MallocHooksState::RecordAllocHook);
   ASSERT(success);
   success = MallocHook::AddDeleteHook(&MallocHooksState::RecordFreeHook);
   ASSERT(success);
 }
 
 
 void MallocHooks::TearDown() {
-  if (!FLAG_enable_malloc_hooks || !MallocHooks::Active()) {
+  if (!FLAG_profiler_native_memory || !MallocHooks::Active()) {
     return;
   }
   MallocLocker ml(MallocHooksState::malloc_hook_mutex(),
                   MallocHooksState::malloc_hook_mutex_owner());
   ASSERT(MallocHooksState::Active());
 
   // Remove malloc hooks.
   bool success = false;
   success = MallocHook::RemoveNewHook(&MallocHooksState::RecordAllocHook);
   ASSERT(success);
@@ skipping 17 matching lines @@
 
 
 void MallocHooks::set_stack_trace_collection_enabled(bool enabled) {
   MallocLocker ml(MallocHooksState::malloc_hook_mutex(),
                   MallocHooksState::malloc_hook_mutex_owner());
   MallocHooksState::set_stack_trace_collection_enabled(enabled);
 }
 
 
 void MallocHooks::ResetStats() {
-  if (!FLAG_enable_malloc_hooks) {
+  if (!FLAG_profiler_native_memory) {
     return;
   }
   MallocLocker ml(MallocHooksState::malloc_hook_mutex(),
                   MallocHooksState::malloc_hook_mutex_owner());
   if (MallocHooksState::Active()) {
     MallocHooksState::ResetStats();
   }
 }
 
 
 bool MallocHooks::Active() {
-  if (!FLAG_enable_malloc_hooks) {
+  if (!FLAG_profiler_native_memory) {
     return false;
   }
   MallocLocker ml(MallocHooksState::malloc_hook_mutex(),
                   MallocHooksState::malloc_hook_mutex_owner());
 
   return MallocHooksState::Active();
 }
 
 
 void MallocHooks::PrintToJSONObject(JSONObject* jsobj) {
-  if (!FLAG_enable_malloc_hooks) {
+  if (!FLAG_profiler_native_memory) {
     return;
   }
   intptr_t allocated_memory = 0;
   intptr_t allocation_count = 0;
   bool add_usage = false;
   // AddProperty may call malloc which would result in an attempt
   // to acquire the lock recursively so we extract the values first
   // and then add the JSON properties.
   {
     MallocLocker ml(MallocHooksState::malloc_hook_mutex(),
                     MallocHooksState::malloc_hook_mutex_owner());
     if (MallocHooksState::Active()) {
       allocated_memory = MallocHooksState::heap_allocated_memory_in_bytes();
       allocation_count = MallocHooksState::allocation_count();
       add_usage = true;
     }
   }
   if (add_usage) {
     jsobj->AddProperty("_heapAllocatedMemoryUsage", allocated_memory);
     jsobj->AddProperty("_heapAllocationCount", allocation_count);
   }
 }
 
 
 intptr_t MallocHooks::allocation_count() {
-  if (!FLAG_enable_malloc_hooks) {
+  if (!FLAG_profiler_native_memory) {
     return 0;
   }
   MallocLocker ml(MallocHooksState::malloc_hook_mutex(),
                   MallocHooksState::malloc_hook_mutex_owner());
   return MallocHooksState::allocation_count();
 }
 
 
 intptr_t MallocHooks::heap_allocated_memory_in_bytes() {
-  if (!FLAG_enable_malloc_hooks) {
+  if (!FLAG_profiler_native_memory) {
     return 0;
   }
   MallocLocker ml(MallocHooksState::malloc_hook_mutex(),
                   MallocHooksState::malloc_hook_mutex_owner());
   return MallocHooksState::heap_allocated_memory_in_bytes();
 }
 
 
 Sample* MallocHooks::GetSample(const void* ptr) {
   MallocLocker ml(MallocHooksState::malloc_hook_mutex(),
@@ skipping 47 matching lines @@
       ASSERT(result);
       delete allocation_info;
     }
   }
 }
 
 }  // namespace dart
 
 #endif  // defined(DART_USE_TCMALLOC) && !defined(PRODUCT) &&
         // !defined(TARGET_ARCH_DBC) && !defined(HOST_OS_FUCHSIA)