Add analyzer support for multiple processes.

base/debug/activity_tracker.h

 // 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.
 
 // Activity tracking provides a low-overhead method of collecting information
 // about the state of the application for analysis both while it is running
 // and after it has terminated unexpectedly. Its primary purpose is to help
 // locate reasons the browser becomes unresponsive by providing insight into
 // what all the various threads and processes are (or were) doing.
 
@@ skipping 359 matching lines @@
     //  - the memory has been released back to the OS
     //  - the memory belongs to a different process's address space
     // Dereferencing the returned StringPiece when the memory is not accessible
     // will cause the program to SEGV!
     StringPiece GetReference() const;
     StringPiece GetStringReference() const;
 
    private:
     friend class ActivityUserData;
 
-    ValueType type_;
+    ValueType type_ = END_OF_VALUES;
     uint64_t short_value_;    // Used to hold copy of numbers, etc.
     std::string long_value_;  // Used to hold copy of raw/string data.
     StringPiece ref_value_;   // Used to hold reference to external data.
   };
 
   using Snapshot = std::map<std::string, TypedValue>;
 
   ActivityUserData(void* memory, size_t size);
   virtual ~ActivityUserData();
 
@@ skipping 42 matching lines @@
   // of information.
   void SetReference(StringPiece name, const void* memory, size_t size) {
     SetReference(name, RAW_VALUE_REFERENCE, memory, size);
   }
   void SetStringReference(StringPiece name, StringPiece value) {
     SetReference(name, STRING_VALUE_REFERENCE, value.data(), value.length());
   }
 
   // Creates a snapshot of the key/value pairs contained within. The returned
   // data will be fixed, independent of whatever changes afterward. There is
-  // protection against concurrent modification of the values but no protection
-  // against a complete overwrite of the contents; the caller must ensure that
-  // the memory segment is not going to be re-initialized while this runs.
+  // some protection against concurrent modification. This will return false
+  // if the data is invalid or if a complete overwrite of the contents is
+  // detected.
   bool CreateSnapshot(Snapshot* output_snapshot) const;
 
   // Gets the base memory address used for storing data.
   const void* GetBaseAddress() const;
 
   // Explicitly sets the process ID.
   void SetOwningProcessIdForTesting(ProcessId pid, int64_t stamp);
 
   // Gets the associated process ID, in native form, and the creation timestamp
   // from tracker memory without loading the entire structure for analysis. This
@@ skipping 68 matching lines @@
 
   // Information about the memory block in which new data can be stored. These
   // are "mutable" because they change even on "const" objects that are just
   // skipping already set values.
   mutable char* memory_;
   mutable size_t available_;
 
   // A pointer to the memory header for this instance.
   MemoryHeader* const header_;
 
+  // These hold values used when initially creating the object. They are
+  // compared against current header values to check for outside changes.
+  const uint32_t orig_data_id;
+  const int64_t orig_process_id;
+  const int64_t orig_create_stamp;
+
   DISALLOW_COPY_AND_ASSIGN(ActivityUserData);
 };
 
 // This class manages tracking a stack of activities for a single thread in
 // a persistent manner, implementing a bounded-size stack in a fixed-size
 // memory allocation. In order to support an operational mode where another
 // thread is analyzing this data in real-time, atomic operations are used
 // where necessary to guarantee a consistent view from the outside.
 //
 // This class is not generally used directly but instead managed by the
@@ skipping 14 matching lines @@
   struct BASE_EXPORT Snapshot {
     // Explicit constructor/destructor are needed because of complex types
     // with non-trivial default constructors and destructors.
     Snapshot();
     ~Snapshot();
 
     // The name of the thread as set when it was created. The name may be
     // truncated due to internal length limitations.
     std::string thread_name;
 
+    // The timestamp at which this process was created.
+    int64_t create_stamp;
+
     // The process and thread IDs. These values have no meaning other than
     // they uniquely identify a running process and a running thread within
     // that process.  Thread-IDs can be re-used across different processes
     // and both can be re-used after the process/thread exits.
     int64_t process_id = 0;
     int64_t thread_id = 0;
 
     // The current stack of activities that are underway for this thread. It
     // is limited in its maximum size with later entries being left off.
     std::vector<Activity> activity_stack;
@@ skipping 683 matching lines @@
   ScopedProcessWaitActivity(const void* program_counter,
                             const base::Process* process);
   DISALLOW_COPY_AND_ASSIGN(ScopedProcessWaitActivity);
 };
 #endif
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_ACTIVITY_TRACKER_H_