Add checks to font proxy for diagnostics.

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 53 matching lines @@
 
   auto iter = family_names_.find(name);
   if (iter != family_names_.end()) {
     *index = iter->second;
     *exists = iter->second != UINT_MAX;
     return S_OK;
   }
 
   if (!sender_.Run()->Send(
           new DWriteFontProxyMsg_FindFamily(name, &family_index))) {
+    CHECK(false);
     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 (!sender_.Run()->Send(
           new DWriteFontProxyMsg_GetFamilyCount(&family_count))) {
+    CHECK(false);
     return 0;
   }
+  CHECK(family_count != 0);
   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))
+    if (family && family->GetFontFromFontFace(font_face, font)) {
       return S_OK;
+    }
   }
+  // If the font came from our collection, at least one family should match
+  CHECK(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))
+  if (!collection_key || collection_key_size != sizeof(uint32_t)) {
+    CHECK(false);
     return E_INVALIDARG;
+  }
 
   TRACE_EVENT0("dwrite", "FontProxy::LoadingFontFiles");
 
   const uint32_t* family_index =
       reinterpret_cast<const uint32_t*>(collection_key);
 
-  if (*family_index >= GetFontFamilyCount())
+  if (*family_index >= GetFontFamilyCount()) {
     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 (!sender_.Run()->Send(
           new DWriteFontProxyMsg_GetFontFiles(*family_index, &file_names))) {
+    CHECK(false);
     return E_FAIL;
   }
 
   HRESULT hr = mswr::MakeAndInitialize<FontFileEnumerator>(
       font_file_enumerator, factory, this, &file_names);
 
-  if (!SUCCEEDED(hr))
+  if (!SUCCEEDED(hr)) {
+    CHECK(false);
     return E_FAIL;
+  }
 
   return S_OK;
 }
 
 HRESULT DWriteFontCollectionProxy::CreateStreamFromKey(
     const void* font_file_reference_key,
     UINT32 font_file_reference_key_size,
     IDWriteFontFileStream** font_file_stream) {
-  if (!font_file_reference_key)
+  if (!font_file_reference_key) {
+    CHECK(false);
     return E_FAIL;
+  }
 
   const base::char16* file_name =
       reinterpret_cast<const base::char16*>(font_file_reference_key);
   DCHECK_EQ(font_file_reference_key_size % sizeof(base::char16), 0u);
   size_t file_name_size =
       static_cast<size_t>(font_file_reference_key_size) / sizeof(base::char16);
 
-  if (file_name_size == 0 || file_name[file_name_size - 1] != L'\0')
+  if (file_name_size == 0 || file_name[file_name_size - 1] != L'\0') {
+    CHECK(false);
     return E_FAIL;
+  }
 
   TRACE_EVENT0("dwrite", "FontFileEnumerator::CreateStreamFromKey");
 
   mswr::ComPtr<IDWriteFontFileStream> stream;
-  if (!SUCCEEDED(mswr::MakeAndInitialize<FontFileStream>(&stream, file_name)))
+  if (!SUCCEEDED(mswr::MakeAndInitialize<FontFileStream>(&stream, file_name))) {
+    CHECK(false);
     return E_FAIL;
+  }
   *font_file_stream = stream.Detach();
   return S_OK;
 }
 
 HRESULT DWriteFontCollectionProxy::RuntimeClassInitialize(
     IDWriteFactory* factory,
     const base::Callback<IPC::Sender*(void)>& sender) {
-  DCHECK(factory);
+  CHECK(factory);
 
   factory_ = factory;
   sender_ = sender;
 
   HRESULT hr = factory->RegisterFontCollectionLoader(this);
-  DCHECK(SUCCEEDED(hr));
+  CHECK(SUCCEEDED(hr));
   hr = factory_->RegisterFontFileLoader(this);
-  DCHECK(SUCCEEDED(hr));
+  CHECK(SUCCEEDED(hr));
   return S_OK;
 }
 
 void DWriteFontCollectionProxy::Unregister() {
   factory_->UnregisterFontCollectionLoader(this);
   factory_->UnregisterFontFileLoader(this);
 }
 
 bool DWriteFontCollectionProxy::LoadFamily(
     UINT32 family_index,
     IDWriteFontCollection** containing_collection) {
   TRACE_EVENT0("dwrite", "FontProxy::LoadFamily");
 
   uint32_t index = family_index;
   // CreateCustomFontCollection ends up calling
   // DWriteFontCollectionProxy::CreateEnumeratorFromKey.
   HRESULT hr = factory_->CreateCustomFontCollection(
       this /*collectionLoader*/, reinterpret_cast<const void*>(&index),
       sizeof(index), containing_collection);
+  CHECK(SUCCEEDED(hr));
 
   return SUCCEEDED(hr);
 }
 
 bool DWriteFontCollectionProxy::LoadFamilyNames(
     UINT32 family_index,
     IDWriteLocalizedStrings** localized_strings) {
   TRACE_EVENT0("dwrite", "FontProxy::LoadFamilyNames");
 
   std::vector<std::pair<base::string16, base::string16>> strings;
   if (!sender_.Run()->Send(
           new DWriteFontProxyMsg_GetFamilyNames(family_index, &strings))) {
+    CHECK(false);
     return false;
   }
 
   HRESULT hr = mswr::MakeAndInitialize<DWriteLocalizedStrings>(
       localized_strings, &strings);
 
+  CHECK(SUCCEEDED(hr));
   return SUCCEEDED(hr);
 }
 
 bool DWriteFontCollectionProxy::CreateFamily(UINT32 family_index) {
   if (family_index < families_.size() && families_[family_index])
     return true;
 
   UINT32 family_count = GetFontFamilyCount();
-  if (family_index >= family_count)
+  if (family_index >= family_count) {
     return false;
+  }
 
   if (families_.size() < family_count)
     families_.resize(family_count);
 
   mswr::ComPtr<DWriteFontFamilyProxy> family;
   HRESULT hr = mswr::MakeAndInitialize<DWriteFontFamilyProxy>(&family, this,
                                                               family_index);
-  DCHECK(SUCCEEDED(hr));
-  DCHECK_LT(family_index, families_.size());
+  CHECK(SUCCEEDED(hr));
+  CHECK_LT(family_index, families_.size());
 
   families_[family_index] = family;
   return true;
 }
 
 DWriteFontFamilyProxy::DWriteFontFamilyProxy() = default;
 
 DWriteFontFamilyProxy::~DWriteFontFamilyProxy() = default;
 
 HRESULT DWriteFontFamilyProxy::GetFontCollection(
@@ skipping 11 matching lines @@
   // well save an IPC here.
   if (!LoadFamily())
     return 0;
 
   return family_->GetFontCount();
 }
 
 HRESULT DWriteFontFamilyProxy::GetFont(UINT32 index, IDWriteFont** font) {
   DCHECK(font);
 
-  if (index >= GetFontCount())
+  if (index >= GetFontCount()) {
+    CHECK(false);
     return E_INVALIDARG;
+  }
   if (!LoadFamily())
     return E_FAIL;
 
   return family_->GetFont(index, font);
 }
 
 HRESULT DWriteFontFamilyProxy::GetFamilyNames(IDWriteLocalizedStrings** names) {
   DCHECK(names);
 
   // Prefer the real thing, if available.
@@ skipping 57 matching lines @@
 bool DWriteFontFamilyProxy::GetFontFromFontFace(IDWriteFontFace* font_face,
                                                 IDWriteFont** font) {
   DCHECK(font_face);
   DCHECK(font);
 
   if (!family_)
     return false;
 
   mswr::ComPtr<IDWriteFontCollection> collection;
   HRESULT hr = family_->GetFontCollection(&collection);
-  DCHECK(SUCCEEDED(hr));
+  CHECK(SUCCEEDED(hr));
   hr = collection->GetFontFromFontFace(font_face, font);
 
   return SUCCEEDED(hr);
 }
 
 void DWriteFontFamilyProxy::SetName(const base::string16& family_name) {
   family_name_.assign(family_name);
 }
 
 bool DWriteFontFamilyProxy::IsLoaded() {
@@ skipping 22 matching lines @@
     // Some fonts are packaged in a single file containing multiple families. In
     // such a case we can find the right family by family name.
     DCHECK(!family_name_.empty());
     UINT32 family_index = 0;
     BOOL found = FALSE;
     hr =
         collection->FindFamilyName(family_name_.c_str(), &family_index, &found);
     if (SUCCEEDED(hr) && found) {
       hr = collection->GetFontFamily(family_index, &family_);
       LogLoadFamilyResult(LOAD_FAMILY_SUCCESS_MATCHED_FAMILY);
+      CHECK(SUCCEEDED(hr));
       return SUCCEEDED(hr);
     }
   }
 
   DCHECK_LE(family_count, 1u);
 
   if (family_count == 0) {
     // This is really strange, we successfully loaded no fonts?!
     LogLoadFamilyResult(LOAD_FAMILY_ERROR_NO_FAMILIES);
+    CHECK(false);
     return false;
   }
 
   LogLoadFamilyResult(family_count == 1 ? LOAD_FAMILY_SUCCESS_SINGLE_FAMILY
                                         : LOAD_FAMILY_ERROR_MULTIPLE_FAMILIES);
 
   hr = collection->GetFontFamily(0, &family_);
 
+  CHECK(SUCCEEDED(hr));
+
   return SUCCEEDED(hr);
 }
 
 FontFileEnumerator::FontFileEnumerator() = default;
 
 FontFileEnumerator::~FontFileEnumerator() = default;
 
 HRESULT FontFileEnumerator::GetCurrentFontFile(IDWriteFontFile** file) {
   DCHECK(file);
-  if (current_file_ >= file_names_.size())
+  if (current_file_ >= file_names_.size()) {
+    CHECK(false);
     return E_FAIL;
+  }
 
   TRACE_EVENT0("dwrite", "FontFileEnumerator::GetCurrentFontFile (memmap)");
   // CreateCustomFontFileReference ends up calling
   // DWriteFontCollectionProxy::CreateStreamFromKey.
-  return factory_->CreateCustomFontFileReference(
+  HRESULT hr = factory_->CreateCustomFontFileReference(
       reinterpret_cast<const void*>(file_names_[current_file_].c_str()),
       (file_names_[current_file_].length() + 1) * sizeof(base::char16),
       loader_.Get() /*IDWriteFontFileLoader*/, file);
+  CHECK(SUCCEEDED(hr));
+  return hr;
 }
 
 HRESULT FontFileEnumerator::MoveNext(BOOL* has_current_file) {
   DCHECK(has_current_file);
 
   TRACE_EVENT0("dwrite", "FontFileEnumerator::MoveNext");
   if (next_file_ >= file_names_.size()) {
     *has_current_file = FALSE;
     current_file_ = UINT_MAX;
     return S_OK;
@@ skipping 27 matching lines @@
 
 HRESULT FontFileStream::GetLastWriteTime(UINT64* last_write_time) {
   *last_write_time = 0;
   return S_OK;
 }
 
 HRESULT FontFileStream::ReadFileFragment(const void** fragment_start,
                                          UINT64 fragment_offset,
                                          UINT64 fragment_size,
                                          void** fragment_context) {
-  if (fragment_offset + fragment_size < fragment_offset)
+  if (fragment_offset + fragment_size < fragment_offset) {
+    CHECK(false);
     return E_FAIL;
-  if (fragment_offset + fragment_size > data_.length())
+  }
+  if (fragment_offset + fragment_size > data_.length()) {
+    CHECK(false);
     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()) {
+    CHECK(false);
     return E_FAIL;
+  }
   return S_OK;
 }
 
 }  // namespace content