Implement support for loading font files from outside system directory

content/child/dwrite_font_proxy/dwrite_font_proxy_win.h

 // 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.
 
 #ifndef CONTENT_CHILD_DWRITE_FONT_PROXY_DWRITE_FONT_PROXY_WIN_H_
 #define CONTENT_CHILD_DWRITE_FONT_PROXY_DWRITE_FONT_PROXY_WIN_H_
 
 #include <dwrite.h>
 #include <wrl.h>
 
+#include <deque>
 #include <map>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "content/common/content_export.h"
 
 namespace IPC {
@@ skipping 53 matching lines @@
   // Gets the family at the specified index with the expected name. This can be
   // used to avoid an IPC call when both the index and family name are known.
   bool GetFontFamily(UINT32 family_index,
                      const base::string16& family_name,
                      IDWriteFontFamily** font_family);
 
   bool LoadFamilyNames(UINT32 family_index, IDWriteLocalizedStrings** strings);
 
   bool CreateFamily(UINT32 family_index);
 
+  size_t CreateFontFileReference(base::string16 file_path);

[ananta, 2016/07/20 01:34:59]

Newline between functions. Please use different names for these functions.
Additionally const reference for string16. Some comments for these functions
would be useful for reference.

[Ilya Kulshin, 2016/07/21 04:17:37]

Removed this code due to a refactor.

+  size_t CreateFontFileReference(HANDLE file_handle);
+
  private:
+  class FontFileReference {

[ananta, 2016/07/20 01:34:59]

Please add some comments for this class. 

[Ilya Kulshin, 2016/07/21 04:17:38]

Removed this class due to a refactor.

+   public:
+    enum ReferenceType {
+      INVALID,
+      PATH,
+      FILE,
+    };
+
+    explicit FontFileReference(base::string16 file_path);

[ananta, 2016/07/20 01:34:59]

const reference for string16.

[Ilya Kulshin, 2016/07/21 04:17:37]

Done.

+    explicit FontFileReference(HANDLE file_handle);
+
+    ReferenceType Type() const { return reference_type_; }
+    const base::string16* Path() const {

[ananta, 2016/07/20 01:34:59]

newline

[Ilya Kulshin, 2016/07/21 04:17:37]

Done.

+      DCHECK_EQ(Type(), PATH);
+      return &file_path_;
+    }
+    const base::File* File() const {

[ananta, 2016/07/20 01:34:59]

newline

[Ilya Kulshin, 2016/07/21 04:17:38]

Done.

+      DCHECK_EQ(Type(), FILE);
+      return &file_;
+    }
+
+   private:
+    ReferenceType reference_type_;
+    base::string16 file_path_;
+    base::File file_;
+  };
+
   IPC::Sender* GetSender();
 
   Microsoft::WRL::ComPtr<IDWriteFactory> factory_;
   std::vector<Microsoft::WRL::ComPtr<DWriteFontFamilyProxy>> families_;
   std::map<base::string16, UINT32> family_names_;
   UINT32 family_count_ = UINT_MAX;
   IPC::Sender* sender_override_;
 
+  std::deque<FontFileReference> font_files_;
+
   DISALLOW_ASSIGN(DWriteFontCollectionProxy);
 };
 
 // Implements the DirectWrite font family interface. This class is just a
 // stub, until something calls a method that requires actual font data. At that
 // point this will load the font files into a custom collection and
 // subsequently calls will be proxied to the resulting DirectWrite object.
 class CONTENT_EXPORT DWriteFontFamilyProxy
     : public Microsoft::WRL::RuntimeClass<
           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
@@ skipping 54 matching lines @@
   FontFileEnumerator();
   ~FontFileEnumerator() override;
 
   // IDWriteFontFileEnumerator:
   HRESULT STDMETHODCALLTYPE GetCurrentFontFile(IDWriteFontFile** file) override;
   HRESULT STDMETHODCALLTYPE MoveNext(BOOL* has_current_file) override;
 
   HRESULT STDMETHODCALLTYPE
   RuntimeClassInitialize(IDWriteFactory* factory,
                          IDWriteFontFileLoader* loader,
-                         std::vector<base::string16>* file_names);
+                         std::vector<size_t>* file_references);
 
  private:
   Microsoft::WRL::ComPtr<IDWriteFactory> factory_;
   Microsoft::WRL::ComPtr<IDWriteFontFileLoader> loader_;
-  std::vector<base::string16> file_names_;
-  std::vector<Microsoft::WRL::ComPtr<IDWriteFontFileStream>> file_streams_;
+  std::vector<size_t> file_references_;

[nasko, 2016/07/20 16:40:03]

Since this is Windows specific code, why not use HANDLE?

[Ilya Kulshin, 2016/07/21 04:17:38]

Done.

   UINT32 next_file_ = 0;
   UINT32 current_file_ = UINT_MAX;
 
   DISALLOW_ASSIGN(FontFileEnumerator);
 };
 
 // Implements the DirectWrite font file stream interface that maps the file to
 // be loaded as a memory mapped file, and subsequently returns pointers into
 // the mapped memory block.
 class CONTENT_EXPORT FontFileStream
     : public Microsoft::WRL::RuntimeClass<
           Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
           IDWriteFontFileStream> {
  public:
   FontFileStream();
   ~FontFileStream() override;
 
   // IDWriteFontFileStream:
   HRESULT STDMETHODCALLTYPE GetFileSize(UINT64* file_size) override;
   HRESULT STDMETHODCALLTYPE GetLastWriteTime(UINT64* last_write_time) override;
   HRESULT STDMETHODCALLTYPE ReadFileFragment(const void** fragment_start,
                                              UINT64 file_offset,
                                              UINT64 fragment_size,
                                              void** fragment_context) override;
   void STDMETHODCALLTYPE ReleaseFileFragment(void* fragment_context) override {}
 
   HRESULT STDMETHODCALLTYPE
-  RuntimeClassInitialize(const base::string16& file_name);
+  RuntimeClassInitialize(const base::string16* file_name);
+  HRESULT STDMETHODCALLTYPE RuntimeClassInitialize(const base::File* file);
 
  private:
   base::MemoryMappedFile data_;
 
   DISALLOW_ASSIGN(FontFileStream);
 };
 
 }  // namespace content
 #endif  // CONTENT_CHILD_DWRITE_FONT_PROXY_DWRITE_FONT_PROXY_WIN_H_