LCOV - code coverage report
Current view: directory - ipc/chromium/src/base - thread_local_storage.h (source / functions) Found Hit Coverage
Test: app.info Lines: 2 1 50.0 %
Date: 2012-06-02 Functions: 2 1 50.0 %

       1                 : // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
       2                 : // Use of this source code is governed by a BSD-style license that can be
       3                 : // found in the LICENSE file.
       4                 : 
       5                 : #ifndef BASE_THREAD_LOCAL_STORAGE_H_
       6                 : #define BASE_THREAD_LOCAL_STORAGE_H_
       7                 : 
       8                 : #include "base/basictypes.h"
       9                 : 
      10                 : #if defined(OS_POSIX)
      11                 : #include <pthread.h>
      12                 : #endif
      13                 : 
      14                 : // Wrapper for thread local storage.  This class doesn't do much except provide
      15                 : // an API for portability.
      16                 : class ThreadLocalStorage {
      17                 :  public:
      18                 : 
      19                 :   // Prototype for the TLS destructor function, which can be optionally used to
      20                 :   // cleanup thread local storage on thread exit.  'value' is the data that is
      21                 :   // stored in thread local storage.
      22                 :   typedef void (*TLSDestructorFunc)(void* value);
      23                 : 
      24                 :   // A key representing one value stored in TLS.
      25                 :   class Slot {
      26                 :    public:
      27                 :     Slot(TLSDestructorFunc destructor = NULL);
      28                 : 
      29                 :     // This constructor should be used for statics.
      30                 :     // It returns an uninitialized Slot.
      31            1464 :     explicit Slot(base::LinkerInitialized x) {}
      32                 : 
      33                 :     // Set up the TLS slot.  Called by the constructor.
      34                 :     // 'destructor' is a pointer to a function to perform per-thread cleanup of
      35                 :     // this object.  If set to NULL, no cleanup is done for this TLS slot.
      36                 :     // Returns false on error.
      37                 :     bool Initialize(TLSDestructorFunc destructor);
      38                 : 
      39                 :     // Free a previously allocated TLS 'slot'.
      40                 :     // If a destructor was set for this slot, removes
      41                 :     // the destructor so that remaining threads exiting
      42                 :     // will not free data.
      43                 :     void Free();
      44                 : 
      45                 :     // Get the thread-local value stored in slot 'slot'.
      46                 :     // Values are guaranteed to initially be zero.
      47                 :     void* Get() const;
      48                 : 
      49                 :     // Set the thread-local value stored in slot 'slot' to
      50                 :     // value 'value'.
      51                 :     void Set(void* value);
      52                 : 
      53               0 :     bool initialized() const { return initialized_; }
      54                 : 
      55                 :    private:
      56                 :     // The internals of this struct should be considered private.
      57                 :     bool initialized_;
      58                 : #if defined(OS_WIN)
      59                 :     int slot_;
      60                 : #elif defined(OS_POSIX)
      61                 :     pthread_key_t key_;
      62                 : #endif
      63                 : 
      64                 :     DISALLOW_COPY_AND_ASSIGN(Slot);
      65                 :   };
      66                 : 
      67                 : #if defined(OS_WIN)
      68                 :   // Function called when on thread exit to call TLS
      69                 :   // destructor functions.  This function is used internally.
      70                 :   static void ThreadExit();
      71                 : 
      72                 :  private:
      73                 :   // Function to lazily initialize our thread local storage.
      74                 :   static void **Initialize();
      75                 : 
      76                 :  private:
      77                 :   // The maximum number of 'slots' in our thread local storage stack.
      78                 :   // For now, this is fixed.  We could either increase statically, or
      79                 :   // we could make it dynamic in the future.
      80                 :   static const int kThreadLocalStorageSize = 64;
      81                 : 
      82                 :   static long tls_key_;
      83                 :   static long tls_max_;
      84                 :   static TLSDestructorFunc tls_destructors_[kThreadLocalStorageSize];
      85                 : #endif  // OS_WIN
      86                 : 
      87                 :   DISALLOW_COPY_AND_ASSIGN(ThreadLocalStorage);
      88                 : };
      89                 : 
      90                 : // Temporary backwards-compatible name.
      91                 : // TODO(evanm): replace all usage of TLSSlot.
      92                 : typedef ThreadLocalStorage::Slot TLSSlot;
      93                 : 
      94                 : #endif  // BASE_THREAD_LOCAL_STORAGE_H_

Generated by: LCOV version 1.7