Added few validations in Direct Write 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 <dwrite.h>
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 263 matching lines @@
   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_OPEN_ALWAYS | base::File::FLAG_WRITE |
+        base::File::FLAG_EXCLUSIVE_WRITE));
     if (!static_cache_->IsValid()) {
       static_cache_.reset();
-      // TODO(shrikant): Convert this CHECK to DCHECK post canary.
-      // We have all fallbacks built in, so if we are not able to create
-      // static cache, browser can still run with old way of loading all fonts.
-      CHECK(FALSE);
       return false;
     }
     CacheFileHeader header;
 
     // At offset 0 write cache version
     static_cache_->Write(0,
                          reinterpret_cast<const char*>(&header),
                          sizeof(header));
 
     static_cache_->Flush();
@@ skipping 603 matching lines @@
   if (!ValidateAndLoadCacheMap()) {
     cache_.reset();
     return false;
   }
 
   return true;
 }
 
 void FontCollectionLoader::EnterStaticCacheMode(const WCHAR* file_name) {
   cache_writer_.reset(new FontCacheWriter());
-  cache_writer_->Create(file_name);
-  create_static_cache_ = true;
+  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_;
@@ skipping 23 matching lines @@
               _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 < mem_file_end && idx < entry->entry_count;
+    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);
@@ skipping 214 matching lines @@
   g_shared_font_cache.Set(mapping);
 
   return true;
 }
 
 bool BuildFontCache(const base::FilePath& file) {
   return BuildFontCacheInternal(file.value().c_str());
 }
 
 }  // namespace content