leveldb-ruby 0.10 → 0.11

data/leveldb/port/sha1_portable.cc

@@ -1,298 +0,0 @@
-// Portions copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-//
-// This module provides a slow but portable implementation of
-// the SHA1 hash function.
-//
-// It is adapted from free code written by Paul E. Jones
-// <paulej@packetizer.com>.  See http://www.packetizer.com/security/sha1/
-//
-// The license for the original code is:
-/*
-  Copyright (C) 1998, 2009
-  Paul E. Jones <paulej@packetizer.com>
-
-  Freeware Public License (FPL)
-
-  This software is licensed as "freeware."  Permission to distribute
-  this software in source and binary forms, including incorporation
-  into other products, is hereby granted without a fee.  THIS SOFTWARE
-  IS PROVIDED 'AS IS' AND WITHOUT ANY EXPRESSED OR IMPLIED WARRANTIES,
-  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS FOR A PARTICULAR PURPOSE.  THE AUTHOR SHALL NOT BE HELD
-  LIABLE FOR ANY DAMAGES RESULTING FROM THE USE OF THIS SOFTWARE, EITHER
-  DIRECTLY OR INDIRECTLY, INCLUDING, BUT NOT LIMITED TO, LOSS OF DATA
-  OR DATA BEING RENDERED INACCURATE.
-*/
-
-#include "port/sha1_portable.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-
-namespace leveldb {
-namespace port {
-
-/*
- *  Description:
- *      This class implements the Secure Hashing Standard as defined
- *      in FIPS PUB 180-1 published April 17, 1995.
- */
-
-/*
- *  This structure will hold context information for the hashing
- *  operation
- */
-typedef struct SHA1Context {
-  unsigned Message_Digest[5]; /* Message Digest (output)          */
-
-  unsigned Length_Low;        /* Message length in bits           */
-  unsigned Length_High;       /* Message length in bits           */
-
-  unsigned char Message_Block[64]; /* 512-bit message blocks      */
-  int Message_Block_Index;    /* Index into message block array   */
-
-  bool Computed;               /* Is the digest computed?          */
-  bool Corrupted;              /* Is the message digest corruped?  */
-} SHA1Context;
-
-/*
- *  Portability Issues:
- *      SHA-1 is defined in terms of 32-bit "words".  This code was
- *      written with the expectation that the processor has at least
- *      a 32-bit machine word size.  If the machine word size is larger,
- *      the code should still function properly.  One caveat to that
- *      is that the input functions taking characters and character
- *      arrays assume that only 8 bits of information are stored in each
- *      character.
- */
-
-/*
- *  Define the circular shift macro
- */
-#define SHA1CircularShift(bits,word) \
-                ((((word) << (bits)) & 0xFFFFFFFF) | \
-                ((word) >> (32-(bits))))
-
-/* Function prototypes */
-static void SHA1ProcessMessageBlock(SHA1Context *);
-static void SHA1PadMessage(SHA1Context *);
-
-// Initialize the SHA1Context in preparation for computing a new
-// message digest.
-static void SHA1Reset(SHA1Context* context) {
-  context->Length_Low             = 0;
-  context->Length_High            = 0;
-  context->Message_Block_Index    = 0;
-
-  context->Message_Digest[0]      = 0x67452301;
-  context->Message_Digest[1]      = 0xEFCDAB89;
-  context->Message_Digest[2]      = 0x98BADCFE;
-  context->Message_Digest[3]      = 0x10325476;
-  context->Message_Digest[4]      = 0xC3D2E1F0;
-
-  context->Computed   = false;
-  context->Corrupted  = false;
-}
-
-// This function will return the 160-bit message digest into the
-// Message_Digest array within the SHA1Context provided
-static bool SHA1Result(SHA1Context *context) {
-  if (context->Corrupted) {
-    return false;
-  }
-
-  if (!context->Computed) {
-    SHA1PadMessage(context);
-    context->Computed = true;
-  }
-  return true;
-}
-
-// This function accepts an array of bytes as the next portion of
-// the message.
-static void SHA1Input(SHA1Context         *context,
-                      const unsigned char *message_array,
-                      unsigned            length) {
-  if (!length) return;
-
-  if (context->Computed || context->Corrupted) {
-    context->Corrupted = true;
-    return;
-  }
-
-  while(length-- && !context->Corrupted) {
-    context->Message_Block[context->Message_Block_Index++] =
-        (*message_array & 0xFF);
-
-    context->Length_Low += 8;
-    /* Force it to 32 bits */
-    context->Length_Low &= 0xFFFFFFFF;
-    if (context->Length_Low == 0) {
-      context->Length_High++;
-      /* Force it to 32 bits */
-      context->Length_High &= 0xFFFFFFFF;
-      if (context->Length_High == 0)
-      {
-        /* Message is too long */
-        context->Corrupted = true;
-      }
-    }
-
-    if (context->Message_Block_Index == 64)
-    {
-      SHA1ProcessMessageBlock(context);
-    }
-
-    message_array++;
-  }
-}
-
-// This function will process the next 512 bits of the message stored
-// in the Message_Block array.
-static void SHA1ProcessMessageBlock(SHA1Context *context) {
-  const unsigned K[] =            // Constants defined in SHA-1
-      {
-        0x5A827999,
-        0x6ED9EBA1,
-        0x8F1BBCDC,
-        0xCA62C1D6
-      };
-  int         t;                  // Loop counter
-  unsigned    temp;               // Temporary word value
-  unsigned    W[80];            // Word sequence
-  unsigned    A, B, C, D, E;    // Word buffers
-
-  // Initialize the first 16 words in the array W
-  for(t = 0; t < 16; t++) {
-    W[t] = ((unsigned) context->Message_Block[t * 4]) << 24;
-    W[t] |= ((unsigned) context->Message_Block[t * 4 + 1]) << 16;
-    W[t] |= ((unsigned) context->Message_Block[t * 4 + 2]) << 8;
-    W[t] |= ((unsigned) context->Message_Block[t * 4 + 3]);
-  }
-
-  for(t = 16; t < 80; t++) {
-    W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
-  }
-
-  A = context->Message_Digest[0];
-  B = context->Message_Digest[1];
-  C = context->Message_Digest[2];
-  D = context->Message_Digest[3];
-  E = context->Message_Digest[4];
-
-  for(t = 0; t < 20; t++) {
-    temp =  SHA1CircularShift(5,A) +
-        ((B & C) | ((~B) & D)) + E + W[t] + K[0];
-    temp &= 0xFFFFFFFF;
-    E = D;
-    D = C;
-    C = SHA1CircularShift(30,B);
-    B = A;
-    A = temp;
-  }
-
-  for(t = 20; t < 40; t++) {
-    temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
-    temp &= 0xFFFFFFFF;
-    E = D;
-    D = C;
-    C = SHA1CircularShift(30,B);
-    B = A;
-    A = temp;
-  }
-
-  for(t = 40; t < 60; t++) {
-    temp = SHA1CircularShift(5,A) +
-        ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
-    temp &= 0xFFFFFFFF;
-    E = D;
-    D = C;
-    C = SHA1CircularShift(30,B);
-    B = A;
-    A = temp;
-  }
-
-  for(t = 60; t < 80; t++) {
-    temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
-    temp &= 0xFFFFFFFF;
-    E = D;
-    D = C;
-    C = SHA1CircularShift(30,B);
-    B = A;
-    A = temp;
-  }
-
-  context->Message_Digest[0] = (context->Message_Digest[0] + A) & 0xFFFFFFFF;
-  context->Message_Digest[1] = (context->Message_Digest[1] + B) & 0xFFFFFFFF;
-  context->Message_Digest[2] = (context->Message_Digest[2] + C) & 0xFFFFFFFF;
-  context->Message_Digest[3] = (context->Message_Digest[3] + D) & 0xFFFFFFFF;
-  context->Message_Digest[4] = (context->Message_Digest[4] + E) & 0xFFFFFFFF;
-
-  context->Message_Block_Index = 0;
-}
-
-// According to the standard, the message must be padded to an even
-// 512 bits.  The first padding bit must be a '1'.  The last 64 bits
-// represent the length of the original message.  All bits in between
-// should be 0.  This function will pad the message according to those
-// rules by filling the Message_Block array accordingly.  It will also
-// call SHA1ProcessMessageBlock() appropriately.  When it returns, it
-// can be assumed that the message digest has been computed.
-static void SHA1PadMessage(SHA1Context *context) {
-  // Check to see if the current message block is too small to hold
-  // the initial padding bits and length.  If so, we will pad the
-  // block, process it, and then continue padding into a second block.
-  if (context->Message_Block_Index > 55) {
-    context->Message_Block[context->Message_Block_Index++] = 0x80;
-    while(context->Message_Block_Index < 64) {
-      context->Message_Block[context->Message_Block_Index++] = 0;
-    }
-
-    SHA1ProcessMessageBlock(context);
-
-    while(context->Message_Block_Index < 56) {
-      context->Message_Block[context->Message_Block_Index++] = 0;
-    }
-  } else {
-    context->Message_Block[context->Message_Block_Index++] = 0x80;
-    while(context->Message_Block_Index < 56) {
-      context->Message_Block[context->Message_Block_Index++] = 0;
-    }
-  }
-
-  // Store the message length as the last 8 octets
-  context->Message_Block[56] = (context->Length_High >> 24) & 0xFF;
-  context->Message_Block[57] = (context->Length_High >> 16) & 0xFF;
-  context->Message_Block[58] = (context->Length_High >> 8) & 0xFF;
-  context->Message_Block[59] = (context->Length_High) & 0xFF;
-  context->Message_Block[60] = (context->Length_Low >> 24) & 0xFF;
-  context->Message_Block[61] = (context->Length_Low >> 16) & 0xFF;
-  context->Message_Block[62] = (context->Length_Low >> 8) & 0xFF;
-  context->Message_Block[63] = (context->Length_Low) & 0xFF;
-
-  SHA1ProcessMessageBlock(context);
-}
-
-
-void SHA1_Hash_Portable(const char* data, size_t len, char* hash_array) {
-  SHA1Context context;
-  SHA1Reset(&context);
-  SHA1Input(&context, reinterpret_cast<const unsigned char*>(data), len);
-  bool ok = SHA1Result(&context);
-  if (!ok) {
-    fprintf(stderr, "Unexpected error in SHA1_Hash_Portable code\n");
-    exit(1);
-  }
-  for (int i = 0; i < 5; i++) {
-    uint32_t value = context.Message_Digest[i];
-    hash_array[i*4 + 0] = (value >> 24) & 0xff;
-    hash_array[i*4 + 1] = (value >> 16) & 0xff;
-    hash_array[i*4 + 2] = (value >> 8) & 0xff;
-    hash_array[i*4 + 3] = value & 0xff;
-  }
-}
-
-}
-}

