/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/* vim: set ts=8 sts=4 et sw=4 tw=99: */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "SharedPrefMap.h"

#include "mozilla/dom/ipc/MemMapSnapshot.h"

#include "mozilla/BinarySearch.h"

#include "mozilla/ResultExtensions.h"

#include "mozilla/ipc/FileDescriptor.h"

using namespace mozilla::loader;

namespace mozilla {

using namespace ipc;

static inline size_t

GetAlignmentOffset(size_t aOffset, size_t aAlign)

{

  auto mod = aOffset % aAlign;

  return mod ? aAlign - mod : 0;

}

SharedPrefMap::SharedPrefMap(const FileDescriptor& aMapFile, size_t aMapSize)

{

  auto result = mMap.initWithHandle(aMapFile, aMapSize);

  MOZ_RELEASE_ASSERT(result.isOk());

  // We return literal nsCStrings pointing to the mapped data for preference

  // names and string values, which means that we may still have references to

  // the mapped data even after this instance is destroyed. That means that we

  // need to keep the mapping alive until process shutdown, in order to be safe.

  mMap.setPersistent();

}

SharedPrefMap::SharedPrefMap(SharedPrefMapBuilder&& aBuilder)

{

  auto result = aBuilder.Finalize(mMap);

  MOZ_RELEASE_ASSERT(result.isOk());

  mMap.setPersistent();

}

mozilla::ipc::FileDescriptor

SharedPrefMap::CloneFileDescriptor() const

{

  return mMap.cloneHandle();

}

bool

SharedPrefMap::Has(const char* aKey) const

{

  size_t index;

  return Find(aKey, &index);

}

Maybe<const SharedPrefMap::Pref>

SharedPrefMap::Get(const char* aKey) const

{

  Maybe<const Pref> result;

  size_t index;

  if (Find(aKey, &index)) {

    result.emplace(Pref{ this, &Entries()[index] });

  }

  return result;

}

bool

SharedPrefMap::Find(const char* aKey, size_t* aIndex) const

{

  const auto& keys = KeyTable();

  return BinarySearchIf(Entries(),

                        0,

                        EntryCount(),

                        [&](const Entry& aEntry) {

                          return strcmp(aKey, keys.GetBare(aEntry.mKey));

                        },

                        aIndex);

}

void

SharedPrefMapBuilder::Add(const char* aKey,

                          const Flags& aFlags,

                          bool aDefaultValue,

                          bool aUserValue)

{

  mEntries.AppendElement(Entry{

    aKey,

    mKeyTable.Add(aKey),

    { aDefaultValue, aUserValue },

    uint8_t(PrefType::Bool),

    aFlags.mHasDefaultValue,

    aFlags.mHasUserValue,

    aFlags.mIsSticky,

    aFlags.mIsLocked,

    aFlags.mDefaultChanged,

  });

}

void

SharedPrefMapBuilder::Add(const char* aKey,

                          const Flags& aFlags,

                          int32_t aDefaultValue,

                          int32_t aUserValue)

{

  ValueIdx index;

  if (aFlags.mHasUserValue) {

    index = mIntValueTable.Add(aDefaultValue, aUserValue);

  } else {

    index = mIntValueTable.Add(aDefaultValue);

  }

  mEntries.AppendElement(Entry{

    aKey,

    mKeyTable.Add(aKey),

    { index },

    uint8_t(PrefType::Int),

    aFlags.mHasDefaultValue,

    aFlags.mHasUserValue,

    aFlags.mIsSticky,

    aFlags.mIsLocked,

    aFlags.mDefaultChanged,

  });

}

void

SharedPrefMapBuilder::Add(const char* aKey,

                          const Flags& aFlags,

                          const nsCString& aDefaultValue,

                          const nsCString& aUserValue)

{

  ValueIdx index;

  StringTableEntry defaultVal = mValueStringTable.Add(aDefaultValue);

  if (aFlags.mHasUserValue) {

    StringTableEntry userVal = mValueStringTable.Add(aUserValue);

    index = mStringValueTable.Add(defaultVal, userVal);

  } else {

    index = mStringValueTable.Add(defaultVal);

  }

  mEntries.AppendElement(Entry{

    aKey,

    mKeyTable.Add(aKey),

    { index },

    uint8_t(PrefType::String),

    aFlags.mHasDefaultValue,

    aFlags.mHasUserValue,

    aFlags.mIsSticky,

    aFlags.mIsLocked,

    aFlags.mDefaultChanged,

  });

}

Result<Ok, nsresult>

SharedPrefMapBuilder::Finalize(loader::AutoMemMap& aMap)

{

  using Header = SharedPrefMap::Header;

  // Create an array of entry pointers for the entry array, and sort it by

  // preference name prior to serialization, so that entries can be looked up

  // using binary search.

  nsTArray<Entry*> entries(mEntries.Length());

  for (auto& entry : mEntries) {

    entries.AppendElement(&entry);

  }

  entries.Sort([](const Entry* aA, const Entry* aB) {

    return strcmp(aA->mKeyString, aB->mKeyString);

  });

  Header header = { uint32_t(entries.Length()) };

  size_t offset = sizeof(header);

  offset += GetAlignmentOffset(offset, alignof(Header));

  offset += entries.Length() * sizeof(SharedPrefMap::Entry);

  header.mKeyStrings.mOffset = offset;

  header.mKeyStrings.mSize = mKeyTable.Size();

  offset += header.mKeyStrings.mSize;

  offset += GetAlignmentOffset(offset, mIntValueTable.Alignment());

  header.mUserIntValues.mOffset = offset;

  header.mUserIntValues.mSize = mIntValueTable.UserSize();

  offset += header.mUserIntValues.mSize;

  offset += GetAlignmentOffset(offset, mIntValueTable.Alignment());

  header.mDefaultIntValues.mOffset = offset;

  header.mDefaultIntValues.mSize = mIntValueTable.DefaultSize();

  offset += header.mDefaultIntValues.mSize;

  offset += GetAlignmentOffset(offset, mStringValueTable.Alignment());

  header.mUserStringValues.mOffset = offset;

  header.mUserStringValues.mSize = mStringValueTable.UserSize();

  offset += header.mUserStringValues.mSize;

  offset += GetAlignmentOffset(offset, mStringValueTable.Alignment());

  header.mDefaultStringValues.mOffset = offset;

  header.mDefaultStringValues.mSize = mStringValueTable.DefaultSize();

  offset += header.mDefaultStringValues.mSize;

  header.mValueStrings.mOffset = offset;

  header.mValueStrings.mSize = mValueStringTable.Size();

  offset += header.mValueStrings.mSize;

  MemMapSnapshot mem;

  MOZ_TRY(mem.Init(offset));

  auto headerPtr = mem.Get<Header>();

  headerPtr[0] = header;

  auto* entryPtr = reinterpret_cast<SharedPrefMap::Entry*>(&headerPtr[1]);

  for (auto* entry : entries) {

    *entryPtr = {

      entry->mKey,          GetValue(*entry),

      entry->mType,         entry->mHasDefaultValue,

      entry->mHasUserValue, entry->mIsSticky,

      entry->mIsLocked,     entry->mDefaultChanged,

    };

    entryPtr++;

  }

  auto ptr = mem.Get<uint8_t>();

  mKeyTable.Write(

    { &ptr[header.mKeyStrings.mOffset], header.mKeyStrings.mSize });

  mValueStringTable.Write(

    { &ptr[header.mValueStrings.mOffset], header.mValueStrings.mSize });

  mIntValueTable.WriteDefaultValues(

    { &ptr[header.mDefaultIntValues.mOffset], header.mDefaultIntValues.mSize });

  mIntValueTable.WriteUserValues(

    { &ptr[header.mUserIntValues.mOffset], header.mUserIntValues.mSize });

  mStringValueTable.WriteDefaultValues(

    { &ptr[header.mDefaultStringValues.mOffset],

      header.mDefaultStringValues.mSize });

  mStringValueTable.WriteUserValues(

    { &ptr[header.mUserStringValues.mOffset], header.mUserStringValues.mSize });

  mKeyTable.Clear();

  mValueStringTable.Clear();

  mIntValueTable.Clear();

  mStringValueTable.Clear();

  mEntries.Clear();

  return mem.Finalize(aMap);

}

} // mozilla