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

content/child/webblobregistry_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/webblobregistry_impl.h"
 
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
-#include "content/child/child_thread.h"
+#include "content/child/child_thread_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/fileapi/webblob_messages.h"
 #include "storage/common/data_element.h"
 #include "third_party/WebKit/public/platform/WebBlobData.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebThreadSafeData.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 
 using blink::WebBlobData;
 using blink::WebString;
@@ skipping 128 matching lines @@
 }
 
 void WebBlobRegistryImpl::SendOversizedDataForBlob(
     const std::string& uuid_str,
     const blink::WebThreadSafeData& data) {
   DCHECK_GE(data.size(), kLargeThresholdBytes);
   // We handle larger amounts of data via SharedMemory instead of
   // writing it directly to the IPC channel.
   size_t shared_memory_size = std::min(data.size(), kMaxSharedMemoryBytes);
   scoped_ptr<base::SharedMemory> shared_memory(
-      ChildThread::AllocateSharedMemory(shared_memory_size, sender_.get()));
+      ChildThreadImpl::AllocateSharedMemory(shared_memory_size, sender_.get()));
   CHECK(shared_memory.get());
   if (!shared_memory->Map(shared_memory_size))
     CHECK(false);
 
   size_t data_size = data.size();
   const char* data_ptr = data.data();
   while (data_size) {
     size_t chunk_size = std::min(data_size, shared_memory_size);
     memcpy(shared_memory->memory(), data_ptr, chunk_size);
     sender_->Send(new BlobHostMsg_SyncAppendSharedMemory(
         uuid_str, shared_memory->handle(), chunk_size));
     data_size -= chunk_size;
     data_ptr += chunk_size;
   }
 }
 
 // ------ streams stuff -----
 
 void WebBlobRegistryImpl::registerStreamURL(
     const WebURL& url, const WebString& content_type) {
-  DCHECK(ChildThread::current());
+  DCHECK(ChildThreadImpl::current());
   sender_->Send(new StreamHostMsg_StartBuilding(url, content_type.utf8()));
 }
 
 void WebBlobRegistryImpl::registerStreamURL(
     const WebURL& url, const WebURL& src_url) {
-  DCHECK(ChildThread::current());
+  DCHECK(ChildThreadImpl::current());
   sender_->Send(new StreamHostMsg_Clone(url, src_url));
 }
 
 void WebBlobRegistryImpl::addDataToStream(const WebURL& url,
                                           const char* data, size_t length) {
-  DCHECK(ChildThread::current());
+  DCHECK(ChildThreadImpl::current());
   if (length == 0)
     return;
   if (length < kLargeThresholdBytes) {
     storage::DataElement item;
     item.SetToBytes(data, length);
     sender_->Send(new StreamHostMsg_AppendBlobDataItem(url, item));
   } else {
     // We handle larger amounts of data via SharedMemory instead of
     // writing it directly to the IPC channel.
     size_t shared_memory_size = std::min(
         length, kMaxSharedMemoryBytes);
     scoped_ptr<base::SharedMemory> shared_memory(
-        ChildThread::AllocateSharedMemory(shared_memory_size,
-                                          sender_.get()));
+        ChildThreadImpl::AllocateSharedMemory(shared_memory_size,
+                                              sender_.get()));
     CHECK(shared_memory.get());
     if (!shared_memory->Map(shared_memory_size))
       CHECK(false);
 
     size_t remaining_bytes = length;
     const char* current_ptr = data;
     while (remaining_bytes) {
       size_t chunk_size = std::min(remaining_bytes, shared_memory_size);
       memcpy(shared_memory->memory(), current_ptr, chunk_size);
       sender_->Send(new StreamHostMsg_SyncAppendSharedMemory(
           url, shared_memory->handle(), chunk_size));
       remaining_bytes -= chunk_size;
       current_ptr += chunk_size;
     }
   }
 }
 
 void WebBlobRegistryImpl::flushStream(const WebURL& url) {
-  DCHECK(ChildThread::current());
+  DCHECK(ChildThreadImpl::current());
   sender_->Send(new StreamHostMsg_Flush(url));
 }
 
 void WebBlobRegistryImpl::finalizeStream(const WebURL& url) {
-  DCHECK(ChildThread::current());
+  DCHECK(ChildThreadImpl::current());
   sender_->Send(new StreamHostMsg_FinishBuilding(url));
 }
 
 void WebBlobRegistryImpl::abortStream(const WebURL& url) {
-  DCHECK(ChildThread::current());
+  DCHECK(ChildThreadImpl::current());
   sender_->Send(new StreamHostMsg_AbortBuilding(url));
 }
 
 void WebBlobRegistryImpl::unregisterStreamURL(const WebURL& url) {
-  DCHECK(ChildThread::current());
+  DCHECK(ChildThreadImpl::current());
   sender_->Send(new StreamHostMsg_Remove(url));
 }
 
 }  // namespace content