CrOs: Remove 29 exit time destructors and 8 static initializers.

chrome/browser/chromeos/web_socket_proxy.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 "chrome/browser/chromeos/web_socket_proxy.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
 #include <list>
 #include <map>
 #include <vector>
 
 #include <arpa/inet.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <netinet/in.h>
 #include <signal.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "chrome/browser/internal_auth.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/url_constants.h"
@@ skipping 415 matching lines @@
   bool do_tls_;
 
   // We try to DNS resolve hostname in both IPv4 and IPv6 domains.
   // Track resolution failures here.
   bool destresolution_ipv4_failed_;
   bool destresolution_ipv6_failed_;
 
   // Used to schedule a timeout for initial phase of connection.
   scoped_ptr<struct event> destconnect_timeout_event_;
 
-  static EventKeyMap evkey_map_;
+  static base::LazyInstance<EventKeyMap,
+                            base::LeakyLazyInstanceTraits<EventKeyMap> >
+      evkey_map_;
   static EventKey last_evkey_;
 
   DISALLOW_COPY_AND_ASSIGN(Conn);
 };
 
 class SSLChan : public MessageLoopForIO::Watcher {
  public:
   static void Start(const net::AddressList& address_list,
                     const net::HostPortPair& host_port_pair,
                     int read_pipe,
@@ skipping 660 matching lines @@
 Conn::Conn(Serv* master)
     : master_(master),
       phase_(PHASE_WAIT_HANDSHAKE),
       frame_bytes_remaining_(0),
       frame_mask_index_(0),
       primchan_(this),
       destchan_(this),
       do_tls_(false),
       destresolution_ipv4_failed_(false),
       destresolution_ipv6_failed_(false) {
-  while (evkey_map_.find(last_evkey_) != evkey_map_.end()) {
+  while (evkey_map_.Get().find(last_evkey_) != evkey_map_.Get().end()) {
     last_evkey_ = reinterpret_cast<EventKey>(reinterpret_cast<size_t>(
         last_evkey_) + 1);
   }
   evkey_ = last_evkey_;
-  evkey_map_[evkey_] = this;
+  evkey_map_.Get()[evkey_] = this;
   // Schedule timeout for initial phase of connection.
   destconnect_timeout_event_.reset(new struct event);
   evtimer_set(destconnect_timeout_event_.get(),
               &OnDestConnectTimeout, evkey_);
   event_base_set(master_->evbase(),
                  destconnect_timeout_event_.get());
 
   struct timeval tv;
   tv.tv_sec = 20;
   tv.tv_usec = 0;
   evtimer_add(destconnect_timeout_event_.get(), &tv);
 }
 
 Conn::~Conn() {
   phase_ = PHASE_DEFUNCT;
   event_del(destconnect_timeout_event_.get());
-  if (evkey_map_[evkey_] == this)
-    evkey_map_.erase(evkey_);
+  if (evkey_map_.Get()[evkey_] == this)
+    evkey_map_.Get().erase(evkey_);
   else
     NOTREACHED();
 }
 
 Conn* Conn::Get(EventKey evkey) {
-  EventKeyMap::iterator it = evkey_map_.find(evkey);
-  if (it == evkey_map_.end())
+  EventKeyMap::iterator it = evkey_map_.Get().find(evkey);
+  if (it == evkey_map_.Get().end())
     return NULL;
   Conn* cs = it->second;
   if (cs == NULL ||
       cs->evkey_ != evkey ||
       cs->master_ == NULL ||
       cs->phase_ < 0 ||
       cs->phase_ > PHASE_SHUT ||
       !cs->master_->IsConnSane(cs)) {
     return NULL;
   }
@@ skipping 716 matching lines @@
     return;
   }
   cs->destchan_.set_write_pending(false);
   if (cs->phase_ >= PHASE_SHUT)
     cs->master_->ZapConn(cs);
   else
     cs->Shut(WS_CLOSE_DESTINATION_ERROR,
              "Failure reported on destination channel");
 }
 
+// static
 Conn::EventKey Conn::last_evkey_ = 0;
-Conn::EventKeyMap Conn::evkey_map_;
+
+// static
+base::LazyInstance<Conn::EventKeyMap,
+                   base::LeakyLazyInstanceTraits<Conn::EventKeyMap> >
+    Conn::evkey_map_ = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 WebSocketProxy::WebSocketProxy(const std::vector<std::string>& allowed_origins)
     : impl_(new Serv(allowed_origins)) {
 }
 
 WebSocketProxy::~WebSocketProxy() {
   delete static_cast<Serv*>(impl_);
   impl_ = NULL;
 }
 
 void WebSocketProxy::Run() {
   static_cast<Serv*>(impl_)->Run();
 }
 
 void WebSocketProxy::Shutdown() {
   static_cast<Serv*>(impl_)->Shutdown();
 }
 
 void WebSocketProxy::OnNetworkChange() {
   static_cast<Serv*>(impl_)->OnNetworkChange();
 }
 
 }  // namespace chromeos