Remove a static initializer from ScopedCAPIHandle

crypto/scoped_capi_types.h

 // 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.
 
 #ifndef CRYPTO_SCOPED_CAPI_TYPES_H_
 #define CRYPTO_SCOPED_CAPI_TYPES_H_
 #pragma once
 
 #include <windows.h>
 #include <wincrypt.h>
@@ skipping 33 matching lines @@
 // scoped_ptr-like class for the CryptoAPI cryptography and certificate
 // handles. Because these handles are defined as integer types, and not
 // pointers, the existing scoped classes, such as scoped_ptr_malloc, are
 // insufficient. The semantics are the same as scoped_ptr.
 template <class CAPIHandle, typename FreeProc>
 class ScopedCAPIHandle {
  public:
   explicit ScopedCAPIHandle(CAPIHandle handle = NULL) : handle_(handle) {}
 
   ~ScopedCAPIHandle() {
-    free_(handle_);
+    reset();

[wtc, 2011/08/31 21:15:28]

Just to make sure I understand this correctly: this could
also be written as:
  FreeProc free_proc;
  free_proc(handle_);

Correct?

   }
 
   void reset(CAPIHandle handle = NULL) {
     if (handle_ != handle) {
-      free_(handle_);
+      FreeProc free_proc;
+      free_proc(handle_);
       handle_ = handle;
     }
   }
 
   operator CAPIHandle() const { return handle_; }
   CAPIHandle get() const { return handle_; }
 
   CAPIHandle* receive() {
     CHECK(handle_ == NULL);
     return &handle_;
@@ skipping 14 matching lines @@
   }
 
   CAPIHandle release() {
     CAPIHandle tmp = handle_;
     handle_ = NULL;
     return tmp;
   }
 
  private:
   CAPIHandle handle_;
-  static const FreeProc free_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedCAPIHandle);
 };
 
-template<class CH, typename FP>
-const FP ScopedCAPIHandle<CH, FP>::free_ = FP();
-
 template<class CH, typename FP> inline
 bool operator==(CH h, const ScopedCAPIHandle<CH, FP>& b) {
   return h == b.get();
 }
 
 template<class CH, typename FP> inline
 bool operator!=(CH h, const ScopedCAPIHandle<CH, FP>& b) {
   return h != b.get();
 }
 
 typedef ScopedCAPIHandle<
     HCRYPTPROV,
     CAPIDestroyerWithFlags<HCRYPTPROV,
                            CryptReleaseContext, 0> > ScopedHCRYPTPROV;
 
 typedef ScopedCAPIHandle<
     HCRYPTKEY, CAPIDestroyer<HCRYPTKEY, CryptDestroyKey> > ScopedHCRYPTKEY;
 
 typedef ScopedCAPIHandle<
     HCRYPTHASH, CAPIDestroyer<HCRYPTHASH, CryptDestroyHash> > ScopedHCRYPTHASH;
 
 }  // namespace crypto
 
 #endif  // CRYPTO_SCOPED_CAPI_TYPES_H_