[SyzyAsan] Enable Crashpad reporter as a 50/50 experiment.

syzygy/agent/asan/runtime.cc

 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 369 matching lines @@
           ->WriteCorruptHeapInfo(corrupt_ranges, size, buffer, error_info); \
     }                                                                       \
   }
 
 void LaunchMessageBox(const base::StringPiece& message) {
   // TODO(chrisha): Consider making this close itself with a timeout to prevent
   //     hangs on the waterfall.
   ::MessageBoxA(nullptr, message.data(), nullptr, MB_OK | MB_ICONEXCLAMATION);
 }
 
-std::unique_ptr<ReporterInterface> CreateCrashReporter(AsanLogger* logger) {
+AsanFeatureSet GenerateRandomFeatureSet() {
+  AsanFeatureSet enabled_features =
+      static_cast<AsanFeatureSet>(base::RandGenerator(ASAN_FEATURE_MAX));
+  DCHECK_LT(enabled_features, ASAN_FEATURE_MAX);
+  enabled_features &= kAsanValidFeatures;
+  return enabled_features;
+}
+
+std::unique_ptr<ReporterInterface> CreateCrashReporter(
+    AsanLogger* logger, AsanFeatureSet* feature_set) {
+  DCHECK_NE(static_cast<AsanLogger*>(nullptr), logger);
+  DCHECK_NE(static_cast<AsanFeatureSet*>(nullptr), feature_set);
   std::unique_ptr<ReporterInterface> reporter;
 
+  bool created_crashpad = false;
+
   // First try to grab the preferred crash reporter, overridden by the
   // environment.
   std::unique_ptr<base::Environment> env(base::Environment::Create());
   std::string reporter_name;
   if (env->GetVar("SYZYASAN_CRASH_REPORTER", &reporter_name)) {
-    if (reporter_name == "crashpad")
+    if (reporter_name == "crashpad") {
       reporter.reset(reporters::CrashpadReporter::Create().release());
-    else if (reporter_name == "kasko")
+      created_crashpad = (reporter.get() != nullptr);
+    } else if (reporter_name == "kasko") {
       reporter.reset(reporters::KaskoReporter::Create().release());
-    else if (reporter_name == "breakpad")
+    } else if (reporter_name == "breakpad") {
       reporter.reset(reporters::BreakpadReporter::Create().release());
+    }
 
     if (reporter.get() != nullptr) {
       logger->Write(base::StringPrintf(
           "Using requested \"%s\" crash reporter.", reporter_name));
       return reporter;
     } else {
       logger->Write(base::StringPrintf(
           "Unable to create requested \"%s\" crash reporter.", reporter_name));
     }
   }
 
   // No crash reporter was explicitly specified, or it was unable to be
   // initialized. Try all of them, starting with the most recent.
 
-  // Don't try grabbing a Crashpad reporter by default, as we're not yet
-  // ready to ship this.
-  // TODO(chrisha): Add Crashpad support behind a feature flag.
+  // Only create a crashpad reporter if the feature was enabled.
+  if (reporter.get() == nullptr &&
+      (*feature_set & ASAN_FEATURE_ENABLE_CRASHPAD)) {
+    reporter.reset(reporters::CrashpadReporter::Create().release());
+    created_crashpad = (reporter.get() != nullptr);
+  }
 
   // Try to initialize a Kasko crash reporter.
   if (reporter.get() == nullptr)
     reporter.reset(reporters::KaskoReporter::Create().release());
 
   // If that failed then try to initialize a Breakpad reporter.
   if (reporter.get() == nullptr)
     reporter.reset(reporters::BreakpadReporter::Create().release());
 
+  // Ensure the feature flag (which will end up being reported as an
+  // experiment group in instrumented Chromen) reflects whether or not a
+  // crashpad reporter is in use.
+  if (created_crashpad) {
+    *feature_set |= ASAN_FEATURE_ENABLE_CRASHPAD;
+  } else {
+    *feature_set &= ~ASAN_FEATURE_ENABLE_CRASHPAD;
+  }
+
   return reporter;
 }
 
 }  // namespace
 
 base::Lock AsanRuntime::lock_;
 AsanRuntime* AsanRuntime::runtime_ = NULL;
 LPTOP_LEVEL_EXCEPTION_FILTER AsanRuntime::previous_uef_ = NULL;
 bool AsanRuntime::uef_installed_ = false;
 
