Move a bunch of code from the old to new TLS interface.

chrome/common/ipc_sync_channel.cc

 // Copyright (c) 2006-2008 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 <windows.h>
 
 #include "chrome/common/ipc_sync_channel.h"
 
+#include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/thread_local_storage.h"
+#include "base/thread_local.h"
 #include "chrome/common/child_process.h"
 #include "chrome/common/ipc_logging.h"
 #include "chrome/common/ipc_sync_message.h"
 
 
 namespace IPC {
 // When we're blocked in a Send(), we need to process incoming synchronous
 // messages right away because it could be blocking our reply (either
 // directly from the same object we're calling, or indirectly through one or
 // more other channels).  That means that in SyncContext's OnMessageReceived,
 // we need to process sync message right away if we're blocked.  However a
 // simple check isn't sufficient, because the listener thread can be in the
 // process of calling Send.
 // To work around this, when SyncChannel filters a sync message, it sets
 // an event that the listener thread waits on during its Send() call.  This
 // allows us to dispatch incoming sync messages when blocked.  The race
 // condition is handled because if Send is in the process of being called, it
 // will check the event.  In case the listener thread isn't sending a message,
 // we queue a task on the listener thread to dispatch the received messages.
 // The messages are stored in this queue object that's shared among all
 // SyncChannel objects on the same thread (since one object can receive a
 // sync message while another one is blocked).
 
-// Holds a pointer to the per-thread ReceivedSyncMsgQueue object.
-// TODO(evanm): this shouldn't rely on static initialization.
-static TLSSlot g_tls_index;
+class SyncChannel::ReceivedSyncMsgQueue;
 
 class SyncChannel::ReceivedSyncMsgQueue :
     public base::RefCountedThreadSafe<ReceivedSyncMsgQueue> {
  public:
   ReceivedSyncMsgQueue() :
       blocking_event_(CreateEvent(NULL, FALSE, FALSE, NULL)),
       task_pending_(false),
       listener_message_loop_(MessageLoop::current()) {
   }
 
   ~ReceivedSyncMsgQueue() {
-    DCHECK(g_tls_index.Get());
+    DCHECK(lazy_tls_ptr_.Pointer()->Get());
     DCHECK(MessageLoop::current() == listener_message_loop_);
     CloseHandle(blocking_event_);
-    g_tls_index.Set(NULL);
+    lazy_tls_ptr_.Pointer()->Set(NULL);
   }
 
   // Called on IPC thread when a synchronous message or reply arrives.
   void QueueMessage(const Message& msg, Channel::Listener* listener,
                     const std::wstring& channel_id) {
     bool was_task_pending;
     {
       AutoLock auto_lock(message_lock_);
 
       was_task_pending = task_pending_;
@@ skipping 86 matching lines @@
 
     while (!temp_queue.empty()) {
       message_queue_.push(temp_queue.front());
       temp_queue.pop();
     }
   }
 
   HANDLE blocking_event() { return blocking_event_; }
   MessageLoop* listener_message_loop() { return listener_message_loop_; }
 
+  // Holds a pointer to the per-thread ReceivedSyncMsgQueue object.
+  static base::LazyInstance<base::ThreadLocalPointer<ReceivedSyncMsgQueue> >
+      lazy_tls_ptr_;
+
  private:
   // Called on the ipc thread to check if we can unblock any current Send()
   // calls based on a queued reply.
   void DispatchReplies() {
     for (size_t i = 0; i < received_replies_.size(); ++i) {
       Message* message = received_replies_[i].message;
       if (received_replies_[i].context->UnblockListener(message)) {
         delete message;
         received_replies_.erase(received_replies_.begin() + i);
         return;
@@ skipping 28 matching lines @@
         : message(m),
           context(c) { }
 
     Message* message;
     scoped_refptr<SyncChannel::SyncContext> context;
   };
 
   std::vector<Reply> received_replies_;
 };
 
+base::LazyInstance<base::ThreadLocalPointer<SyncChannel::ReceivedSyncMsgQueue> >
+    SyncChannel::ReceivedSyncMsgQueue::lazy_tls_ptr_(base::LINKER_INITIALIZED);
 
 SyncChannel::SyncContext::SyncContext(
     Channel::Listener* listener,
     MessageFilter* filter,
     MessageLoop* ipc_thread)
     : ChannelProxy::Context(listener, filter, ipc_thread),
       channel_closed_(false),
       reply_deserialize_result_(false) {
   // We want one ReceivedSyncMsgQueue per listener thread (i.e. since multiple
   // SyncChannel objects that can block the same thread).
-  received_sync_msgs_ = static_cast<ReceivedSyncMsgQueue*>(g_tls_index.Get());
+  received_sync_msgs_ = ReceivedSyncMsgQueue::lazy_tls_ptr_.Pointer()->Get();
 
   if (!received_sync_msgs_) {
     // Stash a pointer to the listener thread's ReceivedSyncMsgQueue, as we
     // need to be able to access it in the IPC thread.
     received_sync_msgs_ = new ReceivedSyncMsgQueue();
-    g_tls_index.Set(received_sync_msgs_);
+    ReceivedSyncMsgQueue::lazy_tls_ptr_.Pointer()->Set(received_sync_msgs_);
   }
 
   // Addref manually so that we can ensure destruction on the listener thread
   // (so that the TLS object is NULLd).
   received_sync_msgs_->AddRef();
 }
 
 SyncChannel::SyncContext::~SyncContext() {
   while (!deserializers_.empty())
     PopDeserializer(true);
@@ skipping 239 matching lines @@
     // or we time-out.
   } while (true);
 }
 
 bool SyncChannel::UnblockListener(Message* message) {
   return sync_context()->UnblockListener(message);
 }
 
 }  // namespace IPC