[PM] Implement NodeDataDescriber for V8ContextTracker.

This add context counts and surfaces them in the description.

BUG=1085129

Change-Id: Ifd07af7d08e512fc213d19f4656835243b6b079c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2446095
Commit-Queue: Joe Mason <joenotcharles@chromium.org>
Reviewed-by: Joe Mason <joenotcharles@chromium.org>
Cr-Commit-Position: refs/heads/master@{#816691}

components/performance_manager/v8_memory/v8_context_tracker.cc

@@ -12,6 +12,8 @@
 namespace performance_manager {
 namespace v8_memory {
 
+using ProcessData = internal::ProcessData;
+
 ////////////////////////////////////////////////////////////////////////////////
 // V8ContextTracker::ExecutionContextState implementation:
 
@@ -91,24 +93,54 @@ void V8ContextTracker::OnTakenFromGraph(Graph* graph) {
 base::Value V8ContextTracker::DescribeFrameNodeData(
     const FrameNode* node) const {
   DCHECK_ON_GRAPH_SEQUENCE(node->GetGraph());
+
+  size_t v8_context_count = 0;
+  const auto* ec_data =
+      data_store_->Get(blink::ExecutionContextToken(node->GetFrameToken()));
+  if (ec_data)
+    v8_context_count = ec_data->v8_context_count();
+
   base::Value dict(base::Value::Type::DICTIONARY);
-  // TODO(chrisha): Implement me.
+  dict.SetIntKey("v8_context_count", v8_context_count);
   return dict;
 }
 
 base::Value V8ContextTracker::DescribeProcessNodeData(
     const ProcessNode* node) const {
   DCHECK_ON_GRAPH_SEQUENCE(node->GetGraph());
+
+  size_t v8_context_count = 0;
+  size_t detached_v8_context_count = 0;
+  size_t execution_context_count = 0;
+  size_t destroyed_execution_context_count = 0;
+  const auto* process_data = ProcessData::Get(ProcessNodeImpl::FromNode(node));
+  if (process_data) {
+    v8_context_count = process_data->GetV8ContextDataCount();
+    detached_v8_context_count = process_data->GetDetachedV8ContextDataCount();
+    execution_context_count = process_data->GetExecutionContextDataCount();
+    destroyed_execution_context_count =
+        process_data->GetDestroyedExecutionContextDataCount();
+  }
+
   base::Value dict(base::Value::Type::DICTIONARY);
-  // TODO(chrisha): Implement me.
+  dict.SetIntKey("v8_context_count", v8_context_count);
+  dict.SetIntKey("detached_v8_context_count", detached_v8_context_count);
+  dict.SetIntKey("execution_context_count", execution_context_count);
+  dict.SetIntKey("destroyed_execution_context_count",
+                 destroyed_execution_context_count);
   return dict;
 }
 
 base::Value V8ContextTracker::DescribeWorkerNodeData(
     const WorkerNode* node) const {
-  DCHECK_ON_GRAPH_SEQUENCE(node->GetGraph());
+  size_t v8_context_count = 0;
+  const auto* ec_data =
+      data_store_->Get(ToExecutionContextToken(node->GetWorkerToken()));
+  if (ec_data)
+    v8_context_count = ec_data->v8_context_count();
+
   base::Value dict(base::Value::Type::DICTIONARY);
-  // TODO(chrisha): Implement me.
+  dict.SetIntKey("v8_context_count", v8_context_count);
   return dict;
 }
 

components/performance_manager/v8_memory/v8_context_tracker_helpers.cc

@@ -178,5 +178,21 @@ base::Optional<bool> ExpectIframeAttributionDataForV8ContextDescription(
   return false;
 }
 
+void MarkedObjectCount::Mark() {
+  DCHECK_LT(marked_count_, count_);
+  ++marked_count_;
+}
+
+void MarkedObjectCount::Decrement(bool marked) {
+  DCHECK_LT(0u, count_);
+  if (marked) {
+    DCHECK_LT(0u, marked_count_);
+    --marked_count_;
+  } else {
+    DCHECK_LT(marked_count_, count_);
+  }
+  --count_;
+}
+
 }  // namespace v8_memory
 }  // namespace performance_manager

components/performance_manager/v8_memory/v8_context_tracker_helpers.h

@@ -78,6 +78,61 @@ base::Optional<bool> ExpectIframeAttributionDataForV8ContextDescription(
     const V8ContextDescription& description,
     Graph* graph) WARN_UNUSED_RESULT;
 
+// Small helper class for maintaining a count of objects that are optionally
+// "marked".
+class MarkedObjectCount {
+ public:
+  MarkedObjectCount() = default;
+  MarkedObjectCount(const MarkedObjectCount&) = delete;
+  MarkedObjectCount& operator=(const MarkedObjectCount&) = delete;
+  ~MarkedObjectCount() = default;
+
+  size_t count() const { return count_; }
+  size_t marked_count() const { return marked_count_; }
+
+  void Increment() { ++count_; }
+  void Mark();
+  void Decrement(bool marked);
+
+ private:
+  size_t marked_count_ = 0;
+  size_t count_ = 0;
+};
+
+// Helper class for maintaining a pair of context counts for both
+// ExecutionContexts and V8Contexts.
+class ContextCounts {
+ public:
+  ContextCounts() = default;
+  ContextCounts(const ContextCounts&) = delete;
+  ContextCounts& operator=(const ContextCounts&) = delete;
+  ~ContextCounts() = default;
+
+  size_t GetExecutionContextDataCount() const { return ec_count_.count(); }
+  size_t GetDestroyedExecutionContextDataCount() const {
+    return ec_count_.marked_count();
+  }
+  void IncrementExecutionContextDataCount() { ec_count_.Increment(); }
+  void MarkExecutionContextDataDestroyed() { ec_count_.Mark(); }
+  void DecrementExecutionContextDataCount(bool destroyed) {
+    ec_count_.Decrement(destroyed);
+  }
+
+  size_t GetV8ContextDataCount() const { return v8_count_.count(); }
+  size_t GetDetachedV8ContextDataCount() const {
+    return v8_count_.marked_count();
+  }
+  void IncrementV8ContextDataCount() { v8_count_.Increment(); }
+  void MarkV8ContextDataDetached() { v8_count_.Mark(); }
+  void DecrementV8ContextDataCount(bool detached) {
+    v8_count_.Decrement(detached);
+  }
+
+ private:
+  MarkedObjectCount ec_count_;
+  MarkedObjectCount v8_count_;
+};
+
 }  // namespace v8_memory
 }  // namespace performance_manager
 

