chrome: Remove 11 exit time destructors and 4 static initializers.

chrome/browser/ui/webui/chrome_url_data_manager.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/ui/webui/chrome_url_data_manager.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
+#include "base/lazy_instance.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/synchronization/lock.h"
 #include "base/values.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager_backend.h"
 #include "content/public/browser/browser_thread.h"
 #include "grit/platform_locale_settings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 using content::BrowserThread;
 
-// static
-base::Lock ChromeURLDataManager::delete_lock_;
+static base::LazyInstance<base::Lock,
+                          base::LeakyLazyInstanceTraits<base::Lock> >
+    g_delete_lock = LAZY_INSTANCE_INITIALIZER;
 
 // static
 ChromeURLDataManager::DataSources* ChromeURLDataManager::data_sources_ = NULL;
 
 // Invoked on the IO thread to do the actual adding of the DataSource.
 static void AddDataSourceOnIOThread(
     const base::Callback<ChromeURLDataManagerBackend*(void)>& backend,
     scoped_refptr<ChromeURLDataManager::DataSource> data_source) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   backend.Run()->AddDataSource(data_source.get());
@@ skipping 13 matching lines @@
       BrowserThread::IO, FROM_HERE,
       base::Bind(&AddDataSourceOnIOThread,
                  backend_, make_scoped_refptr(source)));
 }
 
 // static
 void ChromeURLDataManager::DeleteDataSources() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DataSources sources;
   {
-    base::AutoLock lock(delete_lock_);
+    base::AutoLock lock(g_delete_lock.Get());
     if (!data_sources_)
       return;
     data_sources_->swap(sources);
   }
   for (size_t i = 0; i < sources.size(); ++i)
     delete sources[i];
 }
 
 // static
 void ChromeURLDataManager::DeleteDataSource(const DataSource* data_source) {
   // Invoked when a DataSource is no longer referenced and needs to be deleted.
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     // We're on the UI thread, delete right away.
     delete data_source;
     return;
   }
 
   // We're not on the UI thread, add the DataSource to the list of DataSources
   // to delete.
   bool schedule_delete = false;
   {
-    base::AutoLock lock(delete_lock_);
+    base::AutoLock lock(g_delete_lock.Get());
     if (!data_sources_)
       data_sources_ = new DataSources();
     schedule_delete = data_sources_->empty();
     data_sources_->push_back(data_source);
   }
   if (schedule_delete) {
     // Schedule a task to delete the DataSource back on the UI thread.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&ChromeURLDataManager::DeleteDataSources));
   }
 }
 
 // static
 bool ChromeURLDataManager::IsScheduledForDeletion(
     const DataSource* data_source) {
-  base::AutoLock lock(delete_lock_);
+  base::AutoLock lock(g_delete_lock.Get());
   if (!data_sources_)
     return false;
   return std::find(data_sources_->begin(), data_sources_->end(), data_source) !=
       data_sources_->end();
 }
 
 ChromeURLDataManager::DataSource::DataSource(const std::string& source_name,
                                              MessageLoop* message_loop)
     : source_name_(source_name),
       message_loop_(message_loop),
@@ skipping 56 matching lines @@
       base::i18n::IsRTL() ? "rtl" : "ltr");
 }
 
 void ChromeURLDataManager::DataSource::SendResponseOnIOThread(
     int request_id,
     scoped_refptr<RefCountedMemory> bytes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (backend_)
     backend_->DataAvailable(request_id, bytes);
 }