Record field-trial information in stability file for crash analysis.

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.
 
 #ifndef BASE_DEBUG_ACTIVITY_TRACKER_H_
 #define BASE_DEBUG_ACTIVITY_TRACKER_H_
 
 // std::atomic is undesired due to performance issues when used as global
 // variables. There are no such instances here. This module uses the
 // PersistentMemoryAllocator which also uses std::atomic and is written
 // by the same author.
 #include <atomic>
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/location.h"
 #include "base/metrics/persistent_memory_allocator.h"
+#include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_local_storage.h"
 
 namespace base {
 
 struct PendingTask;
 
 class FilePath;
@@ skipping 294 matching lines @@
 
     ValueType type_;
     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);
-  ~ActivityUserData();
+  virtual ~ActivityUserData();
 
   // Gets the unique ID number for this user data. If this changes then the
   // contents have been overwritten by another thread. The return value is
   // always non-zero unless it's actually just a data "sink".
   uint32_t id() const {
     return memory_ ? id_->load(std::memory_order_relaxed) : 0;
   }
 
   // Writes a |value| (as part of a key/value pair) that will be included with
   // the activity in any reports. The same |name| can be written multiple times
@@ skipping 41 matching lines @@
   // 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.
   bool CreateSnapshot(Snapshot* output_snapshot) const;
 
   // Gets the base memory address used for storing data.
   const void* GetBaseAddress();
 
+ protected:
+  virtual void Set(StringPiece name,
+                   ValueType type,
+                   const void* memory,
+                   size_t size);
+
  private:
   FRIEND_TEST_ALL_PREFIXES(ActivityTrackerTest, UserDataTest);
 
   enum : size_t { kMemoryAlignment = sizeof(uint64_t) };
 
   // A structure used to reference data held outside of persistent memory.
   struct ReferenceRecord {
     uint64_t address;
     uint64_t size;
   };
@@ skipping 13 matching lines @@
     ValueInfo(ValueInfo&&);
     ~ValueInfo();
 
     StringPiece name;                 // The "key" of the record.
     ValueType type;                   // The type of the value.
     void* memory;                     // Where the "value" is held.
     std::atomic<uint16_t>* size_ptr;  // Address of the actual size of value.
     size_t extent;                    // The total storage of the value,
   };                                  // typically rounded up for alignment.
 
-  void Set(StringPiece name, ValueType type, const void* memory, size_t size);
   void SetReference(StringPiece name,
                     ValueType type,
                     const void* memory,
                     size_t size);
 
   // Loads any data already in the memory segment. This allows for accessing
   // records created previously.
   void ImportExistingData() const;
 
   // A map of all the values within the memory block, keyed by name for quick
   // updates of the values. This is "mutable" because it changes on "const"
   // objects even when the actual data values can't change.
   mutable std::map<StringPiece, ValueInfo> values_;
 
   // 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 unique ID for this instance.
   std::atomic<uint32_t>* const id_;
 
-  base::ThreadChecker thread_checker_;
-
   // This ID is used to create unique indentifiers for user data so that it's
   // possible to tell if the information has been overwritten.
   static std::atomic<uint32_t> next_id_;
 
   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
@@ skipping 299 matching lines @@
 
   // Records a log message. The current implementation does NOT recycle these
   // only store critical messages such as FATAL ones.
   void RecordLogMessage(StringPiece message);
 
   // Records a module load/unload event. This is safe to call multiple times
   // even with the same information.
   void RecordModuleInfo(const ModuleInfo& info);
 
   // Accesses the global data record for storing arbitrary key/value pairs.
-  ActivityUserData& user_data() { return user_data_; }
+  ActivityUserData& global_data() { return global_data_; }
+
+  // Record field trial information. This will work even before a global
+  // tracker has been created, holding that information internally until a
+  // global tracker is created at which point everything collected will be
+  // dumped into it. This call is completely thread-safe.

[Alexei Svitkine (slow), 2017/02/07 16:14:06]

Nit: Remove the word "completely". "thread safe" is enough to be clear.

[bcwhite, 2017/02/07 17:39:30]

Done.

+  static void RecordFieldTrial(const std::string& trial_name,
+                               const std::string& group_name);
+
+  // Disable all filed trial recording. This should be called when its known

[Alexei Svitkine (slow), 2017/02/07 16:14:06]

field

[bcwhite, 2017/02/07 17:39:30]

Done.

+  // that no global tracker will be created so as to not hold field-trial
+  // information that will never be collected.
+  static void DisableFieldTrialRecording();
 
  private:
   friend class GlobalActivityAnalyzer;
   friend class ScopedThreadActivity;
   friend class ActivityTrackerTest;
 
   enum : int {
     // The maximum number of threads that can be tracked within a process. If
     // more than this number run concurrently, tracking of new ones may cease.
     kMaxThreadCount = 100,
     kCachedThreadMemories = 10,
     kCachedUserDataMemories = 10,
   };
 
+  // A wrapper around ActivityUserData that is thread-safe and thus can be used
+  // in the global scope without the requirement of being called from only one
+  // thread.
+  class GlobalUserData : public ActivityUserData {
+   public:
+    GlobalUserData(void* memory, size_t size);
+    ~GlobalUserData() override;
+
+   private:
+    void Set(StringPiece name,
+             ValueType type,
+             const void* memory,
+             size_t size) override;
+
+    Lock data_lock_;
+
+    DISALLOW_COPY_AND_ASSIGN(GlobalUserData);
+  };
+
   // State of a module as stored in persistent memory. This supports a single
   // loading of a module only. If modules are loaded multiple times at
   // different addresses, only the last will be recorded and an unload will
   // not revert to the information of any other addresses.
   struct BASE_EXPORT ModuleInfoRecord {
     // SHA1(ModuleInfoRecord): Increment this if structure changes!
     static constexpr uint32_t kPersistentTypeId = 0x05DB5F41 + 1;
 
     // Expected size for 32/64-bit check by PersistentMemoryAllocator.
     static constexpr size_t kExpectedInstanceSize = 56;
@@ skipping 84 matching lines @@
   // A caching memory allocator for thread-tracker objects.
   ActivityTrackerMemoryAllocator thread_tracker_allocator_;
   base::Lock thread_tracker_allocator_lock_;
 
   // A caching memory allocator for user data attached to activity data.
   ActivityTrackerMemoryAllocator user_data_allocator_;
   base::Lock user_data_allocator_lock_;
 
   // An object for holding global arbitrary key value pairs. Values must always
   // be written from the main UI thread.
-  ActivityUserData user_data_;
+  GlobalUserData global_data_;
 
   // A map of global module information, keyed by module path.
   std::map<const std::string, ModuleInfoRecord*> modules_;
   base::Lock modules_lock_;
 
   // The active global activity tracker.
   static GlobalActivityTracker* g_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(GlobalActivityTracker);
 };
@@ skipping 122 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_