Remove static initializer in dummy_event

ipc/ipc_sync_message.cc

 // Copyright (c) 2011 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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 #include <stack>
 
 #include "base/atomic_sequence_num.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/synchronization/waitable_event.h"
 #include "ipc/ipc_sync_message.h"
 
+namespace {
+
+struct WaitableEventLazyInstanceTraits
+    : public base::DefaultLazyInstanceTraits<base::WaitableEvent> {
+  static base::WaitableEvent* New(void* instance) {
+    // Use placement new to initialize our instance in our preallocated space.
+    return new (instance) base::WaitableEvent(true, true);
+  }
+};
+
+static base::LazyInstance<base::WaitableEvent, WaitableEventLazyInstanceTraits>

[Nico, 2012/02/03 23:02:16]

Can you make this ::Lazy? As is, this adds an exit time destructor call to at
atexit() time, which is kind of like a static initializer in reverse.

+    dummy_event = LAZY_INSTANCE_INITIALIZER;
+
+}
+
 namespace IPC {
 
 #define kSyncMessageHeaderSize 4
 
 static base::AtomicSequenceNumber g_next_id(base::LINKER_INITIALIZED);
 
-static base::WaitableEvent* dummy_event = new base::WaitableEvent(true, true);
-
 SyncMessage::SyncMessage(
     int32 routing_id,
     uint32 type,
     PriorityValue priority,
     MessageReplyDeserializer* deserializer)
     : Message(routing_id, type, priority),
       deserializer_(deserializer),
       pump_messages_event_(NULL)
       {
   set_sync();
   set_unblock(true);
 
   // Add synchronous message data before the message payload.
   SyncHeader header;
   header.message_id = g_next_id.GetNext();
   WriteSyncHeader(this, header);
 }
 
 SyncMessage::~SyncMessage() {
 }
 
 MessageReplyDeserializer* SyncMessage::GetReplyDeserializer() {
   DCHECK(deserializer_.get());
   return deserializer_.release();
 }
 
 void SyncMessage::EnableMessagePumping() {
   DCHECK(!pump_messages_event_);
-  set_pump_messages_event(dummy_event);
+  set_pump_messages_event(dummy_event.Pointer());
 }
 
 bool SyncMessage::IsMessageReplyTo(const Message& msg, int request_id) {
   if (!msg.is_reply())
     return false;
 
   return GetMessageId(msg) == request_id;
 }
 
 void* SyncMessage::GetDataIterator(const Message* msg) {
@@ skipping 56 matching lines @@
 
   return true;
 }
 
 
 bool MessageReplyDeserializer::SerializeOutputParameters(const Message& msg) {
   return SerializeOutputParameters(msg, SyncMessage::GetDataIterator(&msg));
 }
 
 }  // namespace IPC