// Copyright 2015 The Chromium Authors
// 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 <map>
#include <string>
#include <vector>

#include "base/files/memory_mapped_file.h"
#include "base/functional/callback.h"
#include "base/sequence_checker.h"
#include "base/synchronization/lock.h"
#include "base/task/sequenced_task_runner.h"
#include "base/task/single_thread_task_runner.h"
#include "base/thread_annotations.h"
#include "base/threading/sequence_local_storage_slot.h"
#include "content/common/content_export.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "third_party/blink/public/mojom/dwrite_font_proxy/dwrite_font_proxy.mojom.h"
#include "third_party/blink/public/platform/web_font_rendering_client.h"

namespace content {

class DWriteFontFamilyProxy;

// Implements a DirectWrite font collection that uses IPC to the browser to do
// font enumeration. If a matching family is found, it will be loaded locally
// into a custom font collection.
// This is needed because the sandbox interferes with DirectWrite's
// communication with the system font service.
// This class can be accessed from any thread, uses locks and thread annotations
// to coordinate concurrent accesses.
class DWriteFontCollectionProxy
    : public Microsoft::WRL::RuntimeClass<
          Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
          IDWriteFontCollection,
          IDWriteFontCollectionLoader,
          IDWriteFontFileLoader>,
      public blink::WebFontRenderingClient {
 public:
  // Factory method to avoid exporting the class and all it derives from.
  //
  // |proxy| is an optional DWriteFontProxy to use when the constructed
  // DWriteFontCollectionProxy is used on the current sequence. DWriteFontProxy
  // remotes will be bound via ChildThread when the constructed
  // DWriteFontCollectionProxy is used from a sequence for which no
  // DWriteFontProxy has been provided.
  static CONTENT_EXPORT HRESULT
  Create(DWriteFontCollectionProxy** proxy_out,
         IDWriteFactory* dwrite_factory,
         mojo::PendingRemote<blink::mojom::DWriteFontProxy> proxy);

  // Use Create() to construct these objects. Direct calls to the constructor
  // are an error - it is only public because a WRL helper function creates the
  // objects.
  DWriteFontCollectionProxy();

  DWriteFontCollectionProxy& operator=(const DWriteFontCollectionProxy&) =
      delete;

  ~DWriteFontCollectionProxy() override;

  // IDWriteFontCollection:
  HRESULT STDMETHODCALLTYPE FindFamilyName(const WCHAR* family_name,
                                           UINT32* index,
                                           BOOL* exists) override;
  HRESULT STDMETHODCALLTYPE
  GetFontFamily(UINT32 index, IDWriteFontFamily** font_family) override
      LOCKS_EXCLUDED(families_lock_);
  UINT32 STDMETHODCALLTYPE GetFontFamilyCount() override
      LOCKS_EXCLUDED(families_lock_);
  HRESULT STDMETHODCALLTYPE GetFontFromFontFace(IDWriteFontFace* font_face,
                                                IDWriteFont** font) override
      LOCKS_EXCLUDED(families_lock_);

  // IDWriteFontCollectionLoader:
  HRESULT STDMETHODCALLTYPE CreateEnumeratorFromKey(
      IDWriteFactory* factory,
      const void* collection_key,
      UINT32 collection_key_size,
      IDWriteFontFileEnumerator** font_file_enumerator) override;

  // IDWriteFontFileLoader:
  HRESULT STDMETHODCALLTYPE
  CreateStreamFromKey(const void* font_file_reference_key,
                      UINT32 font_file_reference_key_size,
                      IDWriteFontFileStream** font_file_stream) override;

  CONTENT_EXPORT HRESULT STDMETHODCALLTYPE RuntimeClassInitialize(
      IDWriteFactory* factory,
      mojo::PendingRemote<blink::mojom::DWriteFontProxy> proxy);

  CONTENT_EXPORT void Unregister();

  bool LoadFamily(UINT32 family_index,
                  IDWriteFontCollection** containing_collection);

  // 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 std::u16string& family_name,
                     IDWriteFontFamily** font_family)
      LOCKS_EXCLUDED(families_lock_);

  bool LoadFamilyNames(UINT32 family_index, IDWriteLocalizedStrings** strings);

  // `blink::WebFontRenderingClient` overrides
  void BindFontProxyUsingBroker(
      blink::ThreadSafeBrowserInterfaceBrokerProxy* interface_broker) override;

  void PrewarmFamily(const blink::WebString& family_name) override;

  blink::mojom::DWriteFontProxy& GetFontProxy();

  CONTENT_EXPORT void InitializePrewarmerForTesting(
      mojo::PendingRemote<blink::mojom::DWriteFontProxy> proxy);

 private:
  void InitializePrewarmer();
  void BindFontProxy(mojo::PendingRemote<blink::mojom::DWriteFontProxy> remote);
  UINT32 GetFontFamilyCountLockRequired()
      EXCLUSIVE_LOCKS_REQUIRED(families_lock_);
  DWriteFontFamilyProxy* GetFamily(UINT32 family_index)
      LOCKS_EXCLUDED(families_lock_);
  DWriteFontFamilyProxy* GetFamilyLockRequired(UINT32 family_index)
      EXCLUSIVE_LOCKS_REQUIRED(families_lock_);
  DWriteFontFamilyProxy* GetOrCreateFamilyLockRequired(UINT32 family_index)
      EXCLUSIVE_LOCKS_REQUIRED(families_lock_);
  std::optional<UINT32> FindFamilyIndex(const std::u16string& family_name,
                                        HRESULT* hresult_out = nullptr)
      LOCKS_EXCLUDED(families_lock_);