data/leveldb/port/sha1_portable.h

@@ -1,25 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#ifndef STORAGE_LEVELDB_PORT_SHA1_PORTABLE_H_
-#define STORAGE_LEVELDB_PORT_SHA1_PORTABLE_H_
-
-#include <stddef.h>
-
-namespace leveldb {
-namespace port {
-
-// Compute the SHA1 hash value of "data[0..len-1]" and store it in
-// "hash_array[0..19]".  hash_array must have 20 bytes of space available.
-//
-// This function is portable but may not be as fast as a version
-// optimized for your platform.  It is provided as a default method
-// that can be used when porting leveldb to a new platform if no
-// better SHA1 hash implementation is available.
-void SHA1_Hash_Portable(const char* data, size_t len, char* hash_array);
-
-}
-}
-
-#endif  // STORAGE_LEVELDB_PORT_SHA1_PORTABLE_H_

data/leveldb/port/sha1_test.cc

@@ -1,39 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#include "port/port.h"
-#include "util/testharness.h"
-
-namespace leveldb {
-namespace port {
-
-class SHA1 { };
-
-static std::string TestSHA1(const char* data, size_t len) {
-  char hash_val[20];
-  SHA1_Hash(data, len, hash_val);
-  char buf[41];
-  for (int i = 0; i < 20; i++) {
-    snprintf(buf + i * 2, 41 - i * 2,
-             "%02x",
-             static_cast<unsigned int>(static_cast<unsigned char>(
-                 hash_val[i])));
-  }
-  return std::string(buf, 40);
-}
-
-TEST(SHA1, Simple) {
-  ASSERT_EQ("da39a3ee5e6b4b0d3255bfef95601890afd80709", TestSHA1("", 0));
-  ASSERT_EQ("aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d", TestSHA1("hello", 5));
-  std::string x(10000, 'x');
-  ASSERT_EQ("f8c5cde791c5056cf515881e701c8a9ecb439a75",
-            TestSHA1(x.data(), x.size()));
-}
-
-}
-}
-
-int main(int argc, char** argv) {
-  return leveldb::test::RunAllTests();
-}

