Use a singleton instead of a global for MojoWaitManyState

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 <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 705 matching lines @@
   }
 
   Dart_Handle list = Dart_NewList(3);
   Dart_ListSetAt(list, 0, Dart_NewInteger(res));
   Dart_ListSetAt(list, 1, Dart_NewInteger(blen));
   Dart_ListSetAt(list, 2, Dart_NewInteger(hlen));
   Dart_SetReturnValue(arguments, list);
 }
 
 struct MojoWaitManyState {
+  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);
 };
 
 // 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.
-static MojoWaitManyState handle_watcher_wait_state;
+MojoWaitManyState* MojoWaitManyState::GetInstance() {
+  static MojoWaitManyState* state = new MojoWaitManyState;
+  return state;
+}
 
 void MojoHandleWatcher_GrowStateArrays(Dart_NativeArguments arguments) {
   int64_t new_length;
   CHECK_INTEGER_ARGUMENT(arguments, 0, &new_length, InvalidArgument);
 
+  MojoWaitManyState& handle_watcher_wait_state =
+      *MojoWaitManyState::GetInstance();
+
   handle_watcher_wait_state.handles.resize(new_length);
   handle_watcher_wait_state.signals.resize(new_length);
   handle_watcher_wait_state.out_index.resize(1);
   handle_watcher_wait_state.out_signals.resize(new_length);
 
   Dart_Handle dart_handles = Dart_NewExternalTypedData(
       Dart_TypedData_kUint32, handle_watcher_wait_state.handles.data(),
       handle_watcher_wait_state.handles.size());
   if (Dart_IsError(dart_handles)) {
     Dart_PropagateError(dart_handles);
@@ skipping 43 matching lines @@
   Dart_ListSetAt(list, 3, dart_out_signals);
   Dart_SetReturnValue(arguments, list);
 }
 
 void MojoHandleWatcher_WaitMany(Dart_NativeArguments arguments) {
   int64_t handles_len = 0;
   int64_t deadline = 0;
   CHECK_INTEGER_ARGUMENT(arguments, 0, &handles_len, InvalidArgument);
   CHECK_INTEGER_ARGUMENT(arguments, 1, &deadline, InvalidArgument);
 
+  MojoWaitManyState& handle_watcher_wait_state =
+      *MojoWaitManyState::GetInstance();
+
   uint32_t* handles = handle_watcher_wait_state.handles.data();
   uint32_t* signals = handle_watcher_wait_state.signals.data();
   uint32_t* out_index = handle_watcher_wait_state.out_index.data();
   MojoHandleSignalsState* out_signals =
       handle_watcher_wait_state.out_signals.data();
 
   Dart_IsolateBlocked();
   MojoResult mojo_result = MojoWaitMany(handles, signals, handles_len, deadline,
                                         out_index, out_signals);
   Dart_IsolateUnblocked();
@@ skipping 67 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