Stability instrumentation: add a Vectored Exception Handler

components/browser_watcher/stability_report_extractor_unittest.cc

 // Copyright 2017 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 "components/browser_watcher/stability_report_extractor.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/debug/activity_tracker.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/persistent_memory_allocator.h"
 #include "base/stl_util.h"
+#include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/crashpad/crashpad/client/crash_report_database.h"
 
 namespace browser_watcher {
 
 using base::debug::ActivityData;
 using base::debug::ActivityTrackerMemoryAllocator;
 using base::debug::ActivityUserData;
 using base::debug::GlobalActivityTracker;
 using base::debug::ThreadActivityTracker;
@@ skipping 83 matching lines @@
         mem_reference, GlobalActivityTracker::kTypeIdActivityTracker,
         PersistentMemoryAllocator::kSizeAny);
     if (mem_base == nullptr)
       return nullptr;
 
     // Make the allocation iterable so it can be found by other processes.
     allocator->MakeIterable(mem_reference);
 
     return WrapUnique(new ThreadActivityTracker(mem_base, tracker_mem_size));
   }
+  void PerformBasicReportValidation(const StabilityReport& report) {
+    // One report with one thread that has the expected name and id.
+    ASSERT_EQ(1, report.process_states_size());
+    const ProcessState& process_state = report.process_states(0);
+    EXPECT_EQ(base::GetCurrentProcId(), process_state.process_id());
+    ASSERT_EQ(1, process_state.threads_size());
+    const ThreadState& thread_state = process_state.threads(0);
+    EXPECT_EQ(base::PlatformThread::GetName(), thread_state.thread_name());
+#if defined(OS_WIN)
+    EXPECT_EQ(base::PlatformThread::CurrentId(), thread_state.thread_id());
+#elif defined(OS_POSIX)
+    EXPECT_EQ(base::PlatformThread::CurrentHandle().platform_handle(),
+              thread_state.thread_id());
+#endif
+  }
 
   const FilePath& debug_file_path() const { return debug_file_path_; }
 
  protected:
   base::ScopedTempDir temp_dir_;
   FilePath debug_file_path_;
 
   std::unique_ptr<PersistentMemoryAllocator> allocator_;
   std::unique_ptr<ThreadActivityTracker> tracker_;
 };
@@ skipping 25 matching lines @@
       GlobalActivityTracker::kTypeIdUserDataRecordFree, 1024U, 10U, false);
   std::unique_ptr<ActivityUserData> user_data =
       tracker_->GetUserData(activity_id, &user_data_allocator);
   user_data->SetInt("some_int", 42);
 
   // Validate collection returns the expected report.
   StabilityReport report;
   ASSERT_EQ(SUCCESS, Extract(debug_file_path(), &report));
 
   // Validate the report.
-  ASSERT_EQ(1, report.process_states_size());
-  const ProcessState& process_state = report.process_states(0);
-  EXPECT_EQ(base::GetCurrentProcId(), process_state.process_id());
-  ASSERT_EQ(1, process_state.threads_size());
-
-  const ThreadState& thread_state = process_state.threads(0);
-  EXPECT_EQ(base::PlatformThread::GetName(), thread_state.thread_name());
-#if defined(OS_WIN)
-  EXPECT_EQ(base::PlatformThread::CurrentId(), thread_state.thread_id());
-#elif defined(OS_POSIX)
-  EXPECT_EQ(base::PlatformThread::CurrentHandle().platform_handle(),
-            thread_state.thread_id());
-#endif
+  ASSERT_NO_FATAL_FAILURE(PerformBasicReportValidation(report));
+  const ThreadState& thread_state = report.process_states(0).threads(0);
 
   EXPECT_EQ(7, thread_state.activity_count());
   ASSERT_EQ(6, thread_state.activities_size());
   {
     const Activity& activity = thread_state.activities(0);
     EXPECT_EQ(Activity::ACT_TASK_RUN, activity.type());
     EXPECT_EQ(kTaskOrigin, activity.origin_address());
     EXPECT_EQ(kTaskSequenceNum, activity.task_sequence_id());
     EXPECT_EQ(0U, activity.user_data().size());
   }