  HRESULT FindFamilyName(const std::u16string& family_name,
                         UINT32* index,
                         BOOL* exists);
  DWriteFontFamilyProxy* FindFamily(const std::u16string& family_name);

  void PrewarmFamilyOnWorker(const std::u16string family_name);

  // Special values for |family_names_|.
  enum FamilyIndex : UINT32 { kFamilyNotFound = UINT32_MAX };
  static bool IsValidFamilyIndex(UINT32 index) {
    return index != kFamilyNotFound;
  }

  base::Lock families_lock_;

  // This is initialized in ctor (RuntimeClassInitialize) and will not change.
  Microsoft::WRL::ComPtr<IDWriteFactory> factory_;

  std::vector<Microsoft::WRL::ComPtr<DWriteFontFamilyProxy>> families_
      GUARDED_BY(families_lock_);
  std::map<std::u16string, UINT32> family_names_ GUARDED_BY(families_lock_);
  UINT32 family_count_ GUARDED_BY(families_lock_) = UINT_MAX;

  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
  scoped_refptr<base::SequencedTaskRunner> prewarm_task_runner_;
  // Per-sequence mojo::Remote<DWriteFontProxy>. This is preferred to a
  // mojo::SharedRemote, which would force a thread hop for each call that
  // doesn't originate from the "bound" sequence.
  base::SequenceLocalStorageSlot<mojo::Remote<blink::mojom::DWriteFontProxy>>
      font_proxy_;

  SEQUENCE_CHECKER(sequence_checker_);
};

// 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 DWriteFontFamilyProxy
    : public Microsoft::WRL::RuntimeClass<
          Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
          IDWriteFontFamily> {
 public:
  DWriteFontFamilyProxy();

  DWriteFontFamilyProxy& operator=(const DWriteFontFamilyProxy&) = delete;

  ~DWriteFontFamilyProxy() override;

  // IDWriteFontFamily:
  HRESULT STDMETHODCALLTYPE
  GetFontCollection(IDWriteFontCollection** font_collection) override;
  UINT32 STDMETHODCALLTYPE GetFontCount() override;
  HRESULT STDMETHODCALLTYPE GetFont(UINT32 index, IDWriteFont** font) override;
  HRESULT STDMETHODCALLTYPE GetFamilyNames(
      IDWriteLocalizedStrings** names) override LOCKS_EXCLUDED(family_lock_);
  HRESULT STDMETHODCALLTYPE
  GetFirstMatchingFont(DWRITE_FONT_WEIGHT weight,
                       DWRITE_FONT_STRETCH stretch,
                       DWRITE_FONT_STYLE style,
                       IDWriteFont** matching_font) override;
  HRESULT STDMETHODCALLTYPE
  GetMatchingFonts(DWRITE_FONT_WEIGHT weight,
                   DWRITE_FONT_STRETCH stretch,
                   DWRITE_FONT_STYLE style,
                   IDWriteFontList** matching_fonts) override;

  HRESULT STDMETHODCALLTYPE
  RuntimeClassInitialize(DWriteFontCollectionProxy* collection, UINT32 index);

  bool GetFontFromFontFace(IDWriteFontFace* font_face, IDWriteFont** font)
      LOCKS_EXCLUDED(family_lock_);

  const std::u16string& GetName() LOCKS_EXCLUDED(family_lock_);
  void SetName(const std::u16string& family_name) LOCKS_EXCLUDED(family_lock_);
  void SetNameIfNotLoaded(const std::u16string& family_name)
      LOCKS_EXCLUDED(family_lock_);

  void PrewarmFamilyOnWorker() LOCKS_EXCLUDED(family_lock_);

 private:
  IDWriteFontFamily* LoadFamily() LOCKS_EXCLUDED(family_lock_);
  IDWriteFontFamily* LoadFamilyCoreLockRequired()
      EXCLUSIVE_LOCKS_REQUIRED(family_lock_);

  base::Lock family_lock_;

  // These are initialized in ctor (RuntimeClassInitialize) and will not change.
  UINT32 family_index_;
  Microsoft::WRL::ComPtr<DWriteFontCollectionProxy> proxy_collection_;

  Microsoft::WRL::ComPtr<IDWriteFontFamily> family_ GUARDED_BY(family_lock_);
  std::u16string family_name_ GUARDED_BY(family_lock_);
  Microsoft::WRL::ComPtr<IDWriteLocalizedStrings> family_names_
      GUARDED_BY(family_lock_);

  SEQUENCE_CHECKER(sequence_checker_);
};

// Implements the DirectWrite font file enumerator interface, backed by a list
// of font files.
class FontFileEnumerator
    : public Microsoft::WRL::RuntimeClass<
          Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
          IDWriteFontFileEnumerator> {
 public:
  FontFileEnumerator();

  FontFileEnumerator& operator=(const FontFileEnumerator&) = delete;

  ~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<HANDLE>* files);

 private:
  Microsoft::WRL::ComPtr<IDWriteFactory> factory_;
  Microsoft::WRL::ComPtr<IDWriteFontFileLoader> loader_;
  std::vector<HANDLE> files_;
  UINT32 next_file_ = 0;
  UINT32 current_file_ = UINT_MAX;
};

// 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 FontFileStream
    : public Microsoft::WRL::RuntimeClass<
          Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>,
          IDWriteFontFileStream> {
 public:
  FontFileStream();

  FontFileStream& operator=(const FontFileStream&) = delete;

  ~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(HANDLE handle);

 private:
  base::MemoryMappedFile data_;
};

}  // namespace content
#endif  // CONTENT_CHILD_DWRITE_FONT_PROXY_DWRITE_FONT_PROXY_WIN_H_