Use ChildThreadImpl::thread_safe_sender in font proxy if available

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 79 matching lines @@
   uint32_t family_index = 0;
   base::string16 name(family_name);
 
   auto iter = family_names_.find(name);
   if (iter != family_names_.end()) {
     *index = iter->second;
     *exists = iter->second != UINT_MAX;
     return S_OK;
   }
 
-  if (!GetSender()->Send(
+  if (!sender_.Run()->Send(
           new DWriteFontProxyMsg_FindFamily(name, &family_index))) {
     LogFontProxyError(FIND_FAMILY_SEND_FAILED);
     return E_FAIL;
   }
 
   if (family_index != UINT32_MAX) {
     if (!CreateFamily(family_index))
       return E_FAIL;
     *exists = TRUE;
     *index = family_index;
@@ skipping 24 matching lines @@
   return S_OK;
 }
 
 UINT32 DWriteFontCollectionProxy::GetFontFamilyCount() {
   if (family_count_ != UINT_MAX)
     return family_count_;
 
   TRACE_EVENT0("dwrite", "FontProxy::GetFontFamilyCount");
 
   uint32_t family_count = 0;
-  if (!GetSender()->Send(
+  if (!sender_.Run()->Send(
           new DWriteFontProxyMsg_GetFamilyCount(&family_count))) {
     LogFontProxyError(GET_FAMILY_COUNT_SEND_FAILED);
     return 0;
   }
 
   LogFamilyCount(family_count);
   family_count_ = family_count;
   return family_count;
 }
 
@@ skipping 32 matching lines @@
   if (*family_index >= GetFontFamilyCount()) {
     LogFontProxyError(FAMILY_INDEX_OUT_OF_RANGE);
     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;
   std::vector<IPC::PlatformFileForTransit> file_handles;
-  if (!GetSender()->Send(new DWriteFontProxyMsg_GetFontFiles(
+  if (!sender_.Run()->Send(new DWriteFontProxyMsg_GetFontFiles(
           *family_index, &file_names, &file_handles))) {
     LogFontProxyError(GET_FONT_FILES_SEND_FAILED);
     return E_FAIL;
   }
 
   std::vector<HANDLE> handles;
   file_handles.reserve(file_names.size() + file_handles.size());
   for (const base::string16& file_name : file_names) {
     // This leaks the handles, since they are used as the reference key to
     // CreateStreamFromKey, and DirectWrite requires the reference keys to
@@ skipping 43 matching lines @@
           mswr::MakeAndInitialize<FontFileStream>(&stream, file_handle))) {
     DCHECK(false);
     return E_FAIL;
   }
   *font_file_stream = stream.Detach();
   return S_OK;
 }
 
 HRESULT DWriteFontCollectionProxy::RuntimeClassInitialize(
     IDWriteFactory* factory,
-    IPC::Sender* sender_override) {
+    const base::Callback<IPC::Sender*(void)>& sender) {
   DCHECK(factory);
 
   factory_ = factory;
-  sender_override_ = sender_override;
+  sender_ = sender;
 
   HRESULT hr = factory->RegisterFontCollectionLoader(this);
   DCHECK(SUCCEEDED(hr));
   hr = factory_->RegisterFontFileLoader(this);
   DCHECK(SUCCEEDED(hr));
   return S_OK;
 }
 
 void DWriteFontCollectionProxy::Unregister() {
   factory_->UnregisterFontCollectionLoader(this);
@@ skipping 30 matching lines @@
   family.CopyTo(font_family);
   return true;
 }
 
 bool DWriteFontCollectionProxy::LoadFamilyNames(
     UINT32 family_index,
     IDWriteLocalizedStrings** localized_strings) {
   TRACE_EVENT0("dwrite", "FontProxy::LoadFamilyNames");
 
   std::vector<std::pair<base::string16, base::string16>> strings;
-  if (!GetSender()->Send(
+  if (!sender_.Run()->Send(
           new DWriteFontProxyMsg_GetFamilyNames(family_index, &strings))) {
     return false;
   }
 
   HRESULT hr = mswr::MakeAndInitialize<DWriteLocalizedStrings>(
       localized_strings, &strings);
 
   return SUCCEEDED(hr);
 }
 
@@ skipping 12 matching lines @@
   mswr::ComPtr<DWriteFontFamilyProxy> family;
   HRESULT hr = mswr::MakeAndInitialize<DWriteFontFamilyProxy>(&family, this,
                                                               family_index);
   DCHECK(SUCCEEDED(hr));
   DCHECK_LT(family_index, families_.size());
 
   families_[family_index] = family;
   return true;
 }
 
-IPC::Sender* DWriteFontCollectionProxy::GetSender() {
-  return sender_override_ ? sender_override_ : ChildThread::Get();

[jam, 2016/07/28 16:34:31]

you can fix this by changing

ChildThread::Get()
to
ChildThreadImpl::current()->thread_safe_sender()

[Ilya Kulshin, 2016/07/28 19:01:13]

thread_safe_sender still needs to be called from the main thread, since it
obtains the sender from tls. At the point where I know this code is running from
the main thread (initialization) the IPC system is not yet fully functional, so
I cannot get the sender at that time. By the time the code gets here, it can no
longer be relied to be on the main thread, so thread_safe_sender will not work.

-}
-
 DWriteFontFamilyProxy::DWriteFontFamilyProxy() = default;
 
 DWriteFontFamilyProxy::~DWriteFontFamilyProxy() = default;
 
 HRESULT DWriteFontFamilyProxy::GetFontCollection(
     IDWriteFontCollection** font_collection) {
   DCHECK(font_collection);
 
   proxy_collection_.CopyTo(font_collection);
   return S_OK;
@@ skipping 248 matching lines @@
 
   data_.Initialize(base::File(duplicate_handle));
   if (!data_.IsValid()) {
     LogFontProxyError(MAPPED_FILE_FAILED);
     return E_FAIL;
   }
   return S_OK;
 }
 
 }  // namespace content