Collect stability data from global and activity scopes

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 <limits>
+#include <utility>
 
 #include "base/debug/stack_trace.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/pending_task.h"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/platform_thread.h"
 
 namespace base {
@@ skipping 172 matching lines @@
 #else
   activity->call_stack[0] = 0;
 #endif
 }
 
 ActivityUserData::TypedValue::TypedValue() {}
 ActivityUserData::TypedValue::TypedValue(const TypedValue& other) = default;
 ActivityUserData::TypedValue::~TypedValue() {}
 
 StringPiece ActivityUserData::TypedValue::Get() const {
-  DCHECK_EQ(RAW_VALUE, type);
-  return long_value;
+  DCHECK_EQ(RAW_VALUE, type_);
+  return long_value_;
 }
 
 StringPiece ActivityUserData::TypedValue::GetString() const {
-  DCHECK_EQ(STRING_VALUE, type);
-  return long_value;
+  DCHECK_EQ(STRING_VALUE, type_);
+  return long_value_;
 }
 
 bool ActivityUserData::TypedValue::GetBool() const {
-  DCHECK_EQ(BOOL_VALUE, type);
-  return short_value != 0;
+  DCHECK_EQ(BOOL_VALUE, type_);
+  return short_value_ != 0;
 }
 
 char ActivityUserData::TypedValue::GetChar() const {
-  DCHECK_EQ(CHAR_VALUE, type);
-  return static_cast<char>(short_value);
+  DCHECK_EQ(CHAR_VALUE, type_);
+  return static_cast<char>(short_value_);
 }
 
 int64_t ActivityUserData::TypedValue::GetInt() const {
-  DCHECK_EQ(SIGNED_VALUE, type);
-  return static_cast<int64_t>(short_value);
+  DCHECK_EQ(SIGNED_VALUE, type_);
+  return static_cast<int64_t>(short_value_);
 }
 
 uint64_t ActivityUserData::TypedValue::GetUint() const {
-  DCHECK_EQ(UNSIGNED_VALUE, type);
-  return static_cast<uint64_t>(short_value);
+  DCHECK_EQ(UNSIGNED_VALUE, type_);
+  return static_cast<uint64_t>(short_value_);
 }
 
 StringPiece ActivityUserData::TypedValue::GetReference() const {
-  DCHECK_EQ(RAW_VALUE_REFERENCE, type);
-  return ref_value;
+  DCHECK_EQ(RAW_VALUE_REFERENCE, type_);
+  return ref_value_;
 }
 
 StringPiece ActivityUserData::TypedValue::GetStringReference() const {
-  DCHECK_EQ(STRING_VALUE_REFERENCE, type);
-  return ref_value;
+  DCHECK_EQ(STRING_VALUE_REFERENCE, type_);
+  return ref_value_;
 }
 
 ActivityUserData::ValueInfo::ValueInfo() {}
 ActivityUserData::ValueInfo::ValueInfo(ValueInfo&&) = default;
 ActivityUserData::ValueInfo::~ValueInfo() {}
 
 std::atomic<uint32_t> ActivityUserData::next_id_;
 
 ActivityUserData::ActivityUserData(void* memory, size_t size)
     : memory_(reinterpret_cast<char*>(memory)),
@@ skipping 167 matching lines @@
 bool ActivityUserData::CreateSnapshot(Snapshot* output_snapshot) const {
   DCHECK(output_snapshot);
   DCHECK(output_snapshot->empty());
 
   // Find any new data that may have been added by an active instance of this
   // class that is adding records.
   ImportExistingData();
 
   for (const auto& entry : values_) {
     TypedValue value;
-    value.type = entry.second.type;
+    value.type_ = entry.second.type;
     DCHECK_GE(entry.second.extent,
               entry.second.size_ptr->load(std::memory_order_relaxed));
 
     switch (entry.second.type) {
       case RAW_VALUE:
       case STRING_VALUE:
-        value.long_value =
+        value.long_value_ =
             std::string(reinterpret_cast<char*>(entry.second.memory),
                         entry.second.size_ptr->load(std::memory_order_relaxed));
         break;
       case RAW_VALUE_REFERENCE:
       case STRING_VALUE_REFERENCE: {
         ReferenceRecord* ref =
             reinterpret_cast<ReferenceRecord*>(entry.second.memory);
-        value.ref_value = StringPiece(
+        value.ref_value_ = StringPiece(
             reinterpret_cast<char*>(static_cast<uintptr_t>(ref->address)),
             static_cast<size_t>(ref->size));
       } break;
       case BOOL_VALUE:
       case CHAR_VALUE:
-        value.short_value = *reinterpret_cast<char*>(entry.second.memory);
+        value.short_value_ = *reinterpret_cast<char*>(entry.second.memory);
         break;
       case SIGNED_VALUE:
       case UNSIGNED_VALUE:
-        value.short_value = *reinterpret_cast<uint64_t*>(entry.second.memory);
+        value.short_value_ = *reinterpret_cast<uint64_t*>(entry.second.memory);
         break;
       case END_OF_VALUES:  // Included for completeness purposes.
         NOTREACHED();
     }
     auto inserted = output_snapshot->insert(
         std::make_pair(entry.second.name.as_string(), std::move(value)));
     DCHECK(inserted.second);  // True if inserted, false if existed.
   }
 
   return true;
@@ skipping 741 matching lines @@
     : GlobalActivityTracker::ScopedThreadActivity(
           program_counter,
           nullptr,
           Activity::ACT_PROCESS_WAIT,
           ActivityData::ForProcess(process->Pid()),
           /*lock_allowed=*/true) {}
 #endif
 
 }  // namespace debug
 }  // namespace base