New implementation of font precache on Windows.

chrome/service/service_utility_process_host.cc

 // Copyright (c) 2011 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 "chrome/service/service_utility_process_host.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/scoped_temp_dir.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "ipc/ipc_switches.h"
 #include "printing/page_range.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/gfx/rect.h"
 
 #if defined(OS_WIN)
 #include "base/memory/scoped_ptr.h"
 #include "base/win/scoped_handle.h"
+#include "content/common/child_process_messages.h"
 #include "printing/emf_win.h"
 #endif
 
 ServiceUtilityProcessHost::ServiceUtilityProcessHost(
     Client* client, base::MessageLoopProxy* client_message_loop_proxy)
         : ServiceChildProcessHost(ChildProcessInfo::UTILITY_PROCESS),
           client_(client),
           client_message_loop_proxy_(client_message_loop_proxy),
-          waiting_for_reply_(false) {
+          waiting_for_reply_(false),
+          unique_process_id_(0) {
 }
 
 ServiceUtilityProcessHost::~ServiceUtilityProcessHost() {
 }
 
 bool ServiceUtilityProcessHost::StartRenderPDFPagesToMetafile(
     const FilePath& pdf_path,
     const gfx::Rect& render_area,
     int render_dpi,
     const std::vector<printing::PageRange>& page_ranges) {
@@ skipping 43 matching lines @@
 
 bool ServiceUtilityProcessHost::StartGetPrinterCapsAndDefaults(
     const std::string& printer_name) {
   FilePath exposed_path;
   if (!StartProcess(true, exposed_path))
     return false;
   waiting_for_reply_ = true;
   return Send(new ChromeUtilityMsg_GetPrinterCapsAndDefaults(printer_name));
 }
 
+int ServiceUtilityProcessHost::unique_process_id() {
+  return unique_process_id_;
+}
+
 bool ServiceUtilityProcessHost::StartProcess(bool no_sandbox,
                                              const FilePath& exposed_dir) {
   // Name must be set or metrics_service will crash in any test which
   // launches a UtilityProcessHost.
   set_name(ASCIIToUTF16("utility process"));
 
   if (!CreateChannel())
     return false;
 
   FilePath exe_path = GetUtilityProcessCmd();
   if (exe_path.empty()) {
     NOTREACHED() << "Unable to get utility process binary name.";
     return false;
   }
 
   CommandLine cmd_line(exe_path);
   cmd_line.AppendSwitchASCII(switches::kProcessType, switches::kUtilityProcess);
   cmd_line.AppendSwitchASCII(switches::kProcessChannelID, channel_id());
   cmd_line.AppendSwitch(switches::kLang);
 
-  return Launch(&cmd_line, no_sandbox, exposed_dir);
+  if (Launch(&cmd_line, no_sandbox, exposed_dir)) {
+    unique_process_id_ = ChildProcessInfo::GenerateChildProcessUniqueId();

[jam, 2011/09/19 16:31:17]

we usually set this in the constructor. that way the id stays the same even if
the process crashes. it's also simpler to have the id from the beginning,
instead of having some period of time when we don't have an id

[arthurhsu, 2011/09/19 18:22:51]

Done.

+    return true;
+  }
+
+  return false;
 }
 
 FilePath ServiceUtilityProcessHost::GetUtilityProcessCmd() {
 #if defined(OS_LINUX)
   int flags = CHILD_ALLOW_SELF;
 #else
   int flags = CHILD_NORMAL;
 #endif
   return GetChildPath(flags);
 }
@@ skipping 12 matching lines @@
   }
   // The base class implementation will delete |this|.
   ServiceChildProcessHost::OnChildDied();
 }
 
 bool ServiceUtilityProcessHost::OnMessageReceived(const IPC::Message& message) {
   bool msg_is_ok = false;
   IPC_BEGIN_MESSAGE_MAP_EX(ServiceUtilityProcessHost, message, msg_is_ok)
 #if defined(OS_WIN)  // This hack is Windows-specific.
     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_PreCacheFont, OnPreCacheFont)
+    IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_ReleaseCachedFonts,
+                        OnReleaseCachedFonts)
 #endif
     IPC_MESSAGE_HANDLER(
         ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Succeeded,
         OnRenderPDFPagesToMetafileSucceeded)
     IPC_MESSAGE_UNHANDLED(msg_is_ok__ = MessageForClient(message))
   IPC_END_MESSAGE_MAP_EX()
   return true;
 }
 
 bool ServiceUtilityProcessHost::MessageForClient(const IPC::Message& message) {
   DCHECK(waiting_for_reply_);
   bool ret = client_message_loop_proxy_->PostTask(
       FROM_HERE,
       NewRunnableMethod(client_.get(), &Client::OnMessageReceived,
                         message));
   waiting_for_reply_ = false;
   return ret;
 }
 
 #if defined(OS_WIN)  // This hack is Windows-specific.
 void ServiceUtilityProcessHost::OnPreCacheFont(const LOGFONT& font) {
-  PreCacheFont(font);
+  PreCacheFont(font, unique_process_id());
+}
+
+void ServiceUtilityProcessHost::OnReleaseCachedFonts() {
+  ReleaseCachedFonts(unique_process_id());
 }
 #endif  // OS_WIN
 
 void ServiceUtilityProcessHost::OnRenderPDFPagesToMetafileSucceeded(
     int highest_rendered_page_number) {
   DCHECK(waiting_for_reply_);
   // If the metafile was successfully created, we need to take our hands off the
   // scratch metafile directory. The client will delete it when it is done with
   // metafile.
   scratch_metafile_dir_->Take();
@@ skipping 38 matching lines @@
   printing::Emf metafile;
   if (!metafile.InitFromFile(metafile_path)) {
     OnRenderPDFPagesToMetafileFailed();
   } else {
     OnRenderPDFPagesToMetafileSucceeded(metafile,
                                         highest_rendered_page_number);
   }
 #endif  // defined(OS_WIN)
 }