Avoid reporting crashes for exceptions that hit our SEH from calls to the ori...

chrome_frame/test/exception_barrier_unittest.cc

 // Copyright (c) 2010 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 "gtest/gtest.h"
 #include "chrome_frame/exception_barrier.h"
 
 namespace {
 
 // retrieves the top SEH registration record
@@ skipping 57 matching lines @@
   }
 }
 
 void AccessViolationCrash() {
   volatile char* null = NULL;
   *null = '\0';
 }
 
 // A simple crash over the exception barrier
 void CrashOverExceptionBarrier() {
-  ExceptionBarrier barrier;
+  ExceptionBarrierCustomHandler barrier;
 
   TestSEHChainSane();
 
   AccessViolationCrash();
 
   TestSEHChainSane();
 }
 
 #pragma warning(push)
- // Inline asm assigning to 'FS:0' : handler not registered as safe handler
- // This warning is in error (the compiler can't know that we register the
- // handler as a safe SEH handler in an .asm file)
- #pragma warning(disable:4733)
-// Hand-generate an SEH frame implicating the ExceptionBarrierHandler,
+// Inline asm assigning to 'FS:0' : handler not registered as safe handler
+// This warning is in error (the compiler can't know that we register the
+// handler as a safe SEH handler in an .asm file)
+#pragma warning(disable:4733)
+// Hand-generate an SEH frame implicating the ExceptionBarrierCallCustomHandler,
 // then crash to invoke it.
 __declspec(naked) void CrashOnManualSEHBarrierHandler() {
   __asm {
-    push  ExceptionBarrierHandler
+    push  ExceptionBarrierCallCustomHandler
     push  FS:0
     mov   FS:0, esp
     call  AccessViolationCrash
     ret
   }
 }
 #pragma warning(pop)
 
+
 class ExceptionBarrierTest: public testing::Test {
-public:
-  ExceptionBarrierTest() : old_handler_(NULL) {
+ public:
+  ExceptionBarrierTest() {
   }
 
   // Install an exception handler for the ExceptionBarrier, and
   // set the handled flag to false. This allows us to see whether
   // the ExceptionBarrier gets to handle the exception
   virtual void SetUp() {
-    old_handler_ = ExceptionBarrier::handler();
-    ExceptionBarrier::set_handler(ExceptionHandler);
+    ExceptionBarrierConfig::set_enabled(true);
+    ExceptionBarrierCustomHandler::set_custom_handler(&ExceptionHandler);
     s_handled_ = false;
 
     TestSEHChainSane();
   }
 
   virtual void TearDown() {
-    ExceptionBarrier::set_handler(old_handler_);
-
     TestSEHChainSane();
+    ExceptionBarrierCustomHandler::set_custom_handler(NULL);
+    ExceptionBarrierConfig::set_enabled(false);
   }
 
   // The exception notification callback, sets the handled flag.
   static void CALLBACK ExceptionHandler(EXCEPTION_POINTERS* ptrs) {
     TestSEHChainSane();
-
     s_handled_ = true;
   }
 
-  // Old handler to restore on TearDown
-  ExceptionBarrier::ExceptionHandler old_handler_;
-
   // Flag is set by handler
   static bool s_handled_;
 };
 
-bool ExceptionBarrierTest::s_handled_;
+bool ExceptionBarrierTest::s_handled_ = false;
 
 bool TestExceptionExceptionBarrierHandler() {
   TestSEHChainSane();
   __try {
     CrashOnManualSEHBarrierHandler();
     return false;  // not reached
   } __except(EXCEPTION_ACCESS_VIOLATION == GetExceptionCode() ?
                       EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
     TestSEHChainSane();
     return true;
@@ skipping 112 matching lines @@
   } __except(EXCEPTION_EXECUTE_HANDLER) {
     // we should have unrolled to our frame by now
     if (GetTopRegistration() != my_top)
       return false;
   }
 
   return true;
 }
 
 void RecurseAndCrashOverBarrier(int depth, bool crash) {
-  ExceptionBarrier barrier;
+  ExceptionBarrierCustomHandler barrier;
 
   if (0 == depth) {
     if (crash)
       AccessViolationCrash();
   } else {
     RecurseAndCrashOverBarrier(depth - 1, crash);
   }
 }
 
 // Test that ExceptionBarrier doesn't molest the SEH chain, neither
@@ skipping 67 matching lines @@
   return TestRegularChaining(top) && TestExceptionBarrierChaining(top);
 }
 
 // Test that the SEH chain is unmolested by exception barrier, both under
 // regular unroll, and under exception unroll.
 TEST_F(ExceptionBarrierTest, SEHChainIsSaneAfterException) {
   EXPECT_TRUE(TestChaining());
 }
 
 }  // namespace