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

content/child/child_thread_impl.cc

 // Copyright (c) 2012 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/child_thread.h"
+#include "content/child/child_thread_impl.h"
 
 #include <signal.h>
 
 #include <string>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/base_switches.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/debug/leak_annotations.h"
@@ skipping 48 matching lines @@
 #endif
 
 using tracked_objects::ThreadData;
 
 namespace content {
 namespace {
 
 // How long to wait for a connection to the browser process before giving up.
 const int kConnectionTimeoutS = 15;
 
-base::LazyInstance<base::ThreadLocalPointer<ChildThread> > g_lazy_tls =
+base::LazyInstance<base::ThreadLocalPointer<ChildThreadImpl> > g_lazy_tls =
     LAZY_INSTANCE_INITIALIZER;
 
 // This isn't needed on Windows because there the sandbox's job object
 // terminates child processes automatically. For unsandboxed processes (i.e.
 // plugins), PluginThread has EnsureTerminateMessageFilter.
 #if defined(OS_POSIX)
 
 // TODO(earthdok): Re-enable on CrOS http://crbug.com/360622
 #if (defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) || \
      defined(MEMORY_SANITIZER) || defined(THREAD_SANITIZER) || \
@@ skipping 70 matching lines @@
 #endif
   }
 
  protected:
   ~SuicideOnChannelErrorFilter() override {}
 };
 
 #endif  // OS(POSIX)
 
 #if defined(OS_ANDROID)
-ChildThread* g_child_thread = NULL;
+ChildThreadImpl* g_child_thread = NULL;
 
 // A lock protects g_child_thread.
 base::LazyInstance<base::Lock> g_lazy_child_thread_lock =
     LAZY_INSTANCE_INITIALIZER;
 
 // base::ConditionVariable has an explicit constructor that takes
 // a base::Lock pointer as parameter. The base::DefaultLazyInstanceTraits
 // doesn't handle the case. Thus, we need our own class here.
 struct CondVarLazyInstanceTraits {
   static const bool kRegisterOnExit = true;
@@ skipping 16 matching lines @@
     g_lazy_child_thread_cv = LAZY_INSTANCE_INITIALIZER;
 
 void QuitMainThreadMessageLoop() {
   base::MessageLoop::current()->Quit();
 }
 
 #endif
 
 }  // namespace
 
-ChildThread::Options::Options()
+ChildThread* ChildThread::Get() {
+  return ChildThreadImpl::current();
+}
+
+ChildThreadImpl::Options::Options()
     : channel_name(base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kProcessChannelID)),
       use_mojo_channel(false),
       in_browser_process(false) {
 }
 
-ChildThread::Options::Options(bool mojo)
+ChildThreadImpl::Options::Options(bool mojo)
     : channel_name(base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kProcessChannelID)),
       use_mojo_channel(mojo),
       in_browser_process(true) {
 }
 
-ChildThread::Options::Options(std::string name, bool mojo)
+ChildThreadImpl::Options::Options(std::string name, bool mojo)
     : channel_name(name), use_mojo_channel(mojo), in_browser_process(true) {
 }
 
