third_party/leveldatabase/port/port_chromium.h

   1 // Copyright (c) 2011 The LevelDB 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. See the AUTHORS file for names of contributors.
   4 //
   5 // See port_example.h for documentation for the following types/functions.
   6
   7 #ifndef STORAGE_LEVELDB_PORT_PORT_CHROMIUM_H_
   8 #define STORAGE_LEVELDB_PORT_PORT_CHROMIUM_H_
   9
  10 #include <stdint.h>
  11 #include <string>
  12 #include <cstring>
  13 #include "base/atomicops.h"
  14 #include "base/basictypes.h"
  15 #include "base/synchronization/condition_variable.h"
  16 #include "base/synchronization/lock.h"
  17
  18 // Linux's ThreadIdentifier() needs this.
  19 #if defined(OS_LINUX)
  20 #  include <linux/unistd.h>
  21 #endif
  22
  23 #if defined(OS_WIN)
  24 #define snprintf _snprintf
  25 typedef SSIZE_T ssize_t;
  26 #endif
  27
  28 namespace leveldb {
  29 namespace port {
  30
  31 // Chromium only supports little endian.
  32 static const bool kLittleEndian = true;
  33
  34 class Mutex {
  35  public:
  36   Mutex();
  37   ~Mutex();
  38   void Lock();
  39   void Unlock();
  40   void AssertHeld();
  41
  42  private:
  43   base::Lock mu_;
  44
  45   friend class CondVar;
  46   DISALLOW_COPY_AND_ASSIGN(Mutex);
  47 };
  48
  49 class CondVar {
  50  public:
  51   explicit CondVar(Mutex* mu);
  52   ~CondVar();
  53   void Wait();
  54   void Signal();
  55   void SignalAll();
  56
  57  private:
  58   base::ConditionVariable cv_;
  59
  60   DISALLOW_COPY_AND_ASSIGN(CondVar);
  61 };
  62
  63 class AtomicPointer {
  64  private:
  65   typedef base::subtle::AtomicWord Rep;
  66   Rep rep_;
  67  public:
  68   AtomicPointer() { }
  69   explicit AtomicPointer(void* p) : rep_(reinterpret_cast<Rep>(p)) {}
  70   inline void* Acquire_Load() const {
  71     return reinterpret_cast<void*>(base::subtle::Acquire_Load(&rep_));
  72   }
  73   inline void Release_Store(void* v) {
  74     base::subtle::Release_Store(&rep_, reinterpret_cast<Rep>(v));
  75   }
  76   inline void* NoBarrier_Load() const {
  77     return reinterpret_cast<void*>(base::subtle::NoBarrier_Load(&rep_));
  78   }
  79   inline void NoBarrier_Store(void* v) {
  80     base::subtle::NoBarrier_Store(&rep_, reinterpret_cast<Rep>(v));
  81   }
  82 };
  83
  84 // Implementation of OnceType and InitOnce() pair, this is equivalent to
  85 // pthread_once_t and pthread_once().
  86 typedef base::subtle::Atomic32 OnceType;
  87
  88 enum {
  89   ONCE_STATE_UNINITIALIZED = 0,
  90   ONCE_STATE_EXECUTING_CLOSURE = 1,
  91   ONCE_STATE_DONE = 2
  92 };
  93
  94 #define LEVELDB_ONCE_INIT   leveldb::port::ONCE_STATE_UNINITIALIZED
  95
  96 // slow code path
  97 void InitOnceImpl(OnceType* once, void (*initializer)());
  98
  99 static inline void InitOnce(OnceType* once, void (*initializer)()) {
 100   if (base::subtle::Acquire_Load(once) != ONCE_STATE_DONE)
 101     InitOnceImpl(once, initializer);
 102 }
 103
 104 bool Snappy_Compress(const char* input, size_t input_length,
 105                      std::string* output);
 106 bool Snappy_GetUncompressedLength(const char* input, size_t length,
 107                                   size_t* result);
 108 bool Snappy_Uncompress(const char* input_data, size_t input_length,
 109                        char* output);
 110
 111 inline bool GetHeapProfile(void (*func)(void*, const char*, int), void* arg) {
 112   return false;
 113 }
 114
 115 }
 116 }
 117
 118 #endif  // STORAGE_LEVELDB_PORT_PORT_CHROMIUM_H_