Use LOG() or LOG_IF() instead of IMMEDIATE_CRASH

third_party/WebKit/Source/platform/wtf/ThreadSpecific.h

 /*
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Jian Li <jianli@chromium.org>
  * Copyright (C) 2012 Patrick Gansterer <paroga@paroga.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 107 matching lines @@
   T* main_thread_storage_ = nullptr;
 };
 
 #if OS(POSIX)
 
 typedef pthread_key_t ThreadSpecificKey;
 
 inline void ThreadSpecificKeyCreate(ThreadSpecificKey* key,
                                     void (*destructor)(void*)) {
   int error = pthread_key_create(key, destructor);
-  if (error)
-    IMMEDIATE_CRASH();
+  CHECK(!error);
 }
 
 inline void ThreadSpecificKeyDelete(ThreadSpecificKey key) {
   int error = pthread_key_delete(key);
-  if (error)
-    IMMEDIATE_CRASH();
+  CHECK(!error);
 }
 
 inline void ThreadSpecificSet(ThreadSpecificKey key, void* value) {
   pthread_setspecific(key, value);
 }
 
 inline void* ThreadSpecificGet(ThreadSpecificKey key) {
   return pthread_getspecific(key);
 }
 
 template <typename T>
 inline ThreadSpecific<T>::ThreadSpecific() {
   int error = pthread_key_create(&key_, Destroy);
-  if (error)
-    IMMEDIATE_CRASH();
+  CHECK(!error);
 }
 
 template <typename T>
 inline T* ThreadSpecific<T>::Get() {
   Data* data = static_cast<Data*>(pthread_getspecific(key_));
   return data ? data->value : 0;
 }
 
 template <typename T>
 inline void ThreadSpecific<T>::Set(T* ptr) {
@@ skipping 23 matching lines @@
 typedef PlatformThreadSpecificKey* ThreadSpecificKey;
 
 WTF_EXPORT void ThreadSpecificKeyCreate(ThreadSpecificKey*, void (*)(void*));
 WTF_EXPORT void ThreadSpecificKeyDelete(ThreadSpecificKey);
 WTF_EXPORT void ThreadSpecificSet(ThreadSpecificKey, void*);
 WTF_EXPORT void* ThreadSpecificGet(ThreadSpecificKey);
 
 template <typename T>
 inline ThreadSpecific<T>::ThreadSpecific() : index_(-1) {
   DWORD tls_key = TlsAlloc();
-  if (tls_key == TLS_OUT_OF_INDEXES)
-    IMMEDIATE_CRASH();
+  CHECK_NE(tls_key, TLS_OUT_OF_INDEXES);
 
   index_ = InterlockedIncrement(&TlsKeyCount()) - 1;
-  if (index_ >= kMaxTlsKeySize)
-    IMMEDIATE_CRASH();
+  CHECK_LE(index_, kMaxTlsKeySize);
   TlsKeys()[index_] = tls_key;
 }
 
 template <typename T>
 inline ThreadSpecific<T>::~ThreadSpecific() {
   // Does not invoke destructor functions. They will be called from
   // ThreadSpecificThreadExit when the thread is detached.
   TlsFree(tlsKeys()[m_index]);
 }
 
@@ skipping 97 matching lines @@
 template <typename T>
 inline T& ThreadSpecific<T>::operator*() {
   return *operator T*();
 }
 
 }  // namespace WTF
 
 using WTF::ThreadSpecific;
 
 #endif  // WTF_ThreadSpecific_h