@@ skipping 27 matching lines @@
   }
   {
     const Activity& activity = thread_state.activities(5);
     EXPECT_EQ(Activity::ACT_GENERIC, activity.type());
     EXPECT_EQ(kGenericId, activity.generic_id());
     EXPECT_EQ(kGenericData, activity.generic_data());
     EXPECT_EQ(0U, activity.user_data().size());
   }
 }
 
+TEST_F(StabilityReportExtractorThreadTrackerTest, CollectException) {
+  const void* expected_pc = reinterpret_cast<void*>(0xCAFE);
+  const void* expected_address = nullptr;
+  const uint32_t expected_code = 42U;
+
+  // Record an exception.
+  const int64_t timestamp = base::Time::Now().ToInternalValue();
+  tracker_->RecordExceptionActivity(expected_pc, expected_address,
+                                    base::debug::Activity::ACT_EXCEPTION,
+                                    ActivityData::ForException(expected_code));
+
+  // Collect report and validate.
+  StabilityReport report;
+  ASSERT_EQ(SUCCESS, Extract(debug_file_path(), &report));
+
+  // Validate the presence of the exception.
+  ASSERT_NO_FATAL_FAILURE(PerformBasicReportValidation(report));
+  const ThreadState& thread_state = report.process_states(0).threads(0);
+  ASSERT_TRUE(thread_state.has_exception());
+  const Exception& exception = thread_state.exception();
+  EXPECT_EQ(expected_code, exception.code());
+  EXPECT_EQ(expected_pc, reinterpret_cast<void*>(exception.program_counter()));
+  EXPECT_EQ(expected_address,
+            reinterpret_cast<void*>(exception.exception_address()));
+  const int64_t tolerance_us = 1000ULL;
+  EXPECT_LE(std::abs(timestamp - exception.time()), tolerance_us);
+}
+
+TEST_F(StabilityReportExtractorThreadTrackerTest, CollectNoException) {

[Sigurður Ásgeirsson, 2017/06/09 13:55:15]

nice testing, I like it!

[manzagop (departed), 2017/06/09 21:27:35]

Thanks you sir! Ack.

+  // Record something.
+  tracker_->PushActivity(reinterpret_cast<void*>(kTaskOrigin),
+                         base::debug::Activity::ACT_TASK_RUN,
+                         ActivityData::ForTask(kTaskSequenceNum));
+
+  // Collect report and validate there is no exception.
+  StabilityReport report;
+  ASSERT_EQ(SUCCESS, Extract(debug_file_path(), &report));
+  ASSERT_NO_FATAL_FAILURE(PerformBasicReportValidation(report));
+  const ThreadState& thread_state = report.process_states(0).threads(0);
+  ASSERT_FALSE(thread_state.has_exception());
+}
+
 // Tests stability report extraction.
 class StabilityReportExtractorTest : public testing::Test {
  public:
   const int kMemorySize = 1 << 20;  // 1MiB
 
   StabilityReportExtractorTest() {}
   ~StabilityReportExtractorTest() override {
     GlobalActivityTracker* global_tracker = GlobalActivityTracker::Get();
     if (global_tracker) {
       global_tracker->ReleaseTrackerForCurrentThreadForTesting();
@@ skipping 164 matching lines @@
   EXPECT_EQ("CAFECAFE2d000", collected_module.code_identifier());
   EXPECT_EQ(module_info.debug_file, collected_module.debug_file());
   EXPECT_EQ("1122334455667788ABCD0123456789AB1",
             collected_module.debug_identifier());
   EXPECT_EQ("", collected_module.version());
   EXPECT_EQ(0LL, collected_module.shrink_down_delta());
   EXPECT_EQ(!module_info.is_loaded, collected_module.is_unloaded());
 }
 
 }  // namespace browser_watcher