Add font failure telemetry

content/child/dwrite_font_proxy/dwrite_font_proxy_win.cc

 // Copyright 2015 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/child/dwrite_font_proxy/dwrite_font_proxy_win.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 22 matching lines @@
 enum DirectWriteLoadFamilyResult {
   LOAD_FAMILY_SUCCESS_SINGLE_FAMILY = 0,
   LOAD_FAMILY_SUCCESS_MATCHED_FAMILY = 1,
   LOAD_FAMILY_ERROR_MULTIPLE_FAMILIES = 2,
   LOAD_FAMILY_ERROR_NO_FAMILIES = 3,
   LOAD_FAMILY_ERROR_NO_COLLECTION = 4,
 
   LOAD_FAMILY_MAX_VALUE
 };
 
+// This enum is used to define the buckets for an enumerated UMA histogram.
+// Hence,
+//   (a) existing enumerated constants should never be deleted or reordered, and
+//   (b) new constants should only be appended at the end of the enumeration.
+enum FontProxyError {
+  FIND_FAMILY_SEND_FAILED = 0,
+  GET_FAMILY_COUNT_SEND_FAILED = 1,
+  COLLECTION_KEY_INVALID = 2,
+  FAMILY_INDEX_OUT_OF_RANGE = 3,
+  GET_FONT_FILES_SEND_FAILED = 4,
+  MAPPED_FILE_FAILED = 5,
+
+  FONT_PROXY_ERROR_MAX_VALUE
+};
+
 const char kFontKeyName[] = "font_key_name";
 
 void LogLoadFamilyResult(DirectWriteLoadFamilyResult result) {
   UMA_HISTOGRAM_ENUMERATION("DirectWrite.Fonts.Proxy.LoadFamilyResult", result,
                             LOAD_FAMILY_MAX_VALUE);
 }
 
+void LogFamilyCount(uint32_t count) {
+  UMA_HISTOGRAM_COUNTS_1000("DirectWrite.Fonts.Proxy.FamilyCount", count);
+}
+
+void LogFontProxyError(FontProxyError error) {
+  UMA_HISTOGRAM_ENUMERATION("DirectWrite.Fonts.Proxy.FontProxyError", error,
+                            FONT_PROXY_ERROR_MAX_VALUE);
+}
+
 }  // namespace
 
 DWriteFontCollectionProxy::DWriteFontCollectionProxy() = default;
 
 DWriteFontCollectionProxy::~DWriteFontCollectionProxy() = default;
 
 HRESULT DWriteFontCollectionProxy::FindFamilyName(const WCHAR* family_name,
                                                   UINT32* index,
                                                   BOOL* exists) {
   DCHECK(family_name);
   DCHECK(index);
   DCHECK(exists);
   TRACE_EVENT0("dwrite", "FontProxy::FindFamilyName");
 
   uint32_t family_index = 0;
   base::string16 name(family_name);
 
   auto iter = family_names_.find(name);
   if (iter != family_names_.end()) {
     *index = iter->second;
     *exists = iter->second != UINT_MAX;
     return S_OK;
   }
 
   if (!GetSender()->Send(
           new DWriteFontProxyMsg_FindFamily(name, &family_index))) {
+    LogFontProxyError(FIND_FAMILY_SEND_FAILED);
     return E_FAIL;
   }
 
   if (family_index != UINT32_MAX) {
     if (!CreateFamily(family_index))
       return E_FAIL;
     *exists = TRUE;
     *index = family_index;
     families_[family_index]->SetName(name);
   } else {
@@ skipping 24 matching lines @@
 
 UINT32 DWriteFontCollectionProxy::GetFontFamilyCount() {
   if (family_count_ != UINT_MAX)
     return family_count_;
 
   TRACE_EVENT0("dwrite", "FontProxy::GetFontFamilyCount");
 
   uint32_t family_count = 0;
   if (!GetSender()->Send(
           new DWriteFontProxyMsg_GetFamilyCount(&family_count))) {
+    LogFontProxyError(GET_FAMILY_COUNT_SEND_FAILED);
     return 0;
   }
+
+  LogFamilyCount(family_count);
   family_count_ = family_count;
   return family_count;
 }
 
 HRESULT DWriteFontCollectionProxy::GetFontFromFontFace(
     IDWriteFontFace* font_face,
     IDWriteFont** font) {
   DCHECK(font_face);
   DCHECK(font);
 
   for (const auto& family : families_) {
     if (family && family->GetFontFromFontFace(font_face, font)) {
       return S_OK;
     }
   }
   // If the font came from our collection, at least one family should match
   DCHECK(false);
 
   return E_FAIL;
 }
 
 HRESULT DWriteFontCollectionProxy::CreateEnumeratorFromKey(
     IDWriteFactory* factory,
     const void* collection_key,
     UINT32 collection_key_size,
     IDWriteFontFileEnumerator** font_file_enumerator) {
   if (!collection_key || collection_key_size != sizeof(uint32_t)) {
+    LogFontProxyError(COLLECTION_KEY_INVALID);
     return E_INVALIDARG;
   }
 
   TRACE_EVENT0("dwrite", "FontProxy::LoadingFontFiles");
 
   const uint32_t* family_index =
       reinterpret_cast<const uint32_t*>(collection_key);
 
   if (*family_index >= GetFontFamilyCount()) {
+    LogFontProxyError(FAMILY_INDEX_OUT_OF_RANGE);
     return E_INVALIDARG;
   }
 
   // If we already loaded the family we should reuse the existing collection.
   DCHECK(!families_[*family_index]->IsLoaded());
 
   std::vector<base::string16> file_names;
   if (!GetSender()->Send(
           new DWriteFontProxyMsg_GetFontFiles(*family_index, &file_names))) {
+    LogFontProxyError(GET_FONT_FILES_SEND_FAILED);
     return E_FAIL;
   }
 
   HRESULT hr = mswr::MakeAndInitialize<FontFileEnumerator>(
       font_file_enumerator, factory, this, &file_names);
 
   if (!SUCCEEDED(hr)) {
     DCHECK(false);
     return E_FAIL;
   }
@@ skipping 368 matching lines @@
   if (fragment_offset + fragment_size > data_.length())
     return E_FAIL;
   *fragment_start = data_.data() + fragment_offset;
   *fragment_context = nullptr;
   return S_OK;
 }
 
 HRESULT FontFileStream::RuntimeClassInitialize(
     const base::string16& file_name) {
   data_.Initialize(base::FilePath(file_name));
-  if (!data_.IsValid())
+  if (!data_.IsValid()) {
+    LogFontProxyError(MAPPED_FILE_FAILED);
     return E_FAIL;
+  }
   return S_OK;
 }
 
 }  // namespace content