Adding more checking and some debugging information in Custom Font Collection.

content/renderer/renderer_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/renderer/renderer_font_platform_win.h"
 
 #include <dwrite.h>
 #include <string>
 #include <vector>
 #include <wrl/implements.h>
 #include <wrl/wrappers/corewrappers.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/memory_mapped_file.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/path_service.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/win/iat_patch_function.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 
 namespace {
 
 namespace mswr = Microsoft::WRL;
 namespace mswrw = Microsoft::WRL::Wrappers;
 
+static const char kFontKeyName[] = "font_key_name";
+
 class FontCollectionLoader
     : public mswr::RuntimeClass<mswr::RuntimeClassFlags<mswr::ClassicCom>,
                                 IDWriteFontCollectionLoader> {
  public:
   // IDWriteFontCollectionLoader methods.
   virtual HRESULT STDMETHODCALLTYPE
       CreateEnumeratorFromKey(IDWriteFactory* factory,
                               void const* key,
                               UINT32 key_size,
                               IDWriteFontFileEnumerator** file_enumerator);
@@ skipping 20 matching lines @@
 class FontFileStream
     : public mswr::RuntimeClass<mswr::RuntimeClassFlags<mswr::ClassicCom>,
                                 IDWriteFontFileStream> {
  public:
   // IDWriteFontFileStream methods.
   virtual HRESULT STDMETHODCALLTYPE
   ReadFileFragment(void const** fragment_start,
                    UINT64 file_offset,
                    UINT64 fragment_size,
                    void** context) {
-    if (!memory_.get() || !memory_->IsValid())
+    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;
     return S_OK;
   }
 
   virtual void STDMETHODCALLTYPE ReleaseFileFragment(void* context) {}
 
@@ skipping 18 matching lines @@
     *last_write_time = 0;
     return S_OK;
   }
 
   FontFileStream::FontFileStream() : font_key_(0) {
   };
 
   HRESULT RuntimeClassInitialize(UINT32 font_key) {
     base::FilePath path;
     PathService::Get(base::DIR_WINDOWS_FONTS, &path);
-    path = path.Append(g_font_loader->GetFontNameFromKey(font_key).c_str());
+    std::wstring 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[256];
     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));
     return S_OK;
   }
 
   virtual ~FontFileStream() {}
 
   UINT32 font_key_;
   scoped_ptr<base::MemoryMappedFile> memory_;
 };
 
 class FontFileLoader
@@ skipping 159 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);
 
   CHECK(SUCCEEDED(hr));
   CHECK(g_font_collection.Get() != NULL);
 
+  base::debug::ClearCrashKey(kFontKeyName);
+
   return g_font_collection.Get();
 }
 
 }  // namespace content