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

mojo/dart/embedder/mojo_natives.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 <stdio.h>
 #include <string.h>
 
 #include <memory>
-#include <set>
 #include <vector>
 
 #include "dart/runtime/include/dart_api.h"
 #include "mojo/dart/embedder/builtin.h"
-#include "mojo/dart/embedder/mojo_dart_state.h"
 #include "mojo/public/c/system/core.h"
 #include "mojo/public/cpp/environment/logging.h"
 #include "mojo/public/cpp/system/core.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 namespace dart {
 
 #define MOJO_NATIVE_LIST(V)                \
   V(MojoSharedBuffer_Create, 2)            \
   V(MojoSharedBuffer_Duplicate, 2)         \
   V(MojoSharedBuffer_Map, 5)               \
   V(MojoSharedBuffer_Unmap, 1)             \
   V(MojoDataPipe_Create, 3)                \
   V(MojoDataPipe_WriteData, 4)             \
   V(MojoDataPipe_BeginWriteData, 3)        \
   V(MojoDataPipe_EndWriteData, 2)          \
   V(MojoDataPipe_ReadData, 4)              \
   V(MojoDataPipe_BeginReadData, 3)         \
   V(MojoDataPipe_EndReadData, 2)           \
   V(MojoMessagePipe_Create, 1)             \
   V(MojoMessagePipe_Write, 5)              \
   V(MojoMessagePipe_Read, 5)               \
   V(Mojo_GetTimeTicksNow, 0)               \
   V(MojoHandle_Close, 1)                   \
   V(MojoHandle_Wait, 3)                    \
-  V(MojoHandle_Register, 2)                \
+  V(MojoHandle_RegisterFinalizer, 2)       \
   V(MojoHandle_WaitMany, 3)                \
   V(MojoHandleWatcher_GrowStateArrays, 1)  \
   V(MojoHandleWatcher_WaitMany, 2)         \
   V(MojoHandleWatcher_SendControlData, 4)  \
   V(MojoHandleWatcher_RecvControlData, 1)  \
   V(MojoHandleWatcher_SetControlHandle, 1) \
   V(MojoHandleWatcher_GetControlHandle, 0)
 
 MOJO_NATIVE_LIST(DECLARE_FUNCTION);
 
@@ skipping 78 matching lines @@
       // the handle has leaked from the Dart code, which is an error.
       MOJO_LOG(ERROR) << "Handle Finalizer closing handle:\n\tisolate: "
                       << "\n\thandle: " << callback_peer->handle;
     }
   }
   delete callback_peer;
 }
 
 // Setup a weak persistent handle for a MojoHandle that calls MojoClose on the
 // handle when the MojoHandle is GC'd or the VM is going down.
-void MojoHandle_Register(Dart_NativeArguments arguments) {
+void MojoHandle_RegisterFinalizer(Dart_NativeArguments arguments) {
   Dart_Handle mojo_handle_instance = Dart_GetNativeArgument(arguments, 0);
   if (!Dart_IsInstance(mojo_handle_instance)) {
     SetInvalidArgumentReturn(arguments);
     return;
   }
 
   int64_t raw_handle = static_cast<int64_t>(MOJO_HANDLE_INVALID);
   CHECK_INTEGER_ARGUMENT(arguments, 1, &raw_handle, InvalidArgument);
   if (raw_handle == static_cast<int64_t>(MOJO_HANDLE_INVALID)) {
     SetInvalidArgumentReturn(arguments);
     return;
   }
 
   // Add the handle to this isolate's set.
   MojoHandle handle = static_cast<MojoHandle>(raw_handle);
-  auto isolate_data = MojoDartState::Current();
-  assert(isolate_data != nullptr);
-  isolate_data->unclosed_handles().insert(handle);
 
   // Set up a finalizer.
   CloserCallbackPeer* callback_peer = new CloserCallbackPeer();
   callback_peer->handle = handle;
   Dart_NewWeakPersistentHandle(mojo_handle_instance,
                                reinterpret_cast<void*>(callback_peer),
                                sizeof(CloserCallbackPeer),
                                MojoHandleCloserCallback);
   Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(MOJO_RESULT_OK));
 }
 
 void Mojo_GetTimeTicksNow(Dart_NativeArguments arguments) {
   MojoTimeTicks ticks = MojoGetTimeTicksNow();
   Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(ticks));
 }
 
 void MojoHandle_Close(Dart_NativeArguments arguments) {
   int64_t raw_handle;
   CHECK_INTEGER_ARGUMENT(arguments, 0, &raw_handle, InvalidArgument);
 
   // Remove the handle from this isolate's set.
   MojoHandle handle = static_cast<MojoHandle>(raw_handle);
-  auto isolate_data = MojoDartState::Current();
-  assert(isolate_data != nullptr);
-  isolate_data->unclosed_handles().erase(handle);
-
   MojoResult res = MojoClose(handle);
 
   Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(res));
 }
 
 void MojoHandle_Wait(Dart_NativeArguments arguments) {
   int64_t handle = 0;
   int64_t signals = 0;
   int64_t deadline = 0;
   CHECK_INTEGER_ARGUMENT(arguments, 0, &handle, InvalidArgument);
@@ skipping 532 matching lines @@
   MojoWaitManyState() {}
 
   std::vector<uint32_t> handles;
   std::vector<uint32_t> signals;
   std::vector<uint32_t> out_index;
   std::vector<MojoHandleSignalsState> out_signals;
 
   static MojoWaitManyState* GetInstance();
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(MojoWaitManyState);
+  MOJO_DISALLOW_COPY_AND_ASSIGN(MojoWaitManyState);
 };
 
 // This global is safe because it is only accessed by the single handle watcher
 // isolate. If multiple handle watcher isolates are ever needed, it will need
 // to be replicated.
 MojoWaitManyState* MojoWaitManyState::GetInstance() {
   static MojoWaitManyState* state = new MojoWaitManyState;
   return state;
 }
 
@@ skipping 150 matching lines @@
   mojo_control_handle = control_handle;
   Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(MOJO_RESULT_OK));
 }
 
 void MojoHandleWatcher_GetControlHandle(Dart_NativeArguments arguments) {
   Dart_SetIntegerReturnValue(arguments, mojo_control_handle);
 }
 
 }  // namespace dart
 }  // namespace mojo