Fixes possible deadlock in fontservice

components/font_service/public/cpp/font_service_thread.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 "components/font_service/public/cpp/font_service_thread.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/synchronization/waitable_event.h"
 #include "components/font_service/public/cpp/mapped_font_file.h"
 #include "mojo/message_pump/message_pump_mojo.h"
 #include "mojo/platform_handle/platform_handle_functions.h"
 
 namespace font_service {
 namespace internal {
 
 namespace {
 const char kFontThreadName[] = "Font_Proxy_Thread";
 }  // namespace
 
 FontServiceThread::FontServiceThread(FontServicePtr font_service)
     : base::Thread(kFontThreadName),
-      font_service_info_(font_service.PassInterface()) {
+      font_service_info_(font_service.PassInterface()),
+      weak_factory_(this) {
   base::Thread::Options options;
   options.message_pump_factory =
       base::Bind(&mojo::common::MessagePumpMojo::Create);
   StartWithOptions(options);
 }
 
 bool FontServiceThread::MatchFamilyName(
     const char family_name[],
     SkFontStyle requested_style,
     SkFontConfigInterface::FontIdentity* out_font_identity,
@@ skipping 104 matching lines @@
 
 void FontServiceThread::OpenStreamImpl(base::WaitableEvent* done_event,
                                        base::File* output_file,
                                        const uint32_t id_number) {
   DCHECK_EQ(GetThreadId(), base::PlatformThread::CurrentId());
   if (font_service_.encountered_error()) {
     done_event->Signal();
     return;
   }
 
+  pending_waitable_events_.insert(done_event);
   font_service_->OpenStream(
       id_number, base::Bind(&FontServiceThread::OnOpenStreamComplete, this,
                             done_event, output_file));
 }
 
 void FontServiceThread::OnOpenStreamComplete(base::WaitableEvent* done_event,
                                              base::File* output_file,
                                              mojo::ScopedHandle handle) {
+  pending_waitable_events_.erase(done_event);
   if (handle.is_valid()) {
     MojoPlatformHandle platform_handle;
     CHECK(MojoExtractPlatformHandle(handle.release().value(),
                                     &platform_handle) == MOJO_RESULT_OK);
     *output_file = base::File(platform_handle);
   }
 
   done_event->Signal();
 }
 
+void FontServiceThread::OnFontServiceConnectionError() {
+  std::set<base::WaitableEvent*> events;
+  events.swap(pending_waitable_events_);
+  for (base::WaitableEvent* event : events)
+    event->Signal();
+}
+
 void FontServiceThread::Init() {
   font_service_.Bind(std::move(font_service_info_));
+  font_service_.set_connection_error_handler(
+      base::Bind(&FontServiceThread::OnFontServiceConnectionError,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void FontServiceThread::CleanUp() {
   font_service_.reset();
 }
 
 }  // namespace internal
 }  // namespace font_service