Store log messages in global activity tracker.

base/debug/activity_tracker.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/debug/activity_tracker.h"
 
 #include <algorithm>
 
 #include "base/debug/stack_trace.h"
 #include "base/files/file.h"
@@ skipping 840 matching lines @@
 }
 
 void GlobalActivityTracker::ReleaseUserDataMemory(
     PersistentMemoryAllocator::Reference* reference) {
   DCHECK(*reference);
   base::AutoLock autolock(user_data_allocator_lock_);
   user_data_allocator_.ReleaseObjectReference(*reference);
   *reference = PersistentMemoryAllocator::kReferenceNull;
 }
 
+void GlobalActivityTracker::RecordLogMessage(StringPiece message) {
+  PersistentMemoryAllocator::Reference ref =

[manzagop (departed), 2016/12/02 19:10:41]

Wdyt of setting a max size that we'll truncate to? Even though we only log fatal
messages, we want to make sure the message 1) fits 2) doesn't blow too much
space if there's something else to log.

[bcwhite, 2016/12/02 19:28:07]

If it's somehow too big, the allocation will fail and GetAsArray will return
NULL.

Since right now it's only the browser that has the tracker enabled, there should
only be one and it'll be the last thing going in.  We may have to restrict it
(and/or reuse it) once this extends to other processes.

[manzagop (departed), 2016/12/02 20:08:09]

Yeah, the worry is if it's too big then you get nothing. It would need to rely
on some kind of "best effort allocation" (you asked for X but I only have Y,
here they are).

[bcwhite, 2016/12/02 20:16:30]

Somewhat related:  You should report the IsFull() flag of the allocator in your
data upload.  If true, any kind of information could be missing, including
thread activities.

That flag is persistent and is set if any allocation fails for being too big for
the remaining space.

[manzagop (departed), 2016/12/02 20:50:09]

Thanks for the heads up! Added to the list.

+      allocator_->Allocate(message.size() + 1, kTypeIdGlobalLogMessage);

[manzagop (departed), 2016/12/02 19:10:41]

The extra character is to ensure null termination, and we know the memory we get
is already null, right? Worth mentioning or is that a property of Allocate?

[bcwhite, 2016/12/02 19:28:07]

Done.

+  char* memory = allocator_->GetAsArray<char>(ref, kTypeIdGlobalLogMessage,
+                                              message.size() + 1);
+  if (memory) {
+    memcpy(memory, message.data(), message.size());
+    allocator_->MakeIterable(ref);
+  }
+}
+
 GlobalActivityTracker::GlobalActivityTracker(
     std::unique_ptr<PersistentMemoryAllocator> allocator,
     int stack_depth)
     : allocator_(std::move(allocator)),
       stack_memory_size_(ThreadActivityTracker::SizeForStackDepth(stack_depth)),
       this_thread_tracker_(&OnTLSDestroy),
       thread_tracker_count_(0),
       thread_tracker_allocator_(allocator_.get(),
                                 kTypeIdActivityTracker,
                                 kTypeIdActivityTrackerFree,
@@ skipping 126 matching lines @@
     : GlobalActivityTracker::ScopedThreadActivity(
           program_counter,
           nullptr,
           Activity::ACT_PROCESS_WAIT,
           ActivityData::ForProcess(process->Pid()),
           /*lock_allowed=*/true) {}
 #endif
 
 }  // namespace debug
 }  // namespace base