Revert "Track thread activities in order to diagnose hangs."

base/debug/activity_analyzer.cc

Index: base/debug/activity_analyzer.cc
diff --git a/base/debug/activity_analyzer.cc b/base/debug/activity_analyzer.cc
deleted file mode 100644
index 3c4f80866d0afc21250ef5f20faf74585fdd53f0..0000000000000000000000000000000000000000
--- a/base/debug/activity_analyzer.cc
+++ /dev/null
@@ -1,129 +0,0 @@
-// 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_analyzer.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/stl_util.h"
-#include "base/strings/string_util.h"
-
-namespace base {
-namespace debug {
-
-ThreadActivityAnalyzer::ThreadActivityAnalyzer(
-    const ThreadActivityTracker& tracker)
-    : activity_snapshot_valid_(tracker.Snapshot(&activity_snapshot_)) {}
-
-ThreadActivityAnalyzer::ThreadActivityAnalyzer(void* base, size_t size)
-    : ThreadActivityAnalyzer(ThreadActivityTracker(base, size)) {}
-
-ThreadActivityAnalyzer::ThreadActivityAnalyzer(
-    PersistentMemoryAllocator* allocator,
-    PersistentMemoryAllocator::Reference reference)
-    : ThreadActivityAnalyzer(allocator->GetAsObject<char>(
-                                 reference,
-                                 GlobalActivityTracker::kTypeIdActivityTracker),
-                             allocator->GetAllocSize(reference)) {}
-
-ThreadActivityAnalyzer::~ThreadActivityAnalyzer() {}
-
-GlobalActivityAnalyzer::GlobalActivityAnalyzer(
-    std::unique_ptr<PersistentMemoryAllocator> allocator)
-    : allocator_(std::move(allocator)), allocator_iterator_(allocator_.get()) {}
-
-GlobalActivityAnalyzer::~GlobalActivityAnalyzer() {}
-
-#if !defined(OS_NACL)
-// static
-std::unique_ptr<GlobalActivityAnalyzer> GlobalActivityAnalyzer::CreateWithFile(
-    const FilePath& file_path) {
-  // Map the file read-write so it can guarantee consistency between
-  // the analyzer and any trackers that my still be active.
-  std::unique_ptr<MemoryMappedFile> mmfile(new MemoryMappedFile());
-  mmfile->Initialize(file_path, MemoryMappedFile::READ_WRITE);
-  if (!mmfile->IsValid())
-    return nullptr;
-
-  if (!FilePersistentMemoryAllocator::IsFileAcceptable(*mmfile, true))
-    return nullptr;
-
-  return WrapUnique(new GlobalActivityAnalyzer(
-             WrapUnique(new FilePersistentMemoryAllocator(
-                            std::move(mmfile), 0, 0, base::StringPiece(),
-                            true))));
-}
-#endif  // !defined(OS_NACL)
-
-ThreadActivityAnalyzer* GlobalActivityAnalyzer::GetFirstAnalyzer() {
-  PrepareAllAnalyzers();
-  analyzers_iterator_ = analyzers_.begin();
-  if (analyzers_iterator_ == analyzers_.end())
-    return nullptr;
-  return analyzers_iterator_->second.get();
-}
-
-ThreadActivityAnalyzer* GlobalActivityAnalyzer::GetNextAnalyzer() {
-  DCHECK(analyzers_iterator_ != analyzers_.end());
-  ++analyzers_iterator_;
-  if (analyzers_iterator_ == analyzers_.end())
-    return nullptr;
-  return analyzers_iterator_->second.get();
-}
-
-ThreadActivityAnalyzer* GlobalActivityAnalyzer::GetAnalyzerForThread(
-    const ThreadKey& key) {
-  auto found = analyzers_.find(key);
-  if (found == analyzers_.end())
-    return nullptr;
-  return found->second.get();
-}
-
-void GlobalActivityAnalyzer::PrepareAllAnalyzers() {
-  // Fetch all the records. This will retrieve only ones created since the
-  // last run since the PMA iterator will continue from where it left off.
-  uint32_t type;
-  PersistentMemoryAllocator::Reference ref;
-  while ((ref = allocator_iterator_.GetNext(&type)) != 0) {
-    switch (type) {
-      case GlobalActivityTracker::kTypeIdActivityTracker:
-      case GlobalActivityTracker::kTypeIdActivityTrackerFree:
-        // Free or not, add it to the list of references for later analysis.
-        tracker_references_.insert(ref);
-        break;
-    }
-  }
-
-  // Go through all the known references and create analyzers for them with
-  // snapshots of the current state.
-  analyzers_.clear();
-  for (PersistentMemoryAllocator::Reference tracker_ref : tracker_references_) {
-    // Get the actual data segment for the tracker. This can fail if the
-    // record has been marked "free" since the type will not match.
-    void* base = allocator_->GetAsObject<char>(
-        tracker_ref, GlobalActivityTracker::kTypeIdActivityTracker);
-    if (!base)
-      continue;
-
-    // Create the analyzer on the data. This will capture a snapshot of the
-    // tracker state. This can fail if the tracker is somehow corrupted or is
-    // in the process of shutting down.
-    std::unique_ptr<ThreadActivityAnalyzer> analyzer(new ThreadActivityAnalyzer(
-        base, allocator_->GetAllocSize(tracker_ref)));
-    if (!analyzer->IsValid())
-      continue;
-
-    // Add this analyzer to the map of known ones, indexed by a unique thread
-    // identifier.
-    DCHECK(!ContainsKey(analyzers_, analyzer->GetThreadKey()));
-    analyzer->allocator_reference_ = ref;
-    analyzers_[analyzer->GetThreadKey()] = std::move(analyzer);
-  }
-}
-
-}  // namespace debug
-}  // namespace base