-ChildThread::Options::~Options() {
+ChildThreadImpl::Options::~Options() {
 }
 
-ChildThread::ChildThreadMessageRouter::ChildThreadMessageRouter(
+ChildThreadImpl::ChildThreadMessageRouter::ChildThreadMessageRouter(
     IPC::Sender* sender)
     : sender_(sender) {}
 
-bool ChildThread::ChildThreadMessageRouter::Send(IPC::Message* msg) {
+bool ChildThreadImpl::ChildThreadMessageRouter::Send(IPC::Message* msg) {
   return sender_->Send(msg);
 }
 
-ChildThread::ChildThread()
+ChildThreadImpl::ChildThreadImpl()
     : router_(this),
       in_browser_process_(false),
       channel_connected_factory_(this) {
   Init(Options());
 }
 
-ChildThread::ChildThread(const Options& options)
+ChildThreadImpl::ChildThreadImpl(const Options& options)
     : router_(this),
       in_browser_process_(options.in_browser_process),
       channel_connected_factory_(this) {
   Init(options);
 }
 
-void ChildThread::ConnectChannel(bool use_mojo_channel) {
+void ChildThreadImpl::ConnectChannel(bool use_mojo_channel) {
   bool create_pipe_now = true;
   if (use_mojo_channel) {
     VLOG(1) << "Mojo is enabled on child";
     channel_->Init(IPC::ChannelMojo::CreateClientFactory(channel_name_),
                    create_pipe_now);
     return;
   }
 
   VLOG(1) << "Mojo is disabled on child";
   channel_->Init(channel_name_, IPC::Channel::MODE_CLIENT, create_pipe_now);
 }
 
-void ChildThread::Init(const Options& options) {
+void ChildThreadImpl::Init(const Options& options) {
   channel_name_ = options.channel_name;
 
   g_lazy_tls.Pointer()->Set(this);
   on_channel_error_called_ = false;
   message_loop_ = base::MessageLoop::current();
 #ifdef IPC_MESSAGE_LOG_ENABLED
   // We must make sure to instantiate the IPC Logger *before* we create the
   // channel, otherwise we can get a callback on the IO thread which creates
   // the logger, and the logger does not like being created on the IO thread.
   IPC::Logging::GetInstance();
@@ skipping 87 matching lines @@
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kIPCConnectionTimeout);
   if (!connection_override.empty()) {
     int temp;
     if (base::StringToInt(connection_override, &temp))
       connection_timeout = temp;
   }
 
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&ChildThread::EnsureConnected,
+      base::Bind(&ChildThreadImpl::EnsureConnected,
                  channel_connected_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(connection_timeout));
 
 #if defined(OS_ANDROID)
   {
     base::AutoLock lock(g_lazy_child_thread_lock.Get());
     g_child_thread = this;
   }
   // Signalling without locking is fine here because only
   // one thread can wait on the condition variable.
@@ skipping 11 matching lines @@
   shared_bitmap_manager_.reset(
       new ChildSharedBitmapManager(thread_safe_sender()));
 
   gpu_memory_buffer_manager_.reset(
       new ChildGpuMemoryBufferManager(thread_safe_sender()));
 
   discardable_shared_memory_manager_.reset(
       new ChildDiscardableSharedMemoryManager(thread_safe_sender()));
 }
 
-ChildThread::~ChildThread() {
+ChildThreadImpl::~ChildThreadImpl() {
 #ifdef IPC_MESSAGE_LOG_ENABLED
   IPC::Logging::GetInstance()->SetIPCSender(NULL);
 #endif
 
   channel_->RemoveFilter(histogram_message_filter_.get());
   channel_->RemoveFilter(sync_message_filter_.get());
 
   // The ChannelProxy object caches a pointer to the IPC thread, so need to
   // reset it as it's not guaranteed to outlive this object.
   // NOTE: this also has the side-effect of not closing the main IPC channel to
   // the browser process.  This is needed because this is the signal that the
   // browser uses to know that this process has died, so we need it to be alive
   // until this process is shut down, and the OS closes the handle
   // automatically.  We used to watch the object handle on Windows to do this,
   // but it wasn't possible to do so on POSIX.
   channel_->ClearIPCTaskRunner();
   g_lazy_tls.Pointer()->Set(NULL);
 }
 
-void ChildThread::Shutdown() {
+void ChildThreadImpl::Shutdown() {
   // Delete objects that hold references to blink so derived classes can
   // safely shutdown blink in their Shutdown implementation.
   file_system_dispatcher_.reset();
   quota_dispatcher_.reset();
   WebFileSystemImpl::DeleteThreadSpecificInstance();
 }
 
-void ChildThread::OnChannelConnected(int32 peer_pid) {
+void ChildThreadImpl::OnChannelConnected(int32 peer_pid) {
   channel_connected_factory_.InvalidateWeakPtrs();
 }
 
-void ChildThread::OnChannelError() {
+void ChildThreadImpl::OnChannelError() {
   set_on_channel_error_called(true);
   base::MessageLoop::current()->Quit();
 }
 
-bool ChildThread::Send(IPC::Message* msg) {
+bool ChildThreadImpl::Send(IPC::Message* msg) {
   DCHECK(base::MessageLoop::current() == message_loop());
   if (!channel_) {
     delete msg;
     return false;
   }
 
   return channel_->Send(msg);
 }
 
-MessageRouter* ChildThread::GetRouter() {
+#if defined(OS_WIN)
+void ChildThreadImpl::PreCacheFont(const LOGFONT& log_font) {
+  Send(new ChildProcessHostMsg_PreCacheFont(log_font));
+}
+
+void ChildThreadImpl::ReleaseCachedFonts() {
+  Send(new ChildProcessHostMsg_ReleaseCachedFonts());
+}
+#endif
+
+MessageRouter* ChildThreadImpl::GetRouter() {
   DCHECK(base::MessageLoop::current() == message_loop());
   return &router_;
 }
 
-scoped_ptr<base::SharedMemory> ChildThread::AllocateSharedMemory(
+scoped_ptr<base::SharedMemory> ChildThreadImpl::AllocateSharedMemory(
     size_t buf_size) {
   DCHECK(base::MessageLoop::current() == message_loop());
   return AllocateSharedMemory(buf_size, this);
 }
 
 // static
-scoped_ptr<base::SharedMemory> ChildThread::AllocateSharedMemory(
+scoped_ptr<base::SharedMemory> ChildThreadImpl::AllocateSharedMemory(
     size_t buf_size,
     IPC::Sender* sender) {
   scoped_ptr<base::SharedMemory> shared_buf;
 #if defined(OS_WIN)
   shared_buf.reset(new base::SharedMemory);
   if (!shared_buf->CreateAnonymous(buf_size)) {
     NOTREACHED();
     return NULL;
   }
 #else
   // On POSIX, we need to ask the browser to create the shared memory for us,
   // since this is blocked by the sandbox.
   base::SharedMemoryHandle shared_mem_handle;
   if (sender->Send(new ChildProcessHostMsg_SyncAllocateSharedMemory(
                            buf_size, &shared_mem_handle))) {
     if (base::SharedMemory::IsHandleValid(shared_mem_handle)) {
       shared_buf.reset(new base::SharedMemory(shared_mem_handle, false));
     } else {
       NOTREACHED() << "Browser failed to allocate shared memory";
       return NULL;
     }
   } else {
     NOTREACHED() << "Browser allocation request message failed";
     return NULL;
   }
 #endif
   return shared_buf;
 }
 
-bool ChildThread::OnMessageReceived(const IPC::Message& msg) {
+bool ChildThreadImpl::OnMessageReceived(const IPC::Message& msg) {
   if (mojo_application_->OnMessageReceived(msg))
     return true;
 
   // Resource responses are sent to the resource dispatcher.
   if (resource_dispatcher_->OnMessageReceived(msg))
     return true;
   if (websocket_dispatcher_->OnMessageReceived(msg))
     return true;
   if (file_system_dispatcher_->OnMessageReceived(msg))
     return true;
 
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(ChildThread, msg)
+  IPC_BEGIN_MESSAGE_MAP(ChildThreadImpl, msg)
     IPC_MESSAGE_HANDLER(ChildProcessMsg_Shutdown, OnShutdown)
 #if defined(IPC_MESSAGE_LOG_ENABLED)
     IPC_MESSAGE_HANDLER(ChildProcessMsg_SetIPCLoggingEnabled,
                         OnSetIPCLoggingEnabled)
 #endif
     IPC_MESSAGE_HANDLER(ChildProcessMsg_SetProfilerStatus,
                         OnSetProfilerStatus)
     IPC_MESSAGE_HANDLER(ChildProcessMsg_GetChildProfilerData,
                         OnGetChildProfilerData)
     IPC_MESSAGE_HANDLER(ChildProcessMsg_DumpHandles, OnDumpHandles)
     IPC_MESSAGE_HANDLER(ChildProcessMsg_SetProcessBackgrounded,
                         OnProcessBackgrounded)
 #if defined(USE_TCMALLOC)
     IPC_MESSAGE_HANDLER(ChildProcessMsg_GetTcmallocStats, OnGetTcmallocStats)
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   if (handled)
     return true;
 
   if (msg.routing_id() == MSG_ROUTING_CONTROL)
     return OnControlMessageReceived(msg);
 
   return router_.OnMessageReceived(msg);
 }
 
-bool ChildThread::OnControlMessageReceived(const IPC::Message& msg) {
+bool ChildThreadImpl::OnControlMessageReceived(const IPC::Message& msg) {
   return false;
 }
 
-void ChildThread::OnShutdown() {
+void ChildThreadImpl::OnShutdown() {
   base::MessageLoop::current()->Quit();
 }
 
 #if defined(IPC_MESSAGE_LOG_ENABLED)
-void ChildThread::OnSetIPCLoggingEnabled(bool enable) {
+void ChildThreadImpl::OnSetIPCLoggingEnabled(bool enable) {
   if (enable)
     IPC::Logging::GetInstance()->Enable();
   else
     IPC::Logging::GetInstance()->Disable();
 }
 #endif  //  IPC_MESSAGE_LOG_ENABLED
 
-void ChildThread::OnSetProfilerStatus(ThreadData::Status status) {
+void ChildThreadImpl::OnSetProfilerStatus(ThreadData::Status status) {
   ThreadData::InitializeAndSetTrackingStatus(status);
 }
 
-void ChildThread::OnGetChildProfilerData(int sequence_number) {
+void ChildThreadImpl::OnGetChildProfilerData(int sequence_number) {
   tracked_objects::ProcessDataSnapshot process_data;
   ThreadData::Snapshot(false, &process_data);
 
   Send(new ChildProcessHostMsg_ChildProfilerData(sequence_number,
                                                  process_data));
 }
 
-void ChildThread::OnDumpHandles() {
+void ChildThreadImpl::OnDumpHandles() {
 #if defined(OS_WIN)
   scoped_refptr<HandleEnumerator> handle_enum(
       new HandleEnumerator(
           base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kAuditAllHandles)));
   handle_enum->EnumerateHandles();
   Send(new ChildProcessHostMsg_DumpHandlesDone);
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 #if defined(USE_TCMALLOC)
-void ChildThread::OnGetTcmallocStats() {
+void ChildThreadImpl::OnGetTcmallocStats() {
   std::string result;
   char buffer[1024 * 32];
   base::allocator::GetStats(buffer, sizeof(buffer));
   result.append(buffer);
   Send(new ChildProcessHostMsg_TcmallocStats(result));
 }
 #endif
 
-ChildThread* ChildThread::current() {
+ChildThreadImpl* ChildThreadImpl::current() {
   return g_lazy_tls.Pointer()->Get();
 }
 
 #if defined(OS_ANDROID)
 // The method must NOT be called on the child thread itself.
 // It may block the child thread if so.
-void ChildThread::ShutdownThread() {
-  DCHECK(!ChildThread::current()) <<
+void ChildThreadImpl::ShutdownThread() {
+  DCHECK(!ChildThreadImpl::current()) <<
       "this method should NOT be called from child thread itself";
   {
     base::AutoLock lock(g_lazy_child_thread_lock.Get());
     while (!g_child_thread)
       g_lazy_child_thread_cv.Get().Wait();
   }
   DCHECK_NE(base::MessageLoop::current(), g_child_thread->message_loop());
   g_child_thread->message_loop()->PostTask(
       FROM_HERE, base::Bind(&QuitMainThreadMessageLoop));
 }
 #endif
 
-void ChildThread::OnProcessFinalRelease() {
+void ChildThreadImpl::OnProcessFinalRelease() {
   if (on_channel_error_called_) {
     base::MessageLoop::current()->Quit();
     return;
   }
 
   // The child process shutdown sequence is a request response based mechanism,
   // where we send out an initial feeler request to the child process host
   // instance in the browser to verify if it's ok to shutdown the child process.
   // The browser then sends back a response if it's ok to shutdown. This avoids
   // race conditions if the process refcount is 0 but there's an IPC message
   // inflight that would addref it.
   Send(new ChildProcessHostMsg_ShutdownRequest);
 }
 
-void ChildThread::EnsureConnected() {
-  VLOG(0) << "ChildThread::EnsureConnected()";
+void ChildThreadImpl::EnsureConnected() {
+  VLOG(0) << "ChildThreadImpl::EnsureConnected()";
   base::KillProcess(base::GetCurrentProcessHandle(), 0, false);
 }
 
-void ChildThread::OnProcessBackgrounded(bool background) {
+void ChildThreadImpl::OnProcessBackgrounded(bool background) {
   // Set timer slack to maximum on main thread when in background.
   base::TimerSlack timer_slack = base::TIMER_SLACK_NONE;
   if (background)
     timer_slack = base::TIMER_SLACK_MAXIMUM;
   base::MessageLoop::current()->SetTimerSlack(timer_slack);
 }
 
 }  // namespace content