// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/public/common/dwrite_font_platform_win.h"

#include <windows.h>
#include <stddef.h>
#include <stdint.h>

#include <dwrite.h>
#include <wrl/implements.h>
#include <wrl/wrappers/corewrappers.h>

#include <limits>
#include <map>
#include <string>
#include <utility>
#include <vector>

#include "base/command_line.h"
#include "base/debug/alias.h"
#include "base/debug/crash_logging.h"
#include "base/files/file_enumerator.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/memory_mapped_file.h"
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/shared_memory.h"
#include "base/metrics/field_trial.h"
#include "base/metrics/histogram.h"
#include "base/path_service.h"
#include "base/process/process_handle.h"
#include "base/stl_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/synchronization/lock.h"
#include "base/time/time.h"
#include "base/trace_event/trace_event.h"
#include "base/win/registry.h"
#include "base/win/scoped_comptr.h"
#include "content/public/common/content_switches.h"

namespace {

// Font Cache implementation short story:
// Due to our sandboxing restrictions, we cannot connect to Windows font cache
// service from Renderer and need to use DirectWrite isolated font loading
// mechanism.
// DirectWrite needs to be initialized before any of the API could be used.
// During initialization DirectWrite loads all font files and populates
// internal cache, we refer this phase as enumeration and we are trying
// to optimize this phase in our cache approach. Using cache during
// initialization will help improve on startup latency in each renderer
// instance.
// During enumeration DirectWrite reads various fragments from .ttf/.ttc
// font files. Our assumption is that these fragments are being read to
// cache information such as font families, supported sizes etc.
// For reading fragments DirectWrite calls ReadFragment of our FontFileStream
// implementation with parameters start_offset and length. We cache these
// parameters along with associated data chunk.
// Here is small example of how segments are read
// start_offset: 0, length: 16
// start_offset: 0, length: 12
// start_offset: 0, length: 117
// For better cache management we collapse segments if they overlap or are
// adjacent.

namespace mswr = Microsoft::WRL;

const char kFontKeyName[] = "font_key_name";

// We use this value to determine whether to cache file fragments
// or not. In our trials we observed that for some font files
// direct write ends up reading almost entire file during enumeration
// phase. If we don't use this percentile formula we will end up
// increasing significant cache size by caching entire file contents
// for some of the font files.
const double kMaxPercentileOfFontFileSizeToCache = 0.6;

// With current implementation we map entire shared section into memory during
// renderer startup. This causes increase in working set of Chrome. As first
// step we want to see if caching is really improving any performance for our
// users, so we are putting arbitrary limit on cache file size. There are
// multiple ways we can tune our working size, like mapping only required part
// of section at any given time.
const double kArbitraryCacheFileSizeLimit = (30 * 1024 * 1024);

// We have chosen current font file length arbitrarily. In our logic
// if we don't find file we are looking for in cache we end up loading
// that file directly from system fonts folder.
const unsigned int kMaxFontFileNameLength = 34;

const DWORD kCacheFileVersion = 103;
const DWORD kFileSignature = 0x4D4F5243; // CROM
const DWORD kMagicCompletionSignature = 0x454E4F44; // DONE

const DWORD kUndefinedDWORDS = 36;

// Make sure that all structure sizes align with 8 byte boundary otherwise
// dr. memory test may complain.
#pragma pack(push, 8)
// Cache file header, includes signature, completion bits and version.
struct CacheFileHeader {
  CacheFileHeader() {
    file_signature = kFileSignature;
    magic_completion_signature = 0;
    version = kCacheFileVersion;
    ::ZeroMemory(undefined, sizeof(undefined));
  }

  DWORD file_signature;
  DWORD magic_completion_signature;
  DWORD version;
  BYTE undefined[kUndefinedDWORDS];
};

// Entry for a particular font file within this cache.
struct CacheFileEntry {
  CacheFileEntry() {
    file_size = 0;
    entry_count = 0;
    ::ZeroMemory(file_name, sizeof(file_name));
  }

  UINT64 file_size;
  DWORD entry_count;
  wchar_t file_name[kMaxFontFileNameLength];
};

// Offsets or data chunks that are cached for particular font file.
struct CacheFileOffsetEntry {
  CacheFileOffsetEntry() {
    start_offset = 0;
    length = 0;
  }

