Move Singleton and related structs to namespace base

base/trace_event/winheap_dump_provider_win.cc

 // Copyright 2015 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 "base/trace_event/winheap_dump_provider_win.h"
 
 #include <windows.h>
 
 #include "base/debug/profiler.h"
 #include "base/strings/string_util.h"
@@ skipping 25 matching lines @@
                         MemoryAllocatorDump::kUnitsBytes,
                         heap_info.allocated_size);
   inner_dump->AddScalar(MemoryAllocatorDump::kNameObjectsCount,
                         MemoryAllocatorDump::kUnitsObjects,
                         heap_info.block_count);
 }
 
 }  // namespace
 
 WinHeapDumpProvider* WinHeapDumpProvider::GetInstance() {
-  return Singleton<WinHeapDumpProvider,
-                   LeakySingletonTraits<WinHeapDumpProvider>>::get();
+  return base::Singleton<WinHeapDumpProvider,
+                   base::LeakySingletonTraits<WinHeapDumpProvider>>::get();
 }
 
 bool WinHeapDumpProvider::OnMemoryDump(const MemoryDumpArgs& args,
                                        ProcessMemoryDump* pmd) {
   // This method might be flaky for 2 reasons:
   //   - GetProcessHeaps is racy by design. It returns a snapshot of the
   //     available heaps, but there's no guarantee that that snapshot remains
   //     valid. If a heap disappears between GetProcessHeaps() and HeapWalk()
   //     then chaos should be assumed. This flakyness is acceptable for tracing.
   //   - The MSDN page for HeapLock says: "If the HeapLock function is called on
@@ skipping 62 matching lines @@
     } else if ((heap_entry.wFlags & PROCESS_HEAP_REGION) != 0) {
       heap_info->committed_size += heap_entry.Region.dwCommittedSize;
     }
   }
   CHECK(::HeapUnlock(heap_info->heap_id) == TRUE);
   return true;
 }
 
 }  // namespace trace_event
 }  // namespace base