Dart: Removes C++ set for closing handles on an unhandled exception.

mojo/dart/embedder/test/dart_to_cpp_tests.cc

 // Copyright 2014 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 "base/at_exit.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 254 matching lines @@
     // join while handles are still open, until the C++ side closes them.
     base::Thread dart_thread("dart");
     cpp_side->set_run_loop(&run_loop_);
     return RunWithDartOnThread(&dart_thread, test, cpp_side);
   }
 
  private:
   base::MessageLoop loop;
   base::RunLoop run_loop_;
 
-  static void UnhandledExceptionCallback(bool* exception, Dart_Handle error) {
+  static void UnhandledExceptionCallback(bool* exception,
+                                         int64_t* closed_handles,
+                                         Dart_Handle error,
+                                         int64_t count) {
     *exception = true;
+    *closed_handles = count;
   }
 
   static bool GenerateEntropy(uint8_t* buffer, intptr_t length) {
     base::RandBytes(reinterpret_cast<void*>(buffer), length);
     return true;
   }
 
   static void InitializeDartConfig(DartControllerConfig* config,
                                    const std::string& test,
                                    MojoHandle handle,
                                    const char** arguments,
                                    int arguments_count,
                                    bool* unhandled_exception,
+                                   int64_t* closed_handles,
                                    char** error) {
     base::FilePath path;
     PathService::Get(base::DIR_SOURCE_ROOT, &path);
     path = path.AppendASCII("mojo")
                .AppendASCII("dart")
                .AppendASCII("embedder")
                .AppendASCII("test")
                .AppendASCII(test);
 
     // Setup the package root.
     base::FilePath package_root;
     PathService::Get(base::DIR_EXE, &package_root);
     package_root = package_root.AppendASCII("gen")
                                .AppendASCII("dart-pkg")
                                .AppendASCII("packages");
 
 
     config->strict_compilation = true;
     config->script_uri = path.AsUTF8Unsafe();
     config->package_root = package_root.AsUTF8Unsafe();
-    config->callbacks.exception =
-        base::Bind(&UnhandledExceptionCallback, unhandled_exception);
+    config->callbacks.exception = base::Bind(
+        &UnhandledExceptionCallback, unhandled_exception, closed_handles);
     config->entropy = GenerateEntropy;
     config->handle = handle;
     config->SetVmFlags(arguments, arguments_count);
     config->error = error;
   }
 
   static void RunDartSide(const DartControllerConfig& config) {
     DartController::RunSingleDartScript(config);
   }
 
   bool RunWithDartOnThread(base::Thread* dart_thread,
                            const std::string& test,
                            CppSideConnection* cpp_side) {
     dart_to_cpp::DartSidePtr dart_side_ptr;
     auto dart_side_request = GetProxy(&dart_side_ptr);
 
     dart_to_cpp::CppSidePtr cpp_side_ptr;
     cpp_side->Bind(GetProxy(&cpp_side_ptr));
     dart_side_ptr->SetClient(cpp_side_ptr.Pass());
 
     dart_side_ptr.internal_state()->router_for_testing()->EnableTestingMode();
 
     cpp_side->set_dart_side(dart_side_ptr.get());
 
     DartControllerConfig config;
     char* error;
     bool unhandled_exception = false;
+    int64_t closed_handles;
     InitializeDartConfig(
-        &config,
-        test,
-        dart_side_request.PassMessagePipe().release().value(),
-        nullptr,
-        0,
-        &unhandled_exception,
-        &error);
+        &config, test, dart_side_request.PassMessagePipe().release().value(),
+        nullptr, 0, &unhandled_exception, &closed_handles, &error);
 
     dart_thread->Start();
     dart_thread->message_loop()->PostTask(FROM_HERE,
         base::Bind(&RunDartSide, base::ConstRef(config)));
 
     run_loop_.Run();
     return unhandled_exception;
   }
 
   DISALLOW_COPY_AND_ASSIGN(DartToCppTest);
@@ skipping 10 matching lines @@
 TEST_F(DartToCppTest, Echo) {
   EchoCppSideConnection cpp_side_connection;
   bool unhandled_exception =
       RunTest("dart_to_cpp_tests.dart", &cpp_side_connection);
   EXPECT_TRUE(cpp_side_connection.DidSucceed());
   EXPECT_FALSE(unhandled_exception);
 }
 
 }  // namespace dart
 }  // namespace mojo