@@ skipping 36 matching lines @@
   if (!SetUpMemoryNotifier())
     return false;
   if (!SetUpLogger())
     return false;
   if (!SetUpStackCache())
     return false;
   if (!SetUpHeapManager())
     return false;
   WindowsHeapAdapter::SetUp(heap_manager_.get());
 
-  if (params_.feature_randomization) {
-    AsanFeatureSet feature_set = GenerateRandomFeatureSet();
+  AsanFeatureSet feature_set = 0;
+  if (params_.feature_randomization)
+    GenerateRandomFeatureSet();

[Sigurður Ásgeirsson, 2016/05/18 14:24:51]

uh??

[Sigurður Ásgeirsson, 2016/05/18 14:26:16]

That is to say - this looks like a noop to me?

[chrisha, 2016/05/18 14:32:57]

Indeed it is. Cut and paste error.

Also, as Seb pointed out, I totally spaced on writing the unittest. Ignore this
for now :)

+
+  // Creating the crash reporter may override a randomized feature, so do this
+  // before propagating paramters. The name 'disable_breakpad_reporting' is
+  // legacy; this actually means to disable all external crash reporting
+  // integration.
+  if (!params_.disable_breakpad_reporting) {
+    crash_reporter_.reset(
+        CreateCrashReporter(logger(), &feature_set).release());
+  }
+
+  // Propagate randomized features if they're enabled.
+  if (params_.feature_randomization)
     PropagateFeatureSet(feature_set);
-  }
 
   // Propagates the flags values to the different modules.
   PropagateParams();
 
-  // The name 'disable_breakpad_reporting' is legacy; this actually means to
-  // disable all external crash reporting integration.
-  if (!params_.disable_breakpad_reporting)
-    crash_reporter_.reset(CreateCrashReporter(logger()).release());
-
   // Set up the appropriate error handler depending on whether or not
   // we successfully found a crash reporter.
   if (crash_reporter_.get() != nullptr) {
     logger_->Write(base::StringPrintf(
         "SyzyASAN: Using %s for error reporting.",
         crash_reporter_->GetName()));
     SetErrorCallBack(base::Bind(&CrashReporterErrorHandler));
   } else {
     logger_->Write("SyzyASAN: Using default error reporting handler.");
     SetErrorCallBack(base::Bind(&DefaultErrorHandler));
@@ skipping 445 matching lines @@
   }
 
   // Print the Windbg information to display the free stack if present.
   if (error_info->block_info.free_stack_size != NULL) {
     AsanDbgMessage(L"Free stack trace:");
     AsanDbgCmd(L"dps %p l%d", error_info->block_info.free_stack,
                error_info->block_info.free_stack_size);
   }
 }
 
-AsanFeatureSet AsanRuntime::GenerateRandomFeatureSet() {
-  AsanFeatureSet enabled_features =
-      static_cast<AsanFeatureSet>(base::RandGenerator(ASAN_FEATURE_MAX));
-  DCHECK_LT(enabled_features, ASAN_FEATURE_MAX);
-  enabled_features &= kAsanValidFeatures;
-  return enabled_features;
-}
-
 void AsanRuntime::PropagateFeatureSet(AsanFeatureSet feature_set) {
   DCHECK_EQ(0U, feature_set & ~kAsanValidFeatures);
   heap_manager_->enable_page_protections_ =
       (feature_set & ASAN_FEATURE_ENABLE_PAGE_PROTECTIONS) != 0;
   params_.enable_large_block_heap =
       (feature_set & ASAN_FEATURE_ENABLE_LARGE_BLOCK_HEAP) != 0;
 }
 
 void AsanRuntime::GetBadAccessInformation(AsanErrorInfo* error_info) {
   base::AutoLock lock(lock_);
@@ skipping 216 matching lines @@
   if (heap_manager_->enable_page_protections_)
     enabled_features |= ASAN_FEATURE_ENABLE_PAGE_PROTECTIONS;
   if (params_.enable_large_block_heap)
     enabled_features |= ASAN_FEATURE_ENABLE_LARGE_BLOCK_HEAP;
 
   return enabled_features;
 }
 
 }  // namespace asan
 }  // namespace agent