Call Skia's version of SkFontHost_fontconfig

content/browser/renderer_host/render_sandbox_host_linux.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/browser/renderer_host/render_sandbox_host_linux.h"
 
 #include <fcntl.h>
 #include <fontconfig/fontconfig.h>
 #include <stdint.h>
 #include <sys/poll.h>
@@ skipping 12 matching lines @@
 #include "base/pickle.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/unix_domain_socket_linux.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #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/skia/include/ports/SkFontConfigInterface.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 "ui/gfx/font_render_params_linux.h"
 
 using WebKit::WebCString;
 using WebKit::WebFontInfo;
 using WebKit::WebUChar;
 
 namespace content {
 
 // http://code.google.com/p/chromium/wiki/LinuxSandboxIPC
 
 // BEWARE: code in this file run across *processes* (not just threads).
 
 // This code runs in a child process
 class SandboxIPCProcess  {
  public:
   // lifeline_fd: this is the read end of a pipe which the browser process
   //   holds the other end of. If the browser process dies, its descriptors are
   //   closed and we will noticed an EOF on the pipe. That's our signal to exit.
   // browser_socket: the browser's end of the sandbox IPC socketpair. From the
   //   point of view of the renderer, it's talking to the browser but this
   //   object actually services the requests.
   // sandbox_cmd: the path of the sandbox executable
   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);
     }
 
     // FontConfig doesn't provide a standard property to control subpixel
     // positioning, so we pass the current setting through to WebKit.
     WebFontInfo::setSubpixelPositioning(
         gfx::GetDefaultWebkitSubpixelPositioning());
   }
@@ skipping 38 matching lines @@
   // ---------------------------------------------------------------------------
   // Requests from the renderer...
 
   void HandleRequestFromRenderer(int fd) {
     std::vector<int> fds;
 
     // A FontConfigIPC::METHOD_MATCH message could be kMaxFontFamilyLength
     // 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) {
       // TODO: should send an error reply, or the sender might block forever.
       NOTREACHED()
           << "Sandbox host message is larger than kMaxFontFamilyLength";
       return;
     }
     if (fds.empty())
       return;
@@ skipping 25 matching lines @@
 
   error:
     for (std::vector<int>::const_iterator
          i = fds.begin(); i != fds.end(); ++i) {
       close(*i);
     }
   }
 
   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,
+        &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))
       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) {
       reply.WriteBool(false);
     } else {
       reply.WriteBool(true);
     }
 
     SendRendererReply(fds, reply, result_fd);
-
-    if (result_fd >= 0)
-      close(result_fd);
   }
 
   void HandleGetFontFamilyForChars(int fd, const Pickle& pickle,
                                    PickleIterator iter,
                                    std::vector<int>& fds) {
     // The other side of this call is
     // chrome/renderer/renderer_sandbox_support_linux.cc
 
     int num_chars;
     if (!pickle.ReadInt(&iter, &num_chars))
@@ skipping 406 matching lines @@
     }
 
     if (HANDLE_EINTR(sendmsg(fds[0], &msg, MSG_DONTWAIT)) < 0)
       PLOG(ERROR) << "sendmsg";
   }
 
   // ---------------------------------------------------------------------------
 
   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_;
 };
 
 SandboxIPCProcess::~SandboxIPCProcess() {
   if (webkit_platform_support_.get())
     WebKit::shutdown();
 }
 
 void SandboxIPCProcess::EnsureWebKitInitialized() {
@@ skipping 62 matching lines @@
 RenderSandboxHostLinux::~RenderSandboxHostLinux() {
   if (initialized_) {
     if (HANDLE_EINTR(close(renderer_socket_)) < 0)
       PLOG(ERROR) << "close";
     if (HANDLE_EINTR(close(childs_lifeline_fd_)) < 0)
       PLOG(ERROR) << "close";
   }
 }
 
 }  // namespace content