Unify the three places that patch font loading for PDFium on Windows.

content/child/fileapi/webfilewriter_impl.cc

 // Copyright 2013 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/fileapi/webfilewriter_impl.h"
 
 #include "base/bind.h"
 #include "base/synchronization/waitable_event.h"
-#include "content/child/child_thread.h"
+#include "content/child/child_thread_impl.h"
 #include "content/child/fileapi/file_system_dispatcher.h"
 #include "content/child/worker_task_runner.h"
 
 namespace content {
 
 namespace {
 
 FileSystemDispatcher* GetFileSystemDispatcher() {
-  return ChildThread::current() ?
-      ChildThread::current()->file_system_dispatcher() : NULL;
+  return ChildThreadImpl::current() ?
+      ChildThreadImpl::current()->file_system_dispatcher() : NULL;
 }
 
 }  // namespace
 
 typedef FileSystemDispatcher::StatusCallback StatusCallback;
 typedef FileSystemDispatcher::WriteCallback WriteCallback;
 
 // This instance may be created outside main thread but runs mainly
 // on main thread.
 class WebFileWriterImpl::WriterBridge
     : public base::RefCountedThreadSafe<WriterBridge> {
  public:
   WriterBridge(WebFileWriterImpl::Type type)
       : request_id_(0),
         thread_id_(WorkerTaskRunner::Instance()->CurrentWorkerId()),
         written_bytes_(0) {
     if (type == WebFileWriterImpl::TYPE_SYNC)
       waitable_event_.reset(new base::WaitableEvent(false, false));
   }
 
   void Truncate(const GURL& path, int64 offset,
                 const StatusCallback& status_callback) {
     status_callback_ = status_callback;
     if (!GetFileSystemDispatcher())
       return;
-    ChildThread::current()->file_system_dispatcher()->Truncate(
+    ChildThreadImpl::current()->file_system_dispatcher()->Truncate(
         path, offset, &request_id_,
         base::Bind(&WriterBridge::DidFinish, this));
   }
 
   void Write(const GURL& path, const std::string& id, int64 offset,
              const WriteCallback& write_callback,
              const StatusCallback& error_callback) {
     write_callback_ = write_callback;
     status_callback_ = error_callback;
     if (!GetFileSystemDispatcher())
       return;
-    ChildThread::current()->file_system_dispatcher()->Write(
+    ChildThreadImpl::current()->file_system_dispatcher()->Write(
         path, id, offset, &request_id_,
         base::Bind(&WriterBridge::DidWrite, this),
         base::Bind(&WriterBridge::DidFinish, this));
   }
 
   void Cancel(const StatusCallback& status_callback) {
     status_callback_ = status_callback;
     if (!GetFileSystemDispatcher())
       return;
-    ChildThread::current()->file_system_dispatcher()->Cancel(
+    ChildThreadImpl::current()->file_system_dispatcher()->Cancel(
         request_id_,
         base::Bind(&WriterBridge::DidFinish, this));
   }
 
   base::WaitableEvent* waitable_event() {
     return waitable_event_.get();
   }
 
   void WaitAndRun() {
     waitable_event_->Wait();
@@ skipping 76 matching lines @@
     DCHECK(!bridge_->waitable_event());
     closure.Run();
     return;
   }
   main_thread_task_runner_->PostTask(FROM_HERE, closure);
   if (bridge_->waitable_event())
     bridge_->WaitAndRun();
 }
 
 }  // namespace content