Call Skia's version of SkFontHost_fontconfig

content/browser/renderer_host/render_sandbox_host_linux.cc

Index: content/browser/renderer_host/render_sandbox_host_linux.cc
===================================================================
--- content/browser/renderer_host/render_sandbox_host_linux.cc	(revision 186178)
+++ content/browser/renderer_host/render_sandbox_host_linux.cc	(working copy)
@@ -30,10 +30,10 @@
 #include "content/common/font_config_ipc_linux.h"
 #include "content/common/sandbox_linux.h"
 #include "content/common/webkitplatformsupport_impl.h"
-#include "skia/ext/SkFontHost_fontconfig_direct.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/linux/WebFontInfo.h"
 #include "third_party/npapi/bindings/npapi_extensions.h"
+#include "third_party/skia/include/ports/SkFontConfigInterface.h"
 #include "ui/gfx/font_render_params_linux.h"
 
 using WebKit::WebCString;
@@ -59,8 +59,7 @@
   SandboxIPCProcess(int lifeline_fd, int browser_socket,
                     std::string sandbox_cmd)
       : lifeline_fd_(lifeline_fd),
-        browser_socket_(browser_socket),
-        font_config_(new FontConfigDirect()) {
+        browser_socket_(browser_socket) {
     if (!sandbox_cmd.empty()) {
       sandbox_cmd_.push_back(sandbox_cmd);
       sandbox_cmd_.push_back(base::kFindInodeSwitch);
@@ -119,7 +118,7 @@
     // bytes long (this is the largest message type).
     // 128 bytes padding are necessary so recvmsg() does not return MSG_TRUNC
     // error for a maximum length message.
-    char buf[FontConfigInterface::kMaxFontFamilyLength + 128];
+    char buf[FontConfigIPC::kMaxFontFamilyLength + 128];
 
     const ssize_t len = UnixDomainSocket::RecvMsg(fd, buf, sizeof(buf), &fds);
     if (len == -1) {
@@ -165,62 +164,40 @@
 
   void HandleFontMatchRequest(int fd, const Pickle& pickle, PickleIterator iter,
                               std::vector<int>& fds) {
-    bool filefaceid_valid;
-    uint32_t filefaceid = 0;
-
-    if (!pickle.ReadBool(&iter, &filefaceid_valid))
-      return;
-    if (filefaceid_valid) {
-      if (!pickle.ReadUInt32(&iter, &filefaceid))
-        return;
-    }
-    bool is_bold, is_italic;
-    if (!pickle.ReadBool(&iter, &is_bold) ||
-        !pickle.ReadBool(&iter, &is_italic)) {
-      return;
-    }
-
-    uint32_t characters_bytes;
-    if (!pickle.ReadUInt32(&iter, &characters_bytes))
-      return;
-    const char* characters = NULL;
-    if (characters_bytes > 0) {
-      const uint32_t kMaxCharactersBytes = 1 << 10;
-      if (characters_bytes % 2 != 0 ||  // We expect UTF-16.
-          characters_bytes > kMaxCharactersBytes ||
-          !pickle.ReadBytes(&iter, &characters, characters_bytes))
-        return;
-    }
-
+    uint32_t requested_style;
     std::string family;
-    if (!pickle.ReadString(&iter, &family))
+    if (!pickle.ReadString(&iter, &family) ||
+        !pickle.ReadUInt32(&iter, &requested_style))
       return;
 
-    std::string result_family;
-    unsigned result_filefaceid;
-    const bool r = font_config_->Match(
-        &result_family, &result_filefaceid, filefaceid_valid, filefaceid,
-        family, characters, characters_bytes, &is_bold, &is_italic);
+    SkFontConfigInterface::FontIdentity result_identity;
+    SkString result_family;
+    SkTypeface::Style result_style;
+    SkFontConfigInterface* fc =
+        SkFontConfigInterface::GetSingletonDirectInterface();
+    const bool r = fc->matchFamilyName(
+        family.c_str(), (SkTypeface::Style)requested_style,

[palmer, 2013/03/05 21:38:53]

C-style cast; use C++ style instead.

+        &result_identity, &result_family, &result_style);
 
     Pickle reply;
     if (!r) {
       reply.WriteBool(false);
     } else {
       reply.WriteBool(true);
-      reply.WriteUInt32(result_filefaceid);
-      reply.WriteString(result_family);
-      reply.WriteBool(is_bold);
-      reply.WriteBool(is_italic);
+      reply.WriteString(std::string(result_family.c_str()));
+      reply.WriteString(std::string(result_identity.fString.c_str()));
+      reply.WriteUInt32((uint32_t)result_identity.fIntPtr);
+      reply.WriteUInt32(result_style);
     }
     SendRendererReply(fds, reply, -1);
   }
 
   void HandleFontOpenRequest(int fd, const Pickle& pickle, PickleIterator iter,
                              std::vector<int>& fds) {
-    uint32_t filefaceid;
-    if (!pickle.ReadUInt32(&iter, &filefaceid))
+    std::string path;
+    if (!pickle.ReadString(&iter, &path))

[palmer, 2013/03/05 21:38:53]

Who sends these pickles? Untrustworthy renderers? The browser must not open
arbitrary pathnames on behalf of an untrustworthy requester.

       return;
-    const int result_fd = font_config_->Open(filefaceid);
+    const int result_fd = open(path.c_str(), O_RDONLY);
 
     Pickle reply;
     if (result_fd == -1) {
@@ -230,9 +207,6 @@
     }
 
     SendRendererReply(fds, reply, result_fd);
-
-    if (result_fd >= 0)
-      close(result_fd);
   }
 
   void HandleGetFontFamilyForChars(int fd, const Pickle& pickle,
@@ -659,7 +633,6 @@
 
   const int lifeline_fd_;
   const int browser_socket_;
-  scoped_ptr<FontConfigDirect> font_config_;
   std::vector<std::string> sandbox_cmd_;
   scoped_ptr<WebKitPlatformSupportImpl> webkit_platform_support_;
 };