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"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/singleton.h"
 #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/system/core.h"
 
 namespace mojo {
 namespace dart {
 
 #define MOJO_NATIVE_LIST(V)                \
@@ skipping 697 matching lines @@
   Dart_ListSetAt(list, 1, Dart_NewInteger(blen));
   Dart_ListSetAt(list, 2, Dart_NewInteger(hlen));
   Dart_SetReturnValue(arguments, list);
 }
 
 struct 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();
 };
 
 // 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() {
+  return Singleton<MojoWaitManyState>::get();

[jamesr, 2015/10/09 23:42:32]

Singleton<> here is providing thread-safe initialization, which you don't need
as this code isn't threadsafe anyway. do this instead:

  static MojoWaitManyState* state = new MojoWaitManyState;
  return state;

and remove the //base/memory/singleton.h dependency

[jsimmons1, 2015/10/09 23:50:46]

Done.

+}
 
 void MojoHandleWatcher_GrowStateArrays(Dart_NativeArguments arguments) {
   int64_t new_length;
   CHECK_INTEGER_ARGUMENT(arguments, 0, &new_length, InvalidArgument);
 
-  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);
+  MojoWaitManyState* handle_watcher_wait_state =

[jamesr, 2015/10/09 23:42:32]

Make this a reference and you won't have to change the following lines. it can
never be null

[abarth-chromium, 2015/10/09 23:45:46]

If you make this a reference, please add DISALLOW_COPY_AND_ASSIGN to
MojoWaitManyState.  (You might want to do that anyway.)

[jsimmons1, 2015/10/09 23:50:46]

Done.

+      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());
+      Dart_TypedData_kUint32, handle_watcher_wait_state->handles.data(),
+      handle_watcher_wait_state->handles.size());
   if (Dart_IsError(dart_handles)) {
     Dart_PropagateError(dart_handles);
   }
   if (Dart_IsNull(dart_handles)) {
     SetNullReturn(arguments);
     return;
   }
 
   Dart_Handle dart_signals = Dart_NewExternalTypedData(
-      Dart_TypedData_kUint32, handle_watcher_wait_state.signals.data(),
-      handle_watcher_wait_state.signals.size());
+      Dart_TypedData_kUint32, handle_watcher_wait_state->signals.data(),
+      handle_watcher_wait_state->signals.size());
   if (Dart_IsError(dart_signals)) {
     Dart_PropagateError(dart_signals);
   }
   if (Dart_IsNull(dart_signals)) {
     SetNullReturn(arguments);
     return;
   }
 
   Dart_Handle dart_out_index = Dart_NewExternalTypedData(
-      Dart_TypedData_kUint32, handle_watcher_wait_state.out_index.data(),
-      handle_watcher_wait_state.out_index.size());
+      Dart_TypedData_kUint32, handle_watcher_wait_state->out_index.data(),
+      handle_watcher_wait_state->out_index.size());
   if (Dart_IsError(dart_out_index)) {
     Dart_PropagateError(dart_out_index);
   }
   if (Dart_IsNull(dart_out_index)) {
     SetNullReturn(arguments);
     return;
   }
 
   Dart_Handle dart_out_signals = Dart_NewExternalTypedData(
-      Dart_TypedData_kUint64, handle_watcher_wait_state.out_signals.data(),
-      handle_watcher_wait_state.out_signals.size());
+      Dart_TypedData_kUint64, handle_watcher_wait_state->out_signals.data(),
+      handle_watcher_wait_state->out_signals.size());
   if (Dart_IsError(dart_out_signals)) {
     Dart_PropagateError(dart_out_signals);
   }
   if (Dart_IsNull(dart_out_signals)) {
     SetNullReturn(arguments);
     return;
   }
 
   Dart_Handle list = Dart_NewList(4);
   Dart_ListSetAt(list, 0, dart_handles);
   Dart_ListSetAt(list, 1, dart_signals);
   Dart_ListSetAt(list, 2, dart_out_index);
   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);
 
-  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();
+  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();
+      handle_watcher_wait_state->out_signals.data();
 
   Dart_IsolateBlocked();
   MojoResult mojo_result = MojoWaitMany(handles, signals, handles_len, deadline,
                                         out_index, out_signals);
   Dart_IsolateUnblocked();
 
   Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(mojo_result));
 }
 
 struct ControlData {
@@ skipping 62 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