data/leveldb/util/env_chromium.cc

@@ -1,612 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-
-#include <deque>
-#include <errno.h>
-#include <stdio.h>
-#include "base/at_exit.h"
-#include "base/file_path.h"
-#include "base/file_util.h"
-#include "base/lazy_instance.h"
-#include "base/memory/ref_counted.h"
-#include "base/message_loop.h"
-#include "base/platform_file.h"
-#include "base/process_util.h"
-#include "base/synchronization/lock.h"
-#include "base/sys_info.h"
-#include "base/task.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread.h"
-#include "base/utf_string_conversions.h"
-#include "leveldb/env.h"
-#include "leveldb/slice.h"
-#include "port/port.h"
-#include "util/logging.h"
-
-#if defined(OS_WIN)
-#include <io.h>
-#include "base/win/win_util.h"
-#endif
-
-#if defined(OS_MACOSX) || defined(OS_WIN)
-// The following are glibc-specific
-namespace {
-
-size_t fread_unlocked(void *ptr, size_t size, size_t n, FILE *file) {
-  return fread(ptr, size, n, file);
-}
-
-size_t fwrite_unlocked(const void *ptr, size_t size, size_t n, FILE *file) {
-  return fwrite(ptr, size, n, file);
-}
-
-int fflush_unlocked(FILE *file) {
-  return fflush(file);
-}
-
-int fdatasync(int fildes) {
-#if defined(OS_WIN)
-  return _commit(fildes);
-#else
-  return fsync(fildes);
-#endif
-}
-
-}
-#endif
-
-namespace leveldb {
-
-namespace {
-
-class Thread;
-
-static const ::FilePath::CharType kLevelDBTestDirectoryPrefix[]
-    = FILE_PATH_LITERAL("leveldb-test-");
-
-::FilePath CreateFilePath(const std::string& file_path) {
-#if defined(OS_WIN)
-  return FilePath(UTF8ToUTF16(file_path));
-#else
-  return FilePath(file_path);
-#endif
-}
-
-std::string FilePathToString(const ::FilePath& file_path) {
-#if defined(OS_WIN)
-  return UTF16ToUTF8(file_path.value());
-#else
-  return file_path.value();
-#endif
-}
-
-// TODO(jorlow): This should be moved into Chromium's base.
-const char* PlatformFileErrorString(const ::base::PlatformFileError& error) {
-  switch (error) {
-    case ::base::PLATFORM_FILE_ERROR_FAILED:
-      return "Opening file failed.";
-    case ::base::PLATFORM_FILE_ERROR_IN_USE:
-      return "File currently in use.";
-    case ::base::PLATFORM_FILE_ERROR_EXISTS:
-      return "File already exists.";
-    case ::base::PLATFORM_FILE_ERROR_NOT_FOUND:
-      return "File not found.";
-    case ::base::PLATFORM_FILE_ERROR_ACCESS_DENIED:
-      return "Access denied.";
-    case ::base::PLATFORM_FILE_ERROR_TOO_MANY_OPENED:
-      return "Too many files open.";
-    case ::base::PLATFORM_FILE_ERROR_NO_MEMORY:
-      return "Out of memory.";
-    case ::base::PLATFORM_FILE_ERROR_NO_SPACE:
-      return "No space left on drive.";
-    case ::base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY:
-      return "Not a directory.";
-    case ::base::PLATFORM_FILE_ERROR_INVALID_OPERATION:
-      return "Invalid operation.";
-    case ::base::PLATFORM_FILE_ERROR_SECURITY:
-      return "Security error.";
-    case ::base::PLATFORM_FILE_ERROR_ABORT:
-      return "File operation aborted.";
-    case ::base::PLATFORM_FILE_ERROR_NOT_A_FILE:
-      return "The supplied path was not a file.";
-    case ::base::PLATFORM_FILE_ERROR_NOT_EMPTY:
-      return "The file was not empty.";
-  }
-  NOTIMPLEMENTED();
-  return "Unknown error.";
-}
-
-class ChromiumSequentialFile: public SequentialFile {
- private:
-  std::string filename_;
-  FILE* file_;
-
- public:
-  ChromiumSequentialFile(const std::string& fname, FILE* f)
-      : filename_(fname), file_(f) { }
-  virtual ~ChromiumSequentialFile() { fclose(file_); }
-
-  virtual Status Read(size_t n, Slice* result, char* scratch) {
-    Status s;
-    size_t r = fread_unlocked(scratch, 1, n, file_);
-    *result = Slice(scratch, r);
-    if (r < n) {
-      if (feof(file_)) {
-        // We leave status as ok if we hit the end of the file
-      } else {
-        // A partial read with an error: return a non-ok status
-        s = Status::IOError(filename_, strerror(errno));
-      }
-    }
-    return s;
-  }
-
-  virtual Status Skip(uint64_t n) {
-    if (fseek(file_, n, SEEK_CUR)) {
-      return Status::IOError(filename_, strerror(errno));
-    }
-    return Status::OK();
-  }
-};
-
-class ChromiumRandomAccessFile: public RandomAccessFile {
- private:
-  std::string filename_;
-  ::base::PlatformFile file_;
-
- public:
-  ChromiumRandomAccessFile(const std::string& fname, ::base::PlatformFile file)
-      : filename_(fname), file_(file) { }
-  virtual ~ChromiumRandomAccessFile() { ::base::ClosePlatformFile(file_); }
-
-  virtual Status Read(uint64_t offset, size_t n, Slice* result,
-                      char* scratch) const {
-    Status s;
-    int r = ::base::ReadPlatformFile(file_, offset, scratch, n);
-    *result = Slice(scratch, (r < 0) ? 0 : r);
-    if (r < 0) {
-      // An error: return a non-ok status
-      s = Status::IOError(filename_, "Could not preform read");
-    }
-    return s;
-  }
-};
-
-class ChromiumWritableFile : public WritableFile {
- private:
-  std::string filename_;
-  FILE* file_;
-
- public:
-  ChromiumWritableFile(const std::string& fname, FILE* f)
-      : filename_(fname), file_(f) { }
-
-  ~ChromiumWritableFile() {
-    if (file_ != NULL) {
-      // Ignoring any potential errors
-      fclose(file_);
-    }
-  }
-
-  virtual Status Append(const Slice& data) {
-    size_t r = fwrite_unlocked(data.data(), 1, data.size(), file_);
-    Status result;
-    if (r != data.size()) {
-      result = Status::IOError(filename_, strerror(errno));
-    }
-    return result;
-  }
-
-  virtual Status Close() {
-    Status result;
-    if (fclose(file_) != 0) {
-      result = Status::IOError(filename_, strerror(errno));
-    }
-    file_ = NULL;
-    return result;
-  }
-
-  virtual Status Flush() {
-    Status result;
-    if (fflush_unlocked(file_) != 0) {
-      result = Status::IOError(filename_, strerror(errno));
-    }
-    return result;
-  }
-
-  virtual Status Sync() {
-    Status result;
-    if ((fflush_unlocked(file_) != 0) ||
-        (fdatasync(fileno(file_)) != 0)) {
-      result = Status::IOError(filename_, strerror(errno));
-    }
-    return result;
-  }
-};
-
-class ChromiumFileLock : public FileLock {
- public:
-  ::base::PlatformFile file_;
-};
-
-class ChromiumEnv : public Env {
- public:
-  ChromiumEnv();
-  virtual ~ChromiumEnv() {
-    fprintf(stderr, "Destroying Env::Default()\n");
-    exit(1);
-  }
-
-  virtual Status NewSequentialFile(const std::string& fname,
-                                   SequentialFile** result) {
-    FILE* f = fopen(fname.c_str(), "rb");
-    if (f == NULL) {
-      *result = NULL;
-      return Status::IOError(fname, strerror(errno));
-    } else {
-      *result = new ChromiumSequentialFile(fname, f);
-      return Status::OK();
-    }
-  }
-
-  virtual Status NewRandomAccessFile(const std::string& fname,
-                                     RandomAccessFile** result) {
-    int flags = ::base::PLATFORM_FILE_READ | ::base::PLATFORM_FILE_OPEN;
-    bool created;
-    ::base::PlatformFileError error_code;
-    ::base::PlatformFile file = ::base::CreatePlatformFile(
-        CreateFilePath(fname), flags, &created, &error_code);
-    if (error_code != ::base::PLATFORM_FILE_OK) {
-      *result = NULL;
-      return Status::IOError(fname, PlatformFileErrorString(error_code));
-    }
-    *result = new ChromiumRandomAccessFile(fname, file);
-    return Status::OK();
-  }
-
-  virtual Status NewWritableFile(const std::string& fname,
-                                 WritableFile** result) {
-    *result = NULL;
-    FILE* f = fopen(fname.c_str(), "wb");
-    if (f == NULL) {
-      return Status::IOError(fname, strerror(errno));
-    } else {
-      *result = new ChromiumWritableFile(fname, f);
-      return Status::OK();
-    }
-  }
-
-  virtual bool FileExists(const std::string& fname) {
-    return ::file_util::PathExists(CreateFilePath(fname));
-  }
-
-  virtual Status GetChildren(const std::string& dir,
-                             std::vector<std::string>* result) {
-    result->clear();
-    ::file_util::FileEnumerator iter(
-        CreateFilePath(dir), false, ::file_util::FileEnumerator::FILES);
-    ::FilePath current = iter.Next();
-    while (!current.empty()) {
-      result->push_back(FilePathToString(current.BaseName()));
-      current = iter.Next();
-    }
-    // TODO(jorlow): Unfortunately, the FileEnumerator swallows errors, so
-    //               we'll always return OK. Maybe manually check for error
-    //               conditions like the file not existing?
-    return Status::OK();
-  }
-
-  virtual Status DeleteFile(const std::string& fname) {
-    Status result;
-    // TODO(jorlow): Should we assert this is a file?
-    if (!::file_util::Delete(CreateFilePath(fname), false)) {
-      result = Status::IOError(fname, "Could not delete file.");
-    }
-    return result;
-  };
-
-  virtual Status CreateDir(const std::string& name) {
-    Status result;
-    if (!::file_util::CreateDirectory(CreateFilePath(name))) {
-      result = Status::IOError(name, "Could not create directory.");
-    }
-    return result;
-  };
-
-  virtual Status DeleteDir(const std::string& name) {
-    Status result;
-    // TODO(jorlow): Should we assert this is a directory?
-    if (!::file_util::Delete(CreateFilePath(name), false)) {
-      result = Status::IOError(name, "Could not delete directory.");
-    }
-    return result;
-  };
-
-  virtual Status GetFileSize(const std::string& fname, uint64_t* size) {
-    Status s;
-    int64_t signed_size;
-    if (!::file_util::GetFileSize(CreateFilePath(fname), &signed_size)) {
-      *size = 0;
-      s = Status::IOError(fname, "Could not determine file size.");
-    } else {
-      *size = static_cast<uint64_t>(signed_size);
-    }
-    return s;
-  }
-
-  virtual Status RenameFile(const std::string& src, const std::string& dst) {
-    Status result;
-    if (!::file_util::ReplaceFile(CreateFilePath(src), CreateFilePath(dst))) {
-      result = Status::IOError(src, "Could not rename file.");
-    }
-    return result;
-  }
-
-  virtual Status LockFile(const std::string& fname, FileLock** lock) {
-    *lock = NULL;
-    Status result;
-    int flags = ::base::PLATFORM_FILE_OPEN_ALWAYS |
-                ::base::PLATFORM_FILE_READ |
-                ::base::PLATFORM_FILE_WRITE |
-                ::base::PLATFORM_FILE_EXCLUSIVE_READ |
-                ::base::PLATFORM_FILE_EXCLUSIVE_WRITE;
-    bool created;
-    ::base::PlatformFileError error_code;
-    ::base::PlatformFile file = ::base::CreatePlatformFile(
-        CreateFilePath(fname), flags, &created, &error_code);
-    if (error_code != ::base::PLATFORM_FILE_OK) {
-      result = Status::IOError(fname, PlatformFileErrorString(error_code));
-    } else {
-      ChromiumFileLock* my_lock = new ChromiumFileLock;
-      my_lock->file_ = file;
-      *lock = my_lock;
-    }
-    return result;
-  }
-
-  virtual Status UnlockFile(FileLock* lock) {
-    ChromiumFileLock* my_lock = reinterpret_cast<ChromiumFileLock*>(lock);
-    Status result;
-    if (!::base::ClosePlatformFile(my_lock->file_)) {
-      result = Status::IOError("Could not close lock file.");
-    }
-    delete my_lock;
-    return result;
-  }
-
-  virtual void Schedule(void (*function)(void*), void* arg);
-
-  virtual void StartThread(void (*function)(void* arg), void* arg);
-
-  virtual std::string UserIdentifier() {
-#if defined(OS_WIN)
-    std::wstring user_sid;
-    bool ret = ::base::win::GetUserSidString(&user_sid);
-    DCHECK(ret);
-    return UTF16ToUTF8(user_sid);
-#else
-    char buf[100];
-    snprintf(buf, sizeof(buf), "%d", int(geteuid()));
-    return buf;
-#endif
-  }
-
-  virtual Status GetTestDirectory(std::string* path) {
-    mu_.Acquire();
-    if (test_directory_.empty()) {
-      if (!::file_util::CreateNewTempDirectory(kLevelDBTestDirectoryPrefix,
-                                               &test_directory_)) {
-        mu_.Release();
-        return Status::IOError("Could not create temp directory.");
-      }
-    }
-    *path = FilePathToString(test_directory_);
-    mu_.Release();
-    return Status::OK();
-  }
-
-  virtual void Logv(WritableFile* info_log, const char* format, va_list ap) {
-    // TODO(jorlow): We may want to just use Chromium's built in logging.
-
-    uint64_t thread_id = 0;
-    // Coppied from base/logging.cc.
-#if defined(OS_WIN)
-    thread_id = GetCurrentThreadId();
-#elif defined(OS_MACOSX)
-    thread_id = mach_thread_self();
-#elif defined(OS_LINUX)
-    thread_id = syscall(__NR_gettid);
-#elif defined(OS_FREEBSD) || defined(OS_NACL)
-    // TODO(BSD): find a better thread ID
-    pthread_t tid = pthread_self();
-    memcpy(&thread_id, &tid, min(sizeof(r), sizeof(tid)));
-#endif
-
-    // We try twice: the first time with a fixed-size stack allocated buffer,
-    // and the second time with a much larger dynamically allocated buffer.
-    char buffer[500];
-    for (int iter = 0; iter < 2; iter++) {
-      char* base;
-      int bufsize;
-      if (iter == 0) {
-        bufsize = sizeof(buffer);
-        base = buffer;
-      } else {
-        bufsize = 30000;
-        base = new char[bufsize];
-      }
-      char* p = base;
-      char* limit = base + bufsize;
-
-      ::base::Time::Exploded t;
-      ::base::Time::Now().LocalExplode(&t);
-      p += snprintf(p, limit - p,
-                    "%04d/%02d/%02d-%02d:%02d:%02d.%06d %llx ",
-                    t.year,
-                    t.month,
-                    t.day_of_month,
-                    t.hour,
-                    t.minute,
-                    t.second,
-                    static_cast<int>(t.millisecond) * 1000,
-                    static_cast<long long unsigned int>(thread_id));
-
-      // Print the message
-      if (p < limit) {
-        va_list backup_ap;
-        va_copy(backup_ap, ap);
-        p += vsnprintf(p, limit - p, format, backup_ap);
-        va_end(backup_ap);
-      }
-
-      // Truncate to available space if necessary
-      if (p >= limit) {
-        if (iter == 0) {
-          continue;       // Try again with larger buffer
-        } else {
-          p = limit - 1;
-        }
-      }
-
-      // Add newline if necessary
-      if (p == base || p[-1] != '\n') {
-        *p++ = '\n';
-      }
-
-      assert(p <= limit);
-      info_log->Append(Slice(base, p - base));
-      info_log->Flush();
-      if (base != buffer) {
-        delete[] base;
-      }
-      break;
-    }
-  }
-
-  virtual int AppendLocalTimeToBuffer(char* buffer, size_t size) {
-    ::base::Time::Exploded t;
-    ::base::Time::Now().LocalExplode(&t);
-    return snprintf(buffer, size,
-                    "%04d/%02d/%02d-%02d:%02d:%02d.%06d",
-                    t.year,
-                    t.month,
-                    t.day_of_month,
-                    t.hour,
-                    t.minute,
-                    t.second,
-                    static_cast<int>(t.millisecond) * 1000);
-  }
-
-  virtual uint64_t NowMicros() {
-    return ::base::TimeTicks::HighResNow().ToInternalValue();
-  }
-
-  virtual void SleepForMicroseconds(int micros) {
-    // Round up to the next millisecond.
-    ::base::PlatformThread::Sleep((micros + 999) / 1000);
-  }
-
- private:
-  // BGThread() is the body of the background thread
-  void BGThread();
-  static void BGThreadWrapper(void* arg) {
-    reinterpret_cast<ChromiumEnv*>(arg)->BGThread();
-  }
-
-  FilePath test_directory_;
-
-  size_t page_size_;
-  ::base::Lock mu_;
-  ::base::ConditionVariable bgsignal_;
-  bool started_bgthread_;
-
-  // Entry per Schedule() call
-  struct BGItem { void* arg; void (*function)(void*); };
-  typedef std::deque<BGItem> BGQueue;
-  BGQueue queue_;
-};
-
-ChromiumEnv::ChromiumEnv()
-    : page_size_(::base::SysInfo::VMAllocationGranularity()),
-      bgsignal_(&mu_),
-      started_bgthread_(false) {
-#if defined(OS_MACOSX)
-  ::base::EnableTerminationOnHeapCorruption();
-  ::base::EnableTerminationOnOutOfMemory();
-#endif  // OS_MACOSX
-}
-
-class Thread : public ::base::PlatformThread::Delegate {
- public:
-  Thread(void (*function)(void* arg), void* arg)
-      : function_(function), arg_(arg) {
-    ::base::PlatformThreadHandle handle;
-    bool success = ::base::PlatformThread::Create(0, this, &handle);
-    DCHECK(success);
-  }
-  virtual ~Thread() {}
-  virtual void ThreadMain() {
-    (*function_)(arg_);
-    delete this;
-  }
-
- private:
-  void (*function_)(void* arg);
-  void* arg_;
-};
-
-void ChromiumEnv::Schedule(void (*function)(void*), void* arg) {
-  mu_.Acquire();
-
-  // Start background thread if necessary
-  if (!started_bgthread_) {
-    started_bgthread_ = true;
-    StartThread(&ChromiumEnv::BGThreadWrapper, this);
-  }
-
-  // If the queue is currently empty, the background thread may currently be
-  // waiting.
-  if (queue_.empty()) {
-    bgsignal_.Signal();
-  }
-
-  // Add to priority queue
-  queue_.push_back(BGItem());
-  queue_.back().function = function;
-  queue_.back().arg = arg;
-
-  mu_.Release();
-}
-
-void ChromiumEnv::BGThread() {
-  while (true) {
-    // Wait until there is an item that is ready to run
-    mu_.Acquire();
-    while (queue_.empty()) {
-      bgsignal_.Wait();
-    }
-
-    void (*function)(void*) = queue_.front().function;
-    void* arg = queue_.front().arg;
-    queue_.pop_front();
-
-    mu_.Release();
-    (*function)(arg);
-  }
-}
-
-void ChromiumEnv::StartThread(void (*function)(void* arg), void* arg) {
-  new Thread(function, arg); // Will self-delete.
-}
-
-::base::LazyInstance<ChromiumEnv, ::base::LeakyLazyInstanceTraits<ChromiumEnv> >
-    default_env(::base::LINKER_INITIALIZED);
-
-}
-
-Env* Env::Default() {
-  return default_env.Pointer();
-}
-
-}