components/performance_manager/v8_memory/v8_context_tracker_internal.cc

@@ -60,6 +60,13 @@ bool ExecutionContextData::DecrementV8ContextCount(
   return ShouldDestroy();
 }
 
+bool ExecutionContextData::MarkDestroyed(util::PassKey<ProcessData>) {
+  if (destroyed)
+    return false;
+  destroyed = true;
+  return true;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // RemoteFrameData implementation:
 
@@ -128,6 +135,13 @@ ExecutionContextData* V8ContextData::GetExecutionContextData() const {
   return static_cast<ExecutionContextData*>(execution_context_state);
 }
 
+bool V8ContextData::MarkDetached(util::PassKey<ProcessData>) {
+  if (detached)
+    return false;
+  detached = true;
+  return true;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ProcessData implementation:
 
@@ -181,6 +195,7 @@ void ProcessData::Add(util::PassKey<V8ContextTrackerDataStore>,
   DCHECK(!ec_data->ShouldDestroy());
   DCHECK(!ec_data->IsTracked());
   execution_context_datas_.Append(ec_data);
+  counts_.IncrementExecutionContextDataCount();
 }
 
 void ProcessData::Add(util::PassKey<V8ContextTrackerDataStore>,
@@ -197,6 +212,7 @@ void ProcessData::Add(util::PassKey<V8ContextTrackerDataStore>,
   DCHECK_EQ(this, v8_data->process_data());
   DCHECK(!v8_data->IsTracked());
   v8_context_datas_.Append(v8_data);
+  counts_.IncrementV8ContextDataCount();
 }
 
 void ProcessData::Remove(util::PassKey<V8ContextTrackerDataStore>,
@@ -205,6 +221,7 @@ void ProcessData::Remove(util::PassKey<V8ContextTrackerDataStore>,
   DCHECK_EQ(this, ec_data->process_data());
   DCHECK(ec_data->IsTracked());
   DCHECK(ec_data->ShouldDestroy());
+  counts_.DecrementExecutionContextDataCount(ec_data->destroyed);
   ec_data->RemoveFromList();
 }
 
@@ -221,9 +238,26 @@ void ProcessData::Remove(util::PassKey<V8ContextTrackerDataStore>,
   DCHECK(v8_data);
   DCHECK_EQ(this, v8_data->process_data());
   DCHECK(v8_data->IsTracked());
+  counts_.DecrementV8ContextDataCount(v8_data->detached);
   v8_data->RemoveFromList();
 }
 
+bool ProcessData::MarkDestroyed(util::PassKey<V8ContextTrackerDataStore>,
+                                ExecutionContextData* ec_data) {
+  bool result = ec_data->MarkDestroyed(PassKey());
+  if (result)
+    counts_.MarkExecutionContextDataDestroyed();
+  return result;
+}
+
+bool ProcessData::MarkDetached(util::PassKey<V8ContextTrackerDataStore>,
+                               V8ContextData* v8_data) {
+  bool result = v8_data->MarkDetached(PassKey());
+  if (result)
+    counts_.MarkV8ContextDataDetached();
+  return result;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // V8ContextTrackerDataStore implementation:
 
@@ -281,11 +315,35 @@ V8ContextData* V8ContextTrackerDataStore::Get(
   return it->get();
 }
 
+void V8ContextTrackerDataStore::MarkDestroyed(ExecutionContextData* ec_data) {
+  DCHECK(ec_data);
+  if (ec_data->process_data()->MarkDestroyed(PassKey(), ec_data)) {
+    DCHECK_LT(destroyed_execution_context_count_,
+              global_execution_context_datas_.size());
+    ++destroyed_execution_context_count_;
+  }
+}
+
+void V8ContextTrackerDataStore::MarkDetached(V8ContextData* v8_data) {
+  DCHECK(v8_data);
+  if (v8_data->process_data()->MarkDetached(PassKey(), v8_data)) {
+    DCHECK_LT(detached_v8_context_count_, global_v8_context_datas_.size());
+    ++detached_v8_context_count_;
+  }
+}
+
 void V8ContextTrackerDataStore::Destroy(
     const blink::ExecutionContextToken& token) {
   auto it = global_execution_context_datas_.find(token);
   DCHECK(it != global_execution_context_datas_.end());
   auto* ec_data = it->get();
+  if (ec_data->destroyed) {
+    DCHECK_LT(0u, destroyed_execution_context_count_);
+    --destroyed_execution_context_count_;
+  } else {
+    DCHECK_LT(destroyed_execution_context_count_,
+              global_execution_context_datas_.size());
+  }
   ec_data->process_data()->Remove(PassKey(), ec_data);
   global_execution_context_datas_.erase(it);
 }
@@ -302,6 +360,12 @@ void V8ContextTrackerDataStore::Destroy(const blink::V8ContextToken& token) {
   auto it = global_v8_context_datas_.find(token);
   DCHECK(it != global_v8_context_datas_.end());
   auto* v8_data = it->get();
+  if (v8_data->detached) {
+    DCHECK_LT(0u, detached_v8_context_count_);
+    --detached_v8_context_count_;
+  } else {
+    DCHECK_LT(detached_v8_context_count_, global_v8_context_datas_.size());
+  }
   v8_data->process_data()->Remove(PassKey(), v8_data);
   global_v8_context_datas_.erase(it);
 }

components/performance_manager/v8_memory/v8_context_tracker_internal.h

@@ -20,6 +20,7 @@
 #include "components/performance_manager/graph/node_attached_data_impl.h"
 #include "components/performance_manager/graph/process_node_impl.h"
 #include "components/performance_manager/v8_memory/v8_context_tracker.h"
+#include "components/performance_manager/v8_memory/v8_context_tracker_helpers.h"
 #include "components/performance_manager/v8_memory/v8_context_tracker_types.h"
 #include "third_party/blink/public/common/tokens/tokens.h"
 
@@ -100,6 +101,10 @@ class ExecutionContextData : public base::LinkNode<ExecutionContextData>,
   // transitioned to "ShouldDestroy".
   WARN_UNUSED_RESULT bool DecrementV8ContextCount(util::PassKey<V8ContextData>);
 
+  // Marks this context as destroyed. Returns true if the state changed, false
+  // if it was already destroyed.
+  WARN_UNUSED_RESULT bool MarkDestroyed(util::PassKey<ProcessData>);
+
  private:
   ProcessData* const process_data_;
 
@@ -180,6 +185,10 @@ class V8ContextData : public base::LinkNode<V8ContextData>,
   // Returns the ExecutionContextData associated with this V8ContextData.
   ExecutionContextData* GetExecutionContextData() const;
 
+  // Marks this context as detached. Returns true if the state changed, false
+  // if it was already detached.
+  WARN_UNUSED_RESULT bool MarkDetached(util::PassKey<ProcessData>);
+
  private:
   ProcessData* const process_data_;
 };
@@ -191,6 +200,8 @@ class ProcessData : public NodeAttachedDataImpl<ProcessData> {
  public:
   struct Traits : public NodeAttachedDataInMap<ProcessNodeImpl> {};
 
+  using PassKey = util::PassKey<ProcessData>;
+
   explicit ProcessData(const ProcessNodeImpl* process_node);
   ~ProcessData() override;
 
@@ -217,6 +228,27 @@ class ProcessData : public NodeAttachedDataImpl<ProcessData> {
               RemoteFrameData* rf_data);
   void Remove(util::PassKey<V8ContextTrackerDataStore>, V8ContextData* v8_data);
 
+  // For marking objects detached/destroyed. Returns true if the state
+  // actually changed, false otherwise.
+  WARN_UNUSED_RESULT bool MarkDestroyed(
+      util::PassKey<V8ContextTrackerDataStore>,
+      ExecutionContextData* ec_data);
+  WARN_UNUSED_RESULT bool MarkDetached(util::PassKey<V8ContextTrackerDataStore>,
+                                       V8ContextData* v8_data);
+
+  size_t GetExecutionContextDataCount() const {
+    return counts_.GetExecutionContextDataCount();
+  }
+  size_t GetDestroyedExecutionContextDataCount() const {
+    return counts_.GetDestroyedExecutionContextDataCount();
+  }
+  size_t GetV8ContextDataCount() const {
+    return counts_.GetV8ContextDataCount();
+  }
+  size_t GetDetachedV8ContextDataCount() const {
+    return counts_.GetDetachedV8ContextDataCount();
+  }
+
  private:
   // Used to initialize |data_store_| at construction.
   static V8ContextTrackerDataStore* GetDataStore(
@@ -227,6 +259,9 @@ class ProcessData : public NodeAttachedDataImpl<ProcessData> {
   // Pointer to the DataStore that implicitly owns us.
   V8ContextTrackerDataStore* const data_store_;
 
+  // Counts the number of ExecutionContexts and V8Contexts.
+  ContextCounts counts_;
+
   // List of ExecutionContextDatas associated with this process.
   base::LinkedList<ExecutionContextData> execution_context_datas_;
 
@@ -262,12 +297,23 @@ class V8ContextTrackerDataStore {
   RemoteFrameData* Get(const blink::RemoteFrameToken& token);
   V8ContextData* Get(const blink::V8ContextToken& token);
 
+  // For marking objects as detached/destroyed.
+  void MarkDestroyed(ExecutionContextData* ec_data);
+  void MarkDetached(V8ContextData* v8_data);
+
   // Destroys objects by token. They must exist ("Get" should return non
   // nullptr).
   void Destroy(const blink::ExecutionContextToken& token);
   void Destroy(const blink::RemoteFrameToken& token);
   void Destroy(const blink::V8ContextToken& token);
 
+  size_t GetDestroyedExecutionContextDataCount() const {
+    return destroyed_execution_context_count_;
+  }
+  size_t GetDetachedV8ContextDataCount() const {
+    return detached_v8_context_count_;
+  }
+
   size_t GetExecutionContextDataCount() const {
     return global_execution_context_datas_.size();
   }
@@ -279,6 +325,9 @@ class V8ContextTrackerDataStore {
   }
 
  private:
+  size_t destroyed_execution_context_count_ = 0;
+  size_t detached_v8_context_count_ = 0;
+
   // Browser wide registry of ExecutionContextData objects.
   std::set<std::unique_ptr<ExecutionContextData>,
            ExecutionContextData::Comparator>

components/performance_manager/v8_memory/v8_context_tracker_internal_unittest.cc

@@ -221,6 +221,75 @@ TEST_F(V8ContextTrackerInternalTest,
   EXPECT_EQ(0u, data_store()->GetV8ContextDataCount());
 }
 
+TEST_F(V8ContextTrackerInternalTest, ContextCounts) {
+  auto* process_data = ProcessData::GetOrCreate(
+      static_cast<ProcessNodeImpl*>(mock_graph_.process.get()));
+
+  std::unique_ptr<ExecutionContextData> ec_data =
+      std::make_unique<ExecutionContextData>(
+          process_data, mock_graph_.frame->frame_token(), base::nullopt);
+  auto* raw_ec_data = ec_data.get();
+
+  std::unique_ptr<V8ContextData> v8_data1 = std::make_unique<V8ContextData>(
+      process_data, V8ContextDescription(), ec_data.get());
+  auto* raw_v8_data1 = v8_data1.get();
+
+  std::unique_ptr<V8ContextData> v8_data2 = std::make_unique<V8ContextData>(
+      process_data, V8ContextDescription(), ec_data.get());
+
+  data_store()->Pass(std::move(ec_data));
+  data_store()->Pass(std::move(v8_data1));
+  data_store()->Pass(std::move(v8_data2));
+
+  EXPECT_EQ(1u, data_store()->GetExecutionContextDataCount());
+  EXPECT_EQ(0u, data_store()->GetDestroyedExecutionContextDataCount());
+  EXPECT_EQ(2u, data_store()->GetV8ContextDataCount());
+  EXPECT_EQ(0u, data_store()->GetDetachedV8ContextDataCount());
+  EXPECT_EQ(1u, process_data->GetExecutionContextDataCount());
+  EXPECT_EQ(0u, process_data->GetDestroyedExecutionContextDataCount());
+  EXPECT_EQ(2u, process_data->GetV8ContextDataCount());
+  EXPECT_EQ(0u, process_data->GetDetachedV8ContextDataCount());
+
+  EXPECT_FALSE(raw_ec_data->destroyed);
+  data_store()->MarkDestroyed(raw_ec_data);
+  EXPECT_TRUE(raw_ec_data->destroyed);
+
+  EXPECT_FALSE(raw_v8_data1->detached);
+  data_store()->MarkDetached(raw_v8_data1);
+  EXPECT_TRUE(raw_v8_data1->detached);
+
+  EXPECT_EQ(1u, data_store()->GetExecutionContextDataCount());
+  EXPECT_EQ(1u, data_store()->GetDestroyedExecutionContextDataCount());
+  EXPECT_EQ(2u, data_store()->GetV8ContextDataCount());
+  EXPECT_EQ(1u, data_store()->GetDetachedV8ContextDataCount());
+  EXPECT_EQ(1u, process_data->GetExecutionContextDataCount());
+  EXPECT_EQ(1u, process_data->GetDestroyedExecutionContextDataCount());
+  EXPECT_EQ(2u, process_data->GetV8ContextDataCount());
+  EXPECT_EQ(1u, process_data->GetDetachedV8ContextDataCount());
+
+  data_store()->Destroy(raw_v8_data1->GetToken());
+
+  EXPECT_EQ(1u, data_store()->GetExecutionContextDataCount());
+  EXPECT_EQ(1u, data_store()->GetDestroyedExecutionContextDataCount());
+  EXPECT_EQ(1u, data_store()->GetV8ContextDataCount());
+  EXPECT_EQ(0u, data_store()->GetDetachedV8ContextDataCount());
+  EXPECT_EQ(1u, process_data->GetExecutionContextDataCount());
+  EXPECT_EQ(1u, process_data->GetDestroyedExecutionContextDataCount());
+  EXPECT_EQ(1u, process_data->GetV8ContextDataCount());
+  EXPECT_EQ(0u, process_data->GetDetachedV8ContextDataCount());
+
+  process_data->TearDown();
+
+  EXPECT_EQ(0u, data_store()->GetExecutionContextDataCount());
+  EXPECT_EQ(0u, data_store()->GetDestroyedExecutionContextDataCount());
+  EXPECT_EQ(0u, data_store()->GetV8ContextDataCount());
+  EXPECT_EQ(0u, data_store()->GetDetachedV8ContextDataCount());
+  EXPECT_EQ(0u, process_data->GetExecutionContextDataCount());
+  EXPECT_EQ(0u, process_data->GetDestroyedExecutionContextDataCount());
+  EXPECT_EQ(0u, process_data->GetV8ContextDataCount());
+  EXPECT_EQ(0u, process_data->GetDetachedV8ContextDataCount());
+}
+
 namespace {
 
 class V8ContextTrackerInternalTearDownOrderTest