Fix base:: namespace for Lock.

tools/memory_watcher/call_stack.cc

 // Copyright (c) 2010 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 "tools/memory_watcher/call_stack.h"
 
 #include <shlwapi.h>
 #include <tlhelp32.h>
 
 #include "base/string_number_conversions.h"
@@ skipping 17 matching lines @@
 typedef BOOL (__stdcall *t_SymInitialize)(HANDLE, PCTSTR, BOOL);
 typedef DWORD (__stdcall *t_SymGetOptions)(void);
 typedef DWORD (__stdcall *t_SymSetOptions)(DWORD);
 typedef BOOL (__stdcall *t_SymGetSearchPath)(HANDLE, PTSTR, DWORD);
 typedef DWORD64 (__stdcall *t_SymLoadModule64)(HANDLE, HANDLE, PCSTR,
                                                PCSTR, DWORD64, DWORD);
 typedef BOOL (__stdcall *t_SymGetModuleInfo64)(HANDLE, DWORD64,
                                                PIMAGEHLP_MODULE64);
 
 // static
-Lock CallStack::dbghelp_lock_;
+base:Lock CallStack::dbghelp_lock_;
 // static
 bool CallStack::dbghelp_loaded_ = false;
 // static
 DWORD CallStack::active_thread_id_ = 0;
 
 
 static t_StackWalk64 pStackWalk64 = NULL;
 static t_SymCleanup pSymCleanup = NULL;
 static t_SymGetSymFromAddr64 pSymGetSymFromAddr64 = NULL;
 static t_SymFunctionTableAccess64 pSymFunctionTableAccess64 = NULL;
@@ skipping 317 matching lines @@
       }
     }
 
     (*symbol_cache_)[intruction_pointer] = line;
     *output += line;
   }
   *output += "==================\n";
 }
 
 
-Lock AllocationStack::freelist_lock_;
+base::Lock AllocationStack::freelist_lock_;
 AllocationStack* AllocationStack::freelist_ = NULL;
 
 void* AllocationStack::operator new(size_t size) {
   DCHECK(size == sizeof(AllocationStack));
   {
     base::AutoLock lock(freelist_lock_);
     if (freelist_ != NULL) {
       AllocationStack* stack = freelist_;
       freelist_ = freelist_->next_;
       stack->next_ = NULL;
       return stack;
     }
   }
   return MemoryHook::Alloc(size);
 }
 
 void AllocationStack::operator delete(void* ptr) {
   AllocationStack *stack = reinterpret_cast<AllocationStack*>(ptr);
   base::AutoLock lock(freelist_lock_);
   DCHECK(stack->next_ == NULL);
   stack->next_ = freelist_;
   freelist_ = stack;
 }