  UINT64 start_offset;
  UINT64 length;
  /* BYTE blob_[];  // Place holder for the blob that follows. */
};
#pragma pack(pop)

bool ValidateFontCacheHeader(CacheFileHeader* header) {
  return (header->file_signature == kFileSignature &&
          header->magic_completion_signature == kMagicCompletionSignature &&
          header->version == kCacheFileVersion);
}

class FontCacheWriter;

// This class implements main interface required for loading custom font
// collection as specified by DirectWrite. We also use this class for storing
// some state information as this is one of the centralized entity.
class FontCollectionLoader
    : public mswr::RuntimeClass<mswr::RuntimeClassFlags<mswr::ClassicCom>,
                                IDWriteFontCollectionLoader> {
 public:
  FontCollectionLoader()
      : in_collection_building_mode_(false),
        create_static_cache_(false) {}

  ~FontCollectionLoader() override;

  HRESULT RuntimeClassInitialize() {
    return S_OK;
  }

  // IDWriteFontCollectionLoader methods.
  HRESULT STDMETHODCALLTYPE
  CreateEnumeratorFromKey(IDWriteFactory* factory,
                          void const* key,
                          UINT32 key_size,
                          IDWriteFontFileEnumerator** file_enumerator) override;

  // Does all the initialization for required loading fonts from registry.
  static HRESULT Initialize(IDWriteFactory* factory);

  // Returns font cache map size.
  UINT32 GetFontMapSize();

  // Returns font name string when given font index.
  base::string16 GetFontNameFromKey(UINT32 idx);

  // Loads internal structure with fonts from registry.
  bool LoadFontListFromRegistry();

  // Loads restricted web safe fonts as fallback method to registry fonts.
  bool LoadRestrictedFontList();

  // Puts class in collection building mode. In collection building mode
  // we use static cache if it is available as a look aside buffer.
  void EnableCollectionBuildingMode(bool enable);

  // Returns current state of collection building.
  bool InCollectionBuildingMode();

  // Loads static cache file.
  bool LoadCacheFile();

  // Unloads cache file and related data.
  void UnloadCacheFile();

  // Puts class in static cache creating mode. In this mode we record all
  // direct write requests and store chunks of font data.
  void EnterStaticCacheMode(const WCHAR* file_name);

  // Gets out of static cache building mode.
  void LeaveStaticCacheMode();

  // Returns if class is currently in static cache building mode.
  bool IsBuildStaticCacheMode();

  // Validates cache file for consistency.
  bool ValidateCacheFile(base::File* file);

 private:
  // Structure to represent each chunk within font file that we load in memory.
  struct CacheTableOffsetEntry {
    UINT64 start_offset;
    UINT64 length;
    BYTE* inside_file_ptr;
  };

  typedef std::vector<CacheTableOffsetEntry> OffsetVector;

  // Structure representing each font entry with cache.
  struct CacheTableEntry {
    UINT64 file_size;
    OffsetVector offset_entries;
  };

 public:
  // Returns whether file we have particular font entry within cache or not.
  bool IsFileCached(UINT32 font_key);
  // Returns cache fragment corresponding to specific font key.
  void* GetCachedFragment(UINT32 font_key, UINT64 start_offset, UINT64 length);
  // Returns actual font file size at the time of caching.
  UINT64 GetCachedFileSize(UINT32 font_key);

  // Returns instance of font cache writer. This class manages actual font
  // file format.
  FontCacheWriter* GetFontCacheWriter();

 private:
  // Functions validates and loads cache into internal map.
  bool ValidateAndLoadCacheMap();

  mswr::ComPtr<IDWriteFontFileLoader> file_loader_;

  std::vector<base::string16> reg_fonts_;
  bool in_collection_building_mode_;
  bool create_static_cache_;
  scoped_ptr<base::SharedMemory> cache_;
  scoped_ptr<FontCacheWriter> cache_writer_;

  typedef std::map<base::string16, CacheTableEntry*> CacheMap;
  CacheMap cache_map_;

  DISALLOW_COPY_AND_ASSIGN(FontCollectionLoader);
};

mswr::ComPtr<FontCollectionLoader> g_font_loader;
base::win::ScopedHandle g_shared_font_cache;

// Class responsible for handling font cache file format details as well as
// tracking various cache region requests by direct write.
class FontCacheWriter {
 public:
  FontCacheWriter() : count_font_entries_ignored_(0), cookie_counter_(0) {}

  ~FontCacheWriter() {
    if (static_cache_.get()) {
      static_cache_->Close();
    }
  }

 public:
  // Holds data related to individual region as requested by direct write.
  struct CacheRegion {
    UINT64 start_offset;
    UINT64 length;
    const BYTE* ptr;
    /* BYTE blob_[];  // Place holder for the blob that follows. */
  };

  // Function to create static font cache file.
  bool Create(const wchar_t* file_name) {
    static_cache_.reset(new base::File(base::FilePath(file_name),
        base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE |
        base::File::FLAG_EXCLUSIVE_WRITE));
    if (!static_cache_->IsValid()) {
      static_cache_.reset();
      return false;
    }
    CacheFileHeader header;

    // At offset 0 write cache version
    static_cache_->Write(0,
                         reinterpret_cast<const char*>(&header),
                         sizeof(header));

    static_cache_->Flush();
    return true;
  }

  // Closes static font cache file. Also writes completion signature to mark
  // it as completely written.
  void Close() {
    if (static_cache_.get()) {
      CacheFileHeader header;
      header.magic_completion_signature = kMagicCompletionSignature;
      // At offset 0 write cache version
      int bytes_written = static_cache_->Write(0,
          reinterpret_cast<const char*>(&header),
          sizeof(header));
      DCHECK_NE(bytes_written, -1);

      UMA_HISTOGRAM_MEMORY_KB("DirectWrite.Fonts.BuildCache.File.Size",
                              static_cache_->GetLength() / 1024);

      UMA_HISTOGRAM_COUNTS("DirectWrite.Fonts.BuildCache.Ignored",
                           count_font_entries_ignored_);

      static_cache_->Close();
      static_cache_.reset(NULL);
    }
  }

 private:
  typedef std::vector<CacheRegion> RegionVector;

  // Structure to track various regions requested by direct write for particular
  // font file.
  struct FontEntryInternal {
    FontEntryInternal(const wchar_t* name, UINT64 size)
        : file_name(name),
          file_size(size) {
    }

    base::string16 file_name;
    UINT64 file_size;
    RegionVector regions;
  };

 public:
  // Starts up new font entry to be tracked, returns cookie to identify this
  // particular entry.
  UINT NewFontEntry(const wchar_t* file_name, UINT64 file_size) {
    base::AutoLock lock(lock_);
    UINT old_counter = cookie_counter_;
    FontEntryInternal* font_entry = new FontEntryInternal(file_name, file_size);
    cookie_map_[cookie_counter_].reset(font_entry);
    cookie_counter_++;
    return old_counter;
  }

  // AddRegion function lets caller add various regions to be cached for
  // particular font file. Once enumerating that particular font file is done
  // (based on uniquely identifying cookie) changes could be committed using
  // CommitFontEntry
  bool AddRegion(UINT64 cookie, UINT64 start, UINT64 length, const BYTE* ptr) {
    base::AutoLock lock(lock_);
    if (cookie_map_.find(cookie) == cookie_map_.end())
      return false;
    RegionVector& regions = cookie_map_[cookie].get()->regions;
    CacheRegion region;
    region.start_offset = start;
    region.length = length;
    region.ptr = ptr;
    regions.push_back(region);
    return true;
  }

