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

content/child/threaded_data_provider.cc

 // Copyright 2014 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/threaded_data_provider.h"
 
 #include "content/child/child_process.h"
-#include "content/child/child_thread.h"
+#include "content/child/child_thread_impl.h"
 #include "content/child/resource_dispatcher.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/child/webthread_impl.h"
 #include "content/common/resource_messages.h"
 #include "ipc/ipc_sync_channel.h"
 #include "third_party/WebKit/public/platform/WebThread.h"
 #include "third_party/WebKit/public/platform/WebThreadedDataReceiver.h"
 
 namespace content {
 
@@ skipping 101 matching lines @@
     int request_id,
     blink::WebThreadedDataReceiver* threaded_data_receiver,
     linked_ptr<base::SharedMemory> shm_buffer,
     int shm_size,
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner)
     : request_id_(request_id),
       shm_buffer_(shm_buffer),
       shm_size_(shm_size),
       background_thread_(static_cast<WebThreadImpl&>(
           *threaded_data_receiver->backgroundThread())),
-      ipc_channel_(ChildThread::current()->channel()),
+      ipc_channel_(ChildThreadImpl::current()->channel()),
       threaded_data_receiver_(threaded_data_receiver),
       resource_filter_active_(false),
       main_thread_task_runner_(main_thread_task_runner),
       main_thread_weak_factory_(this) {
-  DCHECK(ChildThread::current());
+  DCHECK(ChildThreadImpl::current());
   DCHECK(ipc_channel_);
   DCHECK(threaded_data_receiver_);
   DCHECK(main_thread_task_runner_.get());
 
   background_thread_weak_factory_.reset(
       new base::WeakPtrFactory<ThreadedDataProvider>(this));
 
   filter_ = new DataProviderMessageFilter(
       ChildProcess::current()->io_message_loop_proxy(),
       main_thread_task_runner_, background_thread_,
       background_thread_weak_factory_->GetWeakPtr(),
       main_thread_weak_factory_.GetWeakPtr(), request_id);
 
-  ChildThread::current()->channel()->AddFilter(filter_.get());
+  ChildThreadImpl::current()->channel()->AddFilter(filter_.get());
 }
 
 ThreadedDataProvider::~ThreadedDataProvider() {
-  DCHECK(ChildThread::current());
+  DCHECK(ChildThreadImpl::current());
 
-  ChildThread::current()->channel()->RemoveFilter(filter_.get());
+  ChildThreadImpl::current()->channel()->RemoveFilter(filter_.get());
 
   delete threaded_data_receiver_;
 }
 
 void DestructOnMainThread(ThreadedDataProvider* data_provider) {
-  DCHECK(ChildThread::current());
+  DCHECK(ChildThreadImpl::current());
 
   // The ThreadedDataProvider must be destructed on the main thread to
   // be threadsafe when removing the message filter and releasing the shared
   // memory buffer.
   delete data_provider;
 }
 
 void ThreadedDataProvider::Stop() {
-  DCHECK(ChildThread::current());
+  DCHECK(ChildThreadImpl::current());
 
   // Make sure we don't get called by on the main thread anymore via weak
   // pointers we've passed to the filter.
   main_thread_weak_factory_.InvalidateWeakPtrs();
 
   blink::WebThread* current_background_thread =
       threaded_data_receiver_->backgroundThread();
 
   // We can't destroy this instance directly; we need to bounce a message over
   // to the background thread and back to make sure nothing else will access it
@@ skipping 19 matching lines @@
   // background thread as it's about to be destroyed on the main thread.
   // Destructing the weak pointer factory means invalidating the weak pointers
   // which means no callbacks from the filter will happen and nothing else will
   // use this instance on the background thread.
   background_thread_weak_factory_.reset(NULL);
   main_thread_task_runner_->PostTask(FROM_HERE,
                                      base::Bind(&DestructOnMainThread, this));
 }
 
 void ThreadedDataProvider::OnResourceMessageFilterAddedMainThread() {
-  DCHECK(ChildThread::current());
+  DCHECK(ChildThreadImpl::current());
   DCHECK(background_thread_weak_factory_);
 
   // We bounce this message from the I/O thread via the main thread and then
   // to our background thread, following the same path as incoming data before
   // our filter gets added, to make sure there's nothing still incoming.
   background_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(
           &ThreadedDataProvider::OnResourceMessageFilterAddedBackgroundThread,
           background_thread_weak_factory_->GetWeakPtr()));
 }
@@ skipping 36 matching lines @@
     // sure we forward (and ACK) everything in the right order.
     QueuedSharedMemoryData queued_data;
     queued_data.data = data_ptr + data_offset;
     queued_data.length = data_length;
     queued_data_.push_back(queued_data);
   }
 }
 
 void ThreadedDataProvider::OnReceivedDataOnForegroundThread(
     const char* data, int data_length, int encoded_data_length) {
-  DCHECK(ChildThread::current());
+  DCHECK(ChildThreadImpl::current());
 
   background_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&ThreadedDataProvider::ForwardAndACKData,
                  base::Unretained(this),
                  data, data_length));
 }
 
 void ThreadedDataProvider::ForwardAndACKData(const char* data,
                                              int data_length) {
   DCHECK(background_thread_.isCurrentThread());
 
   // TODO(oysteine): SiteIsolationPolicy needs to be be checked
   // here before we pass the data to the data provider
   // (or earlier on the I/O thread), otherwise once SiteIsolationPolicy does
   // actual blocking as opposed to just UMA logging this will bypass it.
   threaded_data_receiver_->acceptData(data, data_length);
   ipc_channel_->Send(new ResourceHostMsg_DataReceived_ACK(request_id_));
 }
 
 }  // namespace content