Remove font cache code

content/common/dwrite_font_platform_win.cc

-// 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";

[gab, 2016/04/06 14:25:23]

AFAICT this file isn't being cleaned up by this CL. Please follow-up with a CL
to add cleanup code for a couple of milestones (a TODO with date to remove in a
year is what we typically do for prefs, seems reasonable for a file too).

-
-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