DirectWrite Font Cache browser side hookup

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/common/dwrite_font_platform_win.h"
+#include "content/public/common/dwrite_font_platform_win.h"
 
 #include <dwrite.h>
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 #include <wrl/implements.h>
 #include <wrl/wrappers/corewrappers.h>
 
 #include "base/command_line.h"
@@ skipping 10 matching lines @@
 #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/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "content/public/common/content_switches.h"
-#include "content/public/common/dwrite_font_cache_win.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
@@ skipping 16 matching lines @@
 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.7;
+const double kMaxPercentileOfFontFileSizeToCache = 0.5;
+
+// 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 = (20 * 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 = 101;
 const DWORD kFileSignature = 0x4D4F5243; // CROM
 const DWORD kMagicCompletionSignature = 0x454E4F44; // DONE
 
@@ skipping 277 matching lines @@
     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 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
@@ skipping 734 matching lines @@
   base::TimeDelta time_delta = base::TimeTicks::Now() - start_tick;
   int64 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);
 
-  UMA_HISTOGRAM_TIMES("DirectWrite.Fonts.LoadTime", time_delta);
-
   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) {
@@ skipping 29 matching lines @@
     CHECK(false);
     return false;
   }
 
   DCHECK(!g_shared_font_cache.IsValid());
   g_shared_font_cache.Set(mapping);
 
   return true;
 }
 
-// Assumption for this function is that it will get called through a posted task
-// on FILE thread.
-bool BuildAndLoadFontCache(const base::FilePath& file) {
-  if (BuildFontCacheInternal(file.value().c_str()))
-    return LoadFontCache(file);
-  return false;
+bool BuildFontCache(const base::FilePath& file) {
+  return BuildFontCacheInternal(file.value().c_str());
 }
 
 }  // namespace content