  // Function which commits after merging all collected regions into cache file.
  bool CommitFontEntry(UINT cookie) {
    base::AutoLock lock(lock_);
    if (cookie_map_.find(cookie) == cookie_map_.end())
      return false;

    // We will skip writing entries beyond allowed limit. Following condition
    // doesn't enforce hard file size. We need to write complete font entry.
    int64_t length = static_cache_->GetLength();
    if (length == -1 || length >= kArbitraryCacheFileSizeLimit) {
      count_font_entries_ignored_++;
      return false;
    }

    FontEntryInternal* font_entry = cookie_map_[cookie].get();
    RegionVector& regions = font_entry->regions;
    std::sort(regions.begin(), regions.end(), SortCacheRegions);

    // At this point, we have collected all regions to be cached. These regions
    // are tuples of start, length, data for particular data segment.
    // These tuples can overlap.
    // e.g. (0, 12, data), (0, 117, data), (21, 314, data), (335, 15, data)
    // In this case as you can see first three segments overlap and
    // 4th is adjacent. If we cache them individually then we will end up
    // caching duplicate data, so we merge these segments together to find
    // superset for the cache. In above example our algorithm should
    // produce (cache) single segment starting at offset 0 with length 350.
    RegionVector merged_regions;
    RegionVector::iterator iter;
    int idx = 0;
    for (iter = regions.begin(); iter != regions.end(); iter++) {
      if (iter == regions.begin()) {
        merged_regions.push_back(*iter);
        continue;
      }
      CacheRegion& base_region = merged_regions[idx];
      if (IsOverlap(&base_region, &(*iter))) {
        UINT64 end1 = base_region.start_offset + base_region.length;
        UINT64 end2 = iter->start_offset + iter->length;
        if (base_region.start_offset > iter->start_offset) {
          base_region.start_offset = iter->start_offset;
          base_region.ptr = iter->ptr;
        }
        base_region.length = std::max(end1, end2) - base_region.start_offset;
      } else {
        merged_regions.push_back(*iter);
        idx++;
      }
    }

    UINT64 total_merged_cache_in_bytes = 0;
    for (iter = merged_regions.begin(); iter != merged_regions.end(); iter++) {
      total_merged_cache_in_bytes += iter->length;
    }

    // We want to adjust following parameter based on experiments. But general
    // logic here is that if we are going to end up caching most of the contents
    // for a file (e.g. simsunb.ttf > 90%) then we should avoid caching that
    // file.
    double percentile = static_cast<double>(total_merged_cache_in_bytes) /
        font_entry->file_size;
    if (percentile > kMaxPercentileOfFontFileSizeToCache) {
      count_font_entries_ignored_++;
      return false;
    }

    CacheFileEntry entry;
    wcsncpy_s(entry.file_name, kMaxFontFileNameLength,
              font_entry->file_name.c_str(), _TRUNCATE);
    entry.file_size = font_entry->file_size;
    entry.entry_count = merged_regions.size();
    static_cache_->WriteAtCurrentPos(
        reinterpret_cast<const char*>(&entry),
        sizeof(entry));
    for (iter = merged_regions.begin(); iter != merged_regions.end(); iter++) {
      CacheFileOffsetEntry offset_entry;
      offset_entry.start_offset = iter->start_offset;
      offset_entry.length = iter->length;
      static_cache_->WriteAtCurrentPos(
          reinterpret_cast<const char*>(&offset_entry),
          sizeof(offset_entry));
      static_cache_->WriteAtCurrentPos(
          reinterpret_cast<const char*>(iter->ptr),
          iter->length);
    }
    return true;
  }

 private:
  // This is the count of font entries that we reject based on size to be
  // cached.
  unsigned int count_font_entries_ignored_;
  scoped_ptr<base::File> static_cache_;
  std::map<UINT, scoped_ptr<FontEntryInternal>> cookie_map_;
  UINT cookie_counter_;

  // Lock is required to protect internal data structures and access to file,
  // According to MSDN documentation on ReadFileFragment and based on our
  // experiments so far, there is possibility of ReadFileFragment getting called
  // from multiple threads.
  base::Lock lock_;

  // Function checks if two regions overlap or are adjacent.
  bool IsOverlap(CacheRegion* region1, CacheRegion* region2) {
    return
        !((region1->start_offset + region1->length) < region2->start_offset ||
          region1->start_offset > (region2->start_offset + region2->length));
  }

  // Function to sort cached regions.
  static bool SortCacheRegions(const CacheRegion& region1,
                               const CacheRegion& region2) {
    return
        region1.start_offset == region2.start_offset ?
            region1.length < region2.length :
            region1.start_offset < region2.start_offset;
  }

  DISALLOW_COPY_AND_ASSIGN(FontCacheWriter);
};

// Class implements IDWriteFontFileStream interface as required by direct write.
class FontFileStream
    : public mswr::RuntimeClass<mswr::RuntimeClassFlags<mswr::ClassicCom>,
                                IDWriteFontFileStream> {
 public:
  // IDWriteFontFileStream methods.
  HRESULT STDMETHODCALLTYPE ReadFileFragment(
      void const** fragment_start,
      UINT64 file_offset,
      UINT64 fragment_size,
      void** context) override {
    if (cached_data_) {
      *fragment_start = g_font_loader->GetCachedFragment(font_key_,
                                                         file_offset,
                                                         fragment_size);
      if (*fragment_start == NULL) {
        DCHECK(false);
      }
      *context = NULL;
      return *fragment_start != NULL ? S_OK : E_FAIL;
    }
    if (!memory_.get() || !memory_->IsValid() ||
        file_offset >= memory_->length() ||
        (file_offset + fragment_size) > memory_->length())
      return E_FAIL;

    *fragment_start = static_cast<BYTE const*>(memory_->data()) +
                      static_cast<size_t>(file_offset);
    *context = NULL;
    if (g_font_loader->IsBuildStaticCacheMode()) {
      FontCacheWriter* cache_writer = g_font_loader->GetFontCacheWriter();
      cache_writer->AddRegion(writer_cookie_,
                              file_offset,
                              fragment_size,
                              static_cast<const BYTE*>(*fragment_start));
    }
    return S_OK;
  }

  void STDMETHODCALLTYPE ReleaseFileFragment(void* context) override {}

  HRESULT STDMETHODCALLTYPE GetFileSize(UINT64* file_size) override {
    if (cached_data_) {
      *file_size = g_font_loader->GetCachedFileSize(font_key_);
      return S_OK;
    }

    if (!memory_.get() || !memory_->IsValid())
      return E_FAIL;

    *file_size = memory_->length();
    return S_OK;
  }

  HRESULT STDMETHODCALLTYPE GetLastWriteTime(UINT64* last_write_time) override {
    if (cached_data_) {
      *last_write_time = 0;
      return S_OK;
    }

    if (!memory_.get() || !memory_->IsValid())
      return E_FAIL;

    // According to MSDN article http://goo.gl/rrSYzi the "last modified time"
    // is used by DirectWrite font selection algorithms to determine whether
    // one font resource is more up to date than another one.
    // So by returning 0 we are assuming that it will treat all fonts to be
    // equally up to date.
    // TODO(shrikant): We should further investigate this.
    *last_write_time = 0;
    return S_OK;
  }

  FontFileStream() : font_key_(0), cached_data_(false) {}

  HRESULT RuntimeClassInitialize(UINT32 font_key) {
    if (g_font_loader->InCollectionBuildingMode() &&
        g_font_loader->IsFileCached(font_key)) {
      cached_data_ = true;
      font_key_ = font_key;
      return S_OK;
    }

    base::FilePath path;
    PathService::Get(base::DIR_WINDOWS_FONTS, &path);
    base::string16 font_key_name(g_font_loader->GetFontNameFromKey(font_key));
    path = path.Append(font_key_name.c_str());
    memory_.reset(new base::MemoryMappedFile());

    // Put some debug information on stack.
    WCHAR font_name[MAX_PATH];
    path.value().copy(font_name, arraysize(font_name));
    base::debug::Alias(font_name);

    if (!memory_->Initialize(path)) {
      memory_.reset();
      return E_FAIL;
    }

    font_key_ = font_key;

    base::debug::SetCrashKeyValue(kFontKeyName,
                                  base::WideToUTF8(font_key_name));

    if (g_font_loader->IsBuildStaticCacheMode()) {
      FontCacheWriter* cache_writer = g_font_loader->GetFontCacheWriter();
      writer_cookie_ = cache_writer->NewFontEntry(font_key_name.c_str(),
                                                  memory_->length());
    }
    return S_OK;
  }

  ~FontFileStream() override {
    if (g_font_loader->IsBuildStaticCacheMode()) {
      FontCacheWriter* cache_writer = g_font_loader->GetFontCacheWriter();
      cache_writer->CommitFontEntry(writer_cookie_);
    }
  }

 private:
  UINT32 font_key_;
  scoped_ptr<base::MemoryMappedFile> memory_;
  bool cached_data_;
  UINT writer_cookie_;

  DISALLOW_COPY_AND_ASSIGN(FontFileStream);
};

// Implements IDWriteFontFileLoader as required by FontFileLoader.
class FontFileLoader
    : public mswr::RuntimeClass<mswr::RuntimeClassFlags<mswr::ClassicCom>,
                                IDWriteFontFileLoader> {
 public:
  // IDWriteFontFileLoader methods.
  HRESULT STDMETHODCALLTYPE
  CreateStreamFromKey(void const* ref_key,
                      UINT32 ref_key_size,
                      IDWriteFontFileStream** stream) override {
    if (ref_key_size != sizeof(UINT32))
      return E_FAIL;

    UINT32 font_key = *static_cast<const UINT32*>(ref_key);
    mswr::ComPtr<FontFileStream> font_stream;
    HRESULT hr = mswr::MakeAndInitialize<FontFileStream>(&font_stream,
                                                         font_key);
    if (SUCCEEDED(hr)) {
      *stream = font_stream.Detach();
      return S_OK;
    }
    return E_FAIL;
  }

  FontFileLoader() {}
  ~FontFileLoader() override {}

 private:
  DISALLOW_COPY_AND_ASSIGN(FontFileLoader);
};

// Implements IDWriteFontFileEnumerator as required by direct write.
class FontFileEnumerator
    : public mswr::RuntimeClass<mswr::RuntimeClassFlags<mswr::ClassicCom>,
                                IDWriteFontFileEnumerator> {
 public:
  // IDWriteFontFileEnumerator methods.
  HRESULT STDMETHODCALLTYPE MoveNext(BOOL* has_current_file) override {
    *has_current_file = FALSE;

    if (current_file_)
      current_file_.ReleaseAndGetAddressOf();

    if (font_idx_ < g_font_loader->GetFontMapSize()) {
      HRESULT hr =
          factory_->CreateCustomFontFileReference(&font_idx_,
                                                  sizeof(UINT32),
                                                  file_loader_.Get(),
                                                  current_file_.GetAddressOf());
      DCHECK(SUCCEEDED(hr));
      *has_current_file = TRUE;
      font_idx_++;
    }
    return S_OK;
  }

  HRESULT STDMETHODCALLTYPE
  GetCurrentFontFile(IDWriteFontFile** font_file) override {
    if (!current_file_) {
      *font_file = NULL;
      return E_FAIL;
    }

    *font_file = current_file_.Detach();
    return S_OK;
  }

  FontFileEnumerator(const void* keys,
                     UINT32 buffer_size,
                     IDWriteFactory* factory,
                     IDWriteFontFileLoader* file_loader)
      : factory_(factory), file_loader_(file_loader), font_idx_(0) {}

  ~FontFileEnumerator() override {}

  mswr::ComPtr<IDWriteFactory> factory_;
  mswr::ComPtr<IDWriteFontFile> current_file_;
  mswr::ComPtr<IDWriteFontFileLoader> file_loader_;
  UINT32 font_idx_;

 private:
  DISALLOW_COPY_AND_ASSIGN(FontFileEnumerator);
};

// IDWriteFontCollectionLoader methods.
HRESULT STDMETHODCALLTYPE FontCollectionLoader::CreateEnumeratorFromKey(
    IDWriteFactory* factory,
    void const* key,
    UINT32 key_size,
    IDWriteFontFileEnumerator** file_enumerator) {
  *file_enumerator = mswr::Make<FontFileEnumerator>(
                         key, key_size, factory, file_loader_.Get()).Detach();
  return S_OK;
}

// static
HRESULT FontCollectionLoader::Initialize(IDWriteFactory* factory) {
  DCHECK(g_font_loader == NULL);

  HRESULT result;
  result = mswr::MakeAndInitialize<FontCollectionLoader>(&g_font_loader);
  if (FAILED(result) || !g_font_loader) {
    DCHECK(false);
    return E_FAIL;
  }

  CHECK(g_font_loader->LoadFontListFromRegistry());

  g_font_loader->file_loader_ = mswr::Make<FontFileLoader>().Detach();

  factory->RegisterFontFileLoader(g_font_loader->file_loader_.Get());
  factory->RegisterFontCollectionLoader(g_font_loader.Get());

  return S_OK;
}

FontCollectionLoader::~FontCollectionLoader() {
  STLDeleteContainerPairSecondPointers(cache_map_.begin(), cache_map_.end());
}

UINT32 FontCollectionLoader::GetFontMapSize() {
  return reg_fonts_.size();
}

base::string16 FontCollectionLoader::GetFontNameFromKey(UINT32 idx) {
  DCHECK(idx < reg_fonts_.size());
  return reg_fonts_[idx];
}

const base::FilePath::CharType* kFontExtensionsToIgnore[] {
  FILE_PATH_LITERAL(".FON"),  // Bitmap or vector
  FILE_PATH_LITERAL(".PFM"),  // Adobe Type 1
  FILE_PATH_LITERAL(".PFB"),  // Adobe Type 1
};

const wchar_t* kFontsToIgnore[] = {
  // "Gill Sans Ultra Bold" turns into an Ultra Bold weight "Gill Sans" in
  // DirectWrite, but most users don't have any other weights. The regular
  // weight font is named "Gill Sans MT", but that ends up in a different
  // family with that name. On Mac, there's a "Gill Sans" with various weights,
  // so CSS authors use { 'font-family': 'Gill Sans', 'Gill Sans MT', ... } and
  // because of the DirectWrite family futzing, they end up with an Ultra Bold
  // font, when they just wanted "Gill Sans". Mozilla implemented a more
  // complicated hack where they effectively rename the Ultra Bold font to
  // "Gill Sans MT Ultra Bold", but because the Ultra Bold font is so ugly
  // anyway, we simply ignore it. See
  // http://www.microsoft.com/typography/fonts/font.aspx?FMID=978 for a picture
  // of the font, and the file name. We also ignore "Gill Sans Ultra Bold
  // Condensed".
  L"gilsanub.ttf",
  L"gillubcd.ttf",
};

bool FontCollectionLoader::LoadFontListFromRegistry() {
  const wchar_t kFontsRegistry[] =
      L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts";
  CHECK(reg_fonts_.empty());
  base::win::RegKey regkey;
  if (regkey.Open(HKEY_LOCAL_MACHINE, kFontsRegistry, KEY_READ) !=
      ERROR_SUCCESS) {
    return false;
  }

  base::FilePath system_font_path;
  PathService::Get(base::DIR_WINDOWS_FONTS, &system_font_path);

  base::string16 name;
  base::string16 value;
  for (DWORD idx = 0; idx < regkey.GetValueCount(); idx++) {
    if (regkey.GetValueNameAt(idx, &name) == ERROR_SUCCESS &&
        regkey.ReadValue(name.c_str(), &value) == ERROR_SUCCESS) {
      base::FilePath path(value.c_str());
      // We need to check if path in registry is absolute, if it is then
      // we check if it is same as DIR_WINDOWS_FONTS otherwise we ignore.
      bool absolute = path.IsAbsolute();
      if (absolute &&
          !base::FilePath::CompareEqualIgnoreCase(system_font_path.value(),
                                                  path.DirName().value())) {
        continue;
      }

      // Ignore if path ends with a separator.
      if (path.EndsWithSeparator())
        continue;

      if (absolute)
        value = path.BaseName().value();

      bool should_ignore = false;
      for (const auto& ignore : kFontsToIgnore) {
        if (base::FilePath::CompareEqualIgnoreCase(value, ignore)) {
          should_ignore = true;
          break;
        }
      }
      // DirectWrite doesn't support bitmap/vector fonts and Adobe type 1
      // fonts, we will ignore those font extensions.
      // MSDN article: http://goo.gl/TfCOA
      if (!should_ignore) {
        for (const auto& ignore : kFontExtensionsToIgnore) {
          if (path.MatchesExtension(ignore)) {
            should_ignore = true;
            break;
          }
        }
      }

      if (!should_ignore)
        reg_fonts_.push_back(value.c_str());
    }
  }
  UMA_HISTOGRAM_COUNTS("DirectWrite.Fonts.Loaded", reg_fonts_.size());
  UMA_HISTOGRAM_COUNTS("DirectWrite.Fonts.Ignored",
                       regkey.GetValueCount() - reg_fonts_.size());
  return true;
}

// This list is mainly based on prefs/prefs_tab_helper.cc kFontDefaults.
const wchar_t* kRestrictedFontSet[] = {
  // These are the "Web Safe" fonts.
  L"times.ttf",     // IDS_STANDARD_FONT_FAMILY
  L"timesbd.ttf",   // IDS_STANDARD_FONT_FAMILY
  L"timesbi.ttf",   // IDS_STANDARD_FONT_FAMILY
  L"timesi.ttf",    // IDS_STANDARD_FONT_FAMILY
  L"cour.ttf",      // IDS_FIXED_FONT_FAMILY
  L"courbd.ttf",    // IDS_FIXED_FONT_FAMILY
  L"courbi.ttf",    // IDS_FIXED_FONT_FAMILY
  L"couri.ttf",     // IDS_FIXED_FONT_FAMILY
  L"consola.ttf",   // IDS_FIXED_FONT_FAMILY_ALT_WIN
  L"consolab.ttf",  // IDS_FIXED_FONT_FAMILY_ALT_WIN
  L"consolai.ttf",  // IDS_FIXED_FONT_FAMILY_ALT_WIN
  L"consolaz.ttf",  // IDS_FIXED_FONT_FAMILY_ALT_WIN
  L"arial.ttf",     // IDS_SANS_SERIF_FONT_FAMILY
  L"arialbd.ttf",   // IDS_SANS_SERIF_FONT_FAMILY
  L"arialbi.ttf",   // IDS_SANS_SERIF_FONT_FAMILY
  L"ariali.ttf",    // IDS_SANS_SERIF_FONT_FAMILY
  L"comic.ttf",     // IDS_CURSIVE_FONT_FAMILY
  L"comicbd.ttf",   // IDS_CURSIVE_FONT_FAMILY
  L"comici.ttf",    // IDS_CURSIVE_FONT_FAMILY
  L"comicz.ttf",    // IDS_CURSIVE_FONT_FAMILY
  L"impact.ttf",    // IDS_FANTASY_FONT_FAMILY
  L"georgia.ttf",
  L"georgiab.ttf",
  L"georgiai.ttf",
  L"georgiaz.ttf",
  L"trebuc.ttf",
  L"trebucbd.ttf",
  L"trebucbi.ttf",
  L"trebucit.ttf",
  L"verdana.ttf",
  L"verdanab.ttf",
  L"verdanai.ttf",
  L"verdanaz.ttf",
  L"segoeui.ttf",   // IDS_PICTOGRAPH_FONT_FAMILY
  L"segoeuib.ttf",  // IDS_PICTOGRAPH_FONT_FAMILY
  L"segoeuii.ttf",  // IDS_PICTOGRAPH_FONT_FAMILY
  L"msgothic.ttc",  // IDS_STANDARD_FONT_FAMILY_JAPANESE
  L"msmincho.ttc",  // IDS_SERIF_FONT_FAMILY_JAPANESE
  L"gulim.ttc",     // IDS_FIXED_FONT_FAMILY_KOREAN
  L"batang.ttc",    // IDS_SERIF_FONT_FAMILY_KOREAN
  L"simsun.ttc",    // IDS_STANDARD_FONT_FAMILY_SIMPLIFIED_HAN
  L"mingliu.ttc",   // IDS_SERIF_FONT_FAMILY_TRADITIONAL_HAN

  // These are from the Blink fallback list.
  L"david.ttf",     // USCRIPT_HEBREW
  L"davidbd.ttf",   // USCRIPT_HEBREW
  L"euphemia.ttf",  // USCRIPT_CANADIAN_ABORIGINAL
  L"gautami.ttf",   // USCRIPT_TELUGU
  L"gautamib.ttf",  // USCRIPT_TELUGU
  L"latha.ttf",     // USCRIPT_TAMIL
  L"lathab.ttf",    // USCRIPT_TAMIL
  L"mangal.ttf",    // USCRIPT_DEVANAGARI
  L"mangalb.ttf",   // USCRIPT_DEVANAGARI
  L"monbaiti.ttf",  // USCRIPT_MONGOLIAN
  L"mvboli.ttf",    // USCRIPT_THAANA
  L"plantc.ttf",    // USCRIPT_CHEROKEE
  L"raavi.ttf",     // USCRIPT_GURMUKHI
  L"raavib.ttf",    // USCRIPT_GURMUKHI
  L"shruti.ttf",    // USCRIPT_GUJARATI
  L"shrutib.ttf",   // USCRIPT_GUJARATI
  L"sylfaen.ttf",   // USCRIPT_GEORGIAN and USCRIPT_ARMENIAN
  L"tahoma.ttf",    // USCRIPT_ARABIC,
  L"tahomabd.ttf",  // USCRIPT_ARABIC,
  L"tunga.ttf",     // USCRIPT_KANNADA
  L"tungab.ttf",    // USCRIPT_KANNADA
  L"vrinda.ttf",    // USCRIPT_BENGALI
  L"vrindab.ttf",   // USCRIPT_BENGALI
};

bool FontCollectionLoader::LoadRestrictedFontList() {
  reg_fonts_.clear();
  reg_fonts_.assign(kRestrictedFontSet,
                    kRestrictedFontSet + _countof(kRestrictedFontSet));
  return true;
}

void FontCollectionLoader::EnableCollectionBuildingMode(bool enable) {
  in_collection_building_mode_ = enable;
}

bool FontCollectionLoader::InCollectionBuildingMode() {
  return  in_collection_building_mode_;
}

bool FontCollectionLoader::IsFileCached(UINT32 font_key) {
  if (!cache_.get() || cache_->memory() == NULL) {
    return false;
  }
  CacheMap::iterator iter = cache_map_.find(
      GetFontNameFromKey(font_key).c_str());
  return iter != cache_map_.end();
}

bool FontCollectionLoader::LoadCacheFile() {
  TRACE_EVENT0("startup", "FontCollectionLoader::LoadCacheFile");

  std::string font_cache_handle_string =
      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
          switches::kFontCacheSharedHandle);
  if (font_cache_handle_string.empty())
    return false;

  unsigned int handle_uint;
  base::StringToUint(font_cache_handle_string, &handle_uint);
  DCHECK(handle_uint);
  if (handle_uint > static_cast<unsigned int>(std::numeric_limits<long>::max()))
    return false;
  base::SharedMemoryHandle font_cache_handle(LongToHandle(handle_uint),
                                             base::GetCurrentProcId());

  base::SharedMemory* shared_mem = new base::SharedMemory(
      font_cache_handle, true);
  // Map the cache file into memory.
  shared_mem->Map(0);

  cache_.reset(shared_mem);

  if (base::StartsWith(base::FieldTrialList::FindFullName("LightSpeed"),
                       "PrefetchDWriteFontCache",
                       base::CompareCase::SENSITIVE)) {
    // Prefetch the cache, to avoid unordered IO when it is used.
    // PrefetchVirtualMemory() is loaded dynamically because it is only
    // available from Win8.
    decltype(PrefetchVirtualMemory)* prefetch_virtual_memory =
        reinterpret_cast<decltype(PrefetchVirtualMemory)*>(::GetProcAddress(
            ::GetModuleHandle(L"kernel32.dll"), "PrefetchVirtualMemory"));
    if (prefetch_virtual_memory != NULL) {
      WIN32_MEMORY_RANGE_ENTRY memory_range;
      memory_range.VirtualAddress = shared_mem->memory();
      memory_range.NumberOfBytes = shared_mem->mapped_size();
      prefetch_virtual_memory(::GetCurrentProcess(), 1, &memory_range, 0);
    }
  }

  if (!ValidateAndLoadCacheMap()) {
    cache_.reset();
    return false;
  }

  return true;
}

void FontCollectionLoader::UnloadCacheFile() {
  cache_.reset();
  STLDeleteContainerPairSecondPointers(cache_map_.begin(), cache_map_.end());
  cache_map_.clear();
}

void FontCollectionLoader::EnterStaticCacheMode(const WCHAR* file_name) {
  cache_writer_.reset(new FontCacheWriter());
  if (cache_writer_->Create(file_name))
    create_static_cache_ = true;
}

void FontCollectionLoader::LeaveStaticCacheMode() {
  cache_writer_->Close();
  cache_writer_.reset(NULL);
  create_static_cache_ = false;
}

bool FontCollectionLoader::IsBuildStaticCacheMode() {
  return create_static_cache_;
}

bool FontCollectionLoader::ValidateAndLoadCacheMap() {
  BYTE* mem_file_start = static_cast<BYTE*>(cache_->memory());
  BYTE* mem_file_end = mem_file_start + cache_->mapped_size();

  BYTE* current_ptr = mem_file_start;
  CacheFileHeader* file_header =
      reinterpret_cast<CacheFileHeader*>(current_ptr);
  if (!ValidateFontCacheHeader(file_header))
    return false;

  current_ptr = current_ptr + sizeof(CacheFileHeader);
  if (current_ptr >= mem_file_end)
    return false;

  while ((current_ptr + sizeof(CacheFileEntry)) < mem_file_end) {
    CacheFileEntry* entry = reinterpret_cast<CacheFileEntry*>(current_ptr);
    current_ptr += sizeof(CacheFileEntry);
    WCHAR file_name[kMaxFontFileNameLength];
    wcsncpy_s(file_name,
              kMaxFontFileNameLength,
              entry->file_name,
              _TRUNCATE);
    CacheTableEntry* table_entry = NULL;
    CacheMap::iterator iter = cache_map_.find(file_name);
    if (iter == cache_map_.end()) {
      table_entry = new CacheTableEntry();
      cache_map_[file_name] = table_entry;
    } else {
      table_entry = iter->second;
    }
    table_entry->file_size = entry->file_size;
    for (DWORD idx = 0;
         (current_ptr + sizeof(CacheFileOffsetEntry)) < mem_file_end &&
         idx < entry->entry_count;
         idx++) {
      CacheFileOffsetEntry* offset_entry =
          reinterpret_cast<CacheFileOffsetEntry*>(current_ptr);
      CacheTableOffsetEntry table_offset_entry;
      table_offset_entry.start_offset = offset_entry->start_offset;
      table_offset_entry.length = offset_entry->length;
      table_offset_entry.inside_file_ptr =
          current_ptr + sizeof(CacheFileOffsetEntry);
      table_entry->offset_entries.push_back(table_offset_entry);
      current_ptr += sizeof(CacheFileOffsetEntry);
      current_ptr += offset_entry->length;
    }
  }

  return true;
}

void* FontCollectionLoader::GetCachedFragment(UINT32 font_key,
                                              UINT64 start_offset,
                                              UINT64 length) {
  UINT64 just_past_end = start_offset + length;
  CacheMap::iterator iter = cache_map_.find(
      GetFontNameFromKey(font_key).c_str());
  if (iter != cache_map_.end()) {
    CacheTableEntry* entry = iter->second;
    OffsetVector::iterator offset_iter = entry->offset_entries.begin();
    while (offset_iter != entry->offset_entries.end()) {
      UINT64 available_just_past_end =
          offset_iter->start_offset + offset_iter->length;
      if (offset_iter->start_offset <= start_offset &&
          just_past_end <= available_just_past_end) {
        return offset_iter->inside_file_ptr +
            (start_offset - offset_iter->start_offset);
      }
      offset_iter++;
    }
  }
  return NULL;
}

UINT64 FontCollectionLoader::GetCachedFileSize(UINT32 font_key) {
  CacheMap::iterator iter = cache_map_.find(
      GetFontNameFromKey(font_key).c_str());
  if (iter != cache_map_.end()) {
    return iter->second->file_size;
  }
  return 0;
}

FontCacheWriter* FontCollectionLoader::GetFontCacheWriter() {
  return cache_writer_.get();
}

}  // namespace

namespace content {

const char kFontCacheSharedSectionName[] = "ChromeDWriteFontCache";

mswr::ComPtr<IDWriteFontCollection> g_font_collection;

IDWriteFontCollection* GetCustomFontCollection(IDWriteFactory* factory) {
  if (g_font_collection.Get() != NULL)
    return g_font_collection.Get();

  TRACE_EVENT0("startup", "content::GetCustomFontCollection");

  base::TimeTicks start_tick = base::TimeTicks::Now();

  FontCollectionLoader::Initialize(factory);

  bool cache_file_loaded = g_font_loader->LoadCacheFile();

  // Arbitrary threshold to stop loading enormous number of fonts. Usual
  // side effect of loading large number of fonts results in renderer getting
  // killed as it appears to hang.
  const UINT32 kMaxFontThreshold = 1750;
  HRESULT hr = E_FAIL;
  if (cache_file_loaded ||
      g_font_loader->GetFontMapSize() < kMaxFontThreshold) {
    g_font_loader->EnableCollectionBuildingMode(true);
    hr = factory->CreateCustomFontCollection(
        g_font_loader.Get(), NULL, 0, g_font_collection.GetAddressOf());
    g_font_loader->UnloadCacheFile();
    g_font_loader->EnableCollectionBuildingMode(false);
  }
  bool loading_restricted = false;
  if (FAILED(hr) || !g_font_collection.Get()) {
    loading_restricted = true;
    // We will try here just one more time with restricted font set.
    g_font_loader->LoadRestrictedFontList();
    hr = factory->CreateCustomFontCollection(
        g_font_loader.Get(), NULL, 0, g_font_collection.GetAddressOf());
  }

  base::TimeDelta time_delta = base::TimeTicks::Now() - start_tick;
  int64_t delta = time_delta.ToInternalValue();
  base::debug::Alias(&delta);
  UINT32 size = g_font_loader->GetFontMapSize();
  base::debug::Alias(&size);
  base::debug::Alias(&loading_restricted);

  CHECK(SUCCEEDED(hr));
  CHECK(g_font_collection.Get() != NULL);

  if (cache_file_loaded)
    UMA_HISTOGRAM_TIMES("DirectWrite.Fonts.LoadTime.Cached", time_delta);
  else
    UMA_HISTOGRAM_TIMES("DirectWrite.Fonts.LoadTime", time_delta);

  base::debug::ClearCrashKey(kFontKeyName);

  return g_font_collection.Get();
}

bool BuildFontCacheInternal(const WCHAR* file_name) {
  typedef decltype(DWriteCreateFactory)* DWriteCreateFactoryProc;
  HMODULE dwrite_dll = LoadLibraryW(L"dwrite.dll");
  if (!dwrite_dll) {
    DWORD load_library_get_last_error = GetLastError();
    base::debug::Alias(&dwrite_dll);
    base::debug::Alias(&load_library_get_last_error);
    CHECK(false);
  }

  DWriteCreateFactoryProc dwrite_create_factory_proc =
      reinterpret_cast<DWriteCreateFactoryProc>(
          GetProcAddress(dwrite_dll, "DWriteCreateFactory"));

  if (!dwrite_create_factory_proc) {
    DWORD get_proc_address_get_last_error = GetLastError();
    base::debug::Alias(&dwrite_create_factory_proc);
    base::debug::Alias(&get_proc_address_get_last_error);
    CHECK(false);
  }

  mswr::ComPtr<IDWriteFactory> factory;

  CHECK(SUCCEEDED(
      dwrite_create_factory_proc(
          DWRITE_FACTORY_TYPE_ISOLATED,
          __uuidof(IDWriteFactory),
          reinterpret_cast<IUnknown**>(factory.GetAddressOf()))));

  base::TimeTicks start_tick = base::TimeTicks::Now();

  FontCollectionLoader::Initialize(factory.Get());

  g_font_loader->EnterStaticCacheMode(file_name);

  mswr::ComPtr<IDWriteFontCollection> font_collection;

  HRESULT hr = E_FAIL;
  g_font_loader->EnableCollectionBuildingMode(true);
  hr = factory->CreateCustomFontCollection(
      g_font_loader.Get(), NULL, 0, font_collection.GetAddressOf());
  g_font_loader->EnableCollectionBuildingMode(false);

  bool loading_restricted = false;
  if (FAILED(hr) || !font_collection.Get()) {
    loading_restricted = true;
    // We will try here just one more time with restricted font set.
    g_font_loader->LoadRestrictedFontList();
    hr = factory->CreateCustomFontCollection(
        g_font_loader.Get(), NULL, 0, font_collection.GetAddressOf());
  }

  g_font_loader->LeaveStaticCacheMode();

  base::TimeDelta time_delta = base::TimeTicks::Now() - start_tick;
  int64_t delta = time_delta.ToInternalValue();
  base::debug::Alias(&delta);
  UINT32 size = g_font_loader->GetFontMapSize();
  base::debug::Alias(&size);
  base::debug::Alias(&loading_restricted);

  CHECK(SUCCEEDED(hr));
  CHECK(font_collection.Get() != NULL);

  base::debug::ClearCrashKey(kFontKeyName);

  return true;
}

bool ValidateFontCacheFile(base::File* file) {
  DCHECK(file != NULL);
  CacheFileHeader file_header;
  if (file->Read(0, reinterpret_cast<char*>(&file_header), sizeof(file_header))
      == -1) {
    return false;
  }
  return ValidateFontCacheHeader(&file_header);
}

bool LoadFontCache(const base::FilePath& path) {
  scoped_ptr<base::File> file(new base::File(path,
                              base::File::FLAG_OPEN | base::File::FLAG_READ));
  if (!file->IsValid())
    return false;

  if (!ValidateFontCacheFile(file.get()))
    return false;

  base::string16 name(base::ASCIIToUTF16(content::kFontCacheSharedSectionName));
  name.append(base::UintToString16(base::GetCurrentProcId()));
  HANDLE mapping = ::CreateFileMapping(
      file->GetPlatformFile(),
      NULL,
      PAGE_READONLY,
      0,
      0,
      name.c_str());
  if (mapping == INVALID_HANDLE_VALUE)
    return false;

  if (::GetLastError() == ERROR_ALREADY_EXISTS) {
    CloseHandle(mapping);
    // We crash here, as no one should have created this mapping except Chrome.
    CHECK(false);
    return false;
  }

  DCHECK(!g_shared_font_cache.IsValid());
  g_shared_font_cache.Set(mapping);

  return true;
}

bool BuildFontCache(const base::FilePath& file) {
  return BuildFontCacheInternal(file.value().c_str());
}

bool ShouldUseDirectWriteFontProxyFieldTrial() {
  return base::StartsWith(
      base::FieldTrialList::FindFullName("DirectWriteFontProxy"),
      "UseDirectWriteFontProxy", base::CompareCase::SENSITIVE);
}

}  // namespace content