Remove 13 exit time constructors and 3 static initializers

printing/pdf_metafile_cg_mac.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 "printing/pdf_metafile_cg_mac.h"
 
 #include "base/file_path.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/sys_string_conversions.h"
 #include "base/threading/thread_local.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 using base::mac::ScopedCFTypeRef;
 
 namespace {
 
 // What is up with this ugly hack? <http://crbug.com/64641>, that's what.
 // The bug: Printing certain PDFs crashes. The cause: When printing, the
 // renderer process assembles pages one at a time, in PDF format, to send to the
 // browser process. When printing a PDF, the PDF plugin returns output in PDF
 // format. There is a bug in 10.5 and 10.6 (<rdar://9018916>,
 // <http://www.openradar.me/9018916>) where reference counting is broken when
 // drawing certain PDFs into PDF contexts. So at the high-level, a PdfMetafileCg
 // is used to hold the destination context, and then about five layers down on
 // the callstack, a PdfMetafileCg is used to hold the source PDF. If the source
 // PDF is drawn into the destination PDF context and then released, accessing
 // the destination PDF context will crash. So the outermost instantiation of
 // PdfMetafileCg creates a pool for deeper instantiations to dump their used
 // PDFs into rather than releasing them. When the top-level PDF is closed, then
 // it's safe to clear the pool. A thread local is used to allow this to work in
 // single-process mode. TODO(avi): This Apple bug appears fixed in 10.7; when
 // 10.7 is the minimum required version for Chromium, remove this hack.
 
-base::ThreadLocalPointer<struct __CFSet> thread_pdf_docs;
+base::LazyInstance<
+    base::ThreadLocalPointer<struct __CFSet>,
+    base::LeakyLazyInstanceTraits<base::ThreadLocalPointer<struct __CFSet> > >
+        thread_pdf_docs(base::LINKER_INITIALIZED);
 
 }  // namespace
 
 namespace printing {
 
 PdfMetafileCg::PdfMetafileCg()
     : page_is_open_(false),
       thread_pdf_docs_owned_(false) {
-  if (!thread_pdf_docs.Get() && base::mac::IsOSSnowLeopardOrEarlier()) {
+  if (!thread_pdf_docs.Pointer()->Get() &&
+      base::mac::IsOSSnowLeopardOrEarlier()) {
     thread_pdf_docs_owned_ = true;
-    thread_pdf_docs.Set(CFSetCreateMutable(kCFAllocatorDefault,
-                                           0,
-                                           &kCFTypeSetCallBacks));
+    thread_pdf_docs.Pointer()->Set(
+        CFSetCreateMutable(kCFAllocatorDefault, 0, &kCFTypeSetCallBacks));
   }
 }
 
 PdfMetafileCg::~PdfMetafileCg() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (pdf_doc_ && thread_pdf_docs.Get()) {
+  if (pdf_doc_ && thread_pdf_docs.Pointer()->Get()) {
     // Transfer ownership to the pool.
-    CFSetAddValue(thread_pdf_docs.Get(), pdf_doc_);
+    CFSetAddValue(thread_pdf_docs.Pointer()->Get(), pdf_doc_);
   }
 
   if (thread_pdf_docs_owned_) {
-    CFRelease(thread_pdf_docs.Get());
-    thread_pdf_docs.Set(NULL);
+    CFRelease(thread_pdf_docs.Pointer()->Get());
+    thread_pdf_docs.Pointer()->Set(NULL);
   }
 }
 
 bool PdfMetafileCg::Init() {
   // Ensure that Init hasn't already been called.
   DCHECK(!context_.get());
   DCHECK(!pdf_data_.get());
 
   pdf_data_.reset(CFDataCreateMutable(kCFAllocatorDefault, 0));
   if (!pdf_data_.get()) {
@@ skipping 217 matching lines @@
 
   if (!pdf_doc_.get()) {
     ScopedCFTypeRef<CGDataProviderRef> pdf_data_provider(
         CGDataProviderCreateWithCFData(pdf_data_));
     pdf_doc_.reset(CGPDFDocumentCreateWithProvider(pdf_data_provider));
   }
   return pdf_doc_.get();
 }
 
 }  // namespace printing