clang/win: Fix a few warnings/errors.

base/allocator/generic_allocators.cc

 // Copyright (c) 2009 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.
 
 // When possible, we implement allocator functions on top of the basic
 // low-level functions malloc() and free().  This way, including a new
 // allocator is as simple as providing just a small interface.
 //
 // As such, this file should not contain any allocator-specific code.
 
@@ skipping 10 matching lines @@
   }
   return ptr;
 }
 
 extern "C++" {
 
 void* operator new(size_t size) {
   return generic_cpp_alloc(size, false);
 }
 
-void operator delete(void* p) {
+void operator delete(void* p) throw() {
   free(p);
 }
 
 void* operator new[](size_t size) {
   return generic_cpp_alloc(size, false);
 }
 
-void operator delete[](void* p) {
+void operator delete[](void* p) throw() {
   free(p);
 }
 
 void* operator new(size_t size, const std::nothrow_t& nt) {
   return generic_cpp_alloc(size, true);
 }
 
-void operator delete(void* p, const std::nothrow_t& nt) {
+void operator delete(void* p, const std::nothrow_t& nt) throw() {
   free(p);
 }
 
 void* operator new[](size_t size, const std::nothrow_t& nt) {
   return generic_cpp_alloc(size, true);
 }
 
-void operator delete[](void* p, const std::nothrow_t& nt) {
+void operator delete[](void* p, const std::nothrow_t& nt) throw() {
   free(p);
 }
 
 // This function behaves similarly to MSVC's _set_new_mode.
 // If flag is 0 (default), calls to malloc will behave normally.
 // If flag is 1, calls to malloc will behave like calls to new,
 // and the std_new_handler will be invoked on failure.
 // Returns the previous mode.
 int _set_new_mode(int flag) throw() {
   int old_mode = new_mode;
@@ skipping 10 matching lines @@
   const size_t size = n * elem_size;
   if (elem_size != 0 && size / elem_size != n) return NULL;
 
   void* result = malloc(size);
   if (result != NULL) {
     memset(result, 0, size);
   }
   return result;
 }
 
-void cfree(void* p) {
-  free(p);
-}
-
 #ifdef WIN32
 
 void* _recalloc(void* p, size_t n, size_t elem_size) {
   if (!p)
     return calloc(n, elem_size);
 
   // This API is a bit odd.
   // Note: recalloc only guarantees zeroed memory when p is NULL.
   //   Generally, calls to malloc() have padding.  So a request
   //   to malloc N bytes actually malloc's N+x bytes.  Later, if
@@ skipping 67 matching lines @@
 
 void* _calloc_dbg(size_t n, size_t size, int, const char*, int) {
   return calloc(n, size);
 }
 #endif  // NDEBUG
 
 #endif  // WIN32
 
 }  // extern C