Rename all methods accessing Singleton<T> as GetInstance().

ceee/common/process_utils_win.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.
 //
 // Utilities for windows process and threads stuff.
 
 #include "ceee/common/process_utils_win.h"
 
 #include <sddl.h>
 
@@ skipping 112 matching lines @@
 
 ProcessCompatibilityCheck::ProcessCompatibilityCheck()
     : initialization_result_(E_FAIL),
       running_on_amd64_platform_(false),
       running_as_wow_64_(false),
       integrity_checks_on_(false),
       running_integrity_(base::INTEGRITY_UNKNOWN) {
   StandardInitialize();
 }
 
+// static
+ProcessCompatibilityCheck* ProcessCompatibilityCheck::GetInstance() {
+  return Singleton<ProcessCompatibilityCheck>::get();
+}
+
 void ProcessCompatibilityCheck::StandardInitialize() {
   HRESULT hr = S_OK;
 
   SYSTEM_INFO system_info;
   ::GetNativeSystemInfo(&system_info);
 
   bool system_with_integrity_checks =
       base::win::GetVersion() >= base::win::VERSION_VISTA;
 
   base::IntegrityLevel integrity_level = base::INTEGRITY_UNKNOWN;
@@ skipping 49 matching lines @@
   DWORD process_id = 0;
   if (::GetWindowThreadProcessId(process_window, &process_id) != 0) {
     return IsCompatible(process_id, is_compatible);
   }
 
   return E_FAIL;
 }
 
 HRESULT ProcessCompatibilityCheck::IsCompatible(DWORD process_id,
                                                 bool* is_compatible) {
-  ProcessCompatibilityCheck* instance
-      = Singleton<ProcessCompatibilityCheck>::get();
+  ProcessCompatibilityCheck* instance = GetInstance();
 
   DCHECK(instance != NULL);
   DCHECK(is_compatible != NULL);
 
   if (instance != NULL && SUCCEEDED(instance->initialization_result_)) {
     return instance->IsProcessCompatible(process_id, is_compatible);
   }
 
   return instance != NULL ? instance->initialization_result_ : E_FAIL;
 }
@@ skipping 85 matching lines @@
 // Patching affects both static pointers and the state of the sigleton.
 // To update the later, required variables are forwarded to its
 // KnownStateInitialize.
 void ProcessCompatibilityCheck::PatchState(
     WORD system_type, bool current_process_wow64,
     bool check_integrity, base::IntegrityLevel current_process_integrity,
     OpenProcessFuncType open_process_func,
     CloseHandleFuncType close_handle_func,
     IsWOW64ProcessFuncType is_wow64_process_func) {
   PatchState(open_process_func, close_handle_func, is_wow64_process_func);
-  Singleton<ProcessCompatibilityCheck>::get()->KnownStateInitialize(
+  GetInstance()->KnownStateInitialize(
       system_type, current_process_wow64,
       check_integrity, current_process_integrity);
 }
 
 void ProcessCompatibilityCheck::PatchState(
     OpenProcessFuncType open_process_func,
     CloseHandleFuncType close_handle_func,
     IsWOW64ProcessFuncType is_wow64_process_func) {
   open_process_func_ = open_process_func;
   close_handle_func_ = close_handle_func;
   is_wow64_process_func_ = is_wow64_process_func;
   DCHECK(open_process_func_ != NULL && close_handle_func_ != NULL &&
          is_wow64_process_func_ != NULL);
 }
 
 void ProcessCompatibilityCheck::ResetState() {
   PatchState(OpenProcess, CloseHandle, IsWow64Process);
-  Singleton<ProcessCompatibilityCheck>::get()->StandardInitialize();
+  GetInstance()->StandardInitialize();
 }
 
 }  // namespace com