mmap the opened file descriptor in the renderer process, close the fd in the browser process.

content/common/font_config_ipc_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/common/font_config_ipc_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
+#include <sys/mman.h>
 #include <sys/socket.h>
+#include <sys/stat.h>
 #include <sys/uio.h>
 #include <unistd.h>
 
+#include "base/file_util.h"
 #include "base/pickle.h"
 #include "base/posix/unix_domain_socket_linux.h"
 #include "skia/ext/skia_utils_base.h"
 #include "third_party/skia/include/core/SkStream.h"
 
 namespace content {
 
+// Takes "ownership" of the file descriptor, and will close() it.
+class SkFileDescriptorStream : public SkStream {
+  public:

[jln (very slow on Chromium), 2013/03/18 19:21:28]

Nit: public should be only indented with one space, and the rest indented one
space from it.

[reed1, 2013/03/18 19:26:39]

Done.

+    SkFileDescriptorStream(int fd) : memory_(NULL), offset_(0), length_(0) {
+      struct stat st;
+      if (fstat(fd, &st)) {
+        DCHECK(!HANDLE_EINTR(close(fd)));
+        return;
+      }
+
+      void* memory = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
+      DCHECK(!HANDLE_EINTR(close(fd)));
+      if (memory == MAP_FAILED)
+        return;
+
+      memory_ = reinterpret_cast<uint8_t*>(memory);
+      length_ = st.st_size;
+    }
+
+    virtual ~SkFileDescriptorStream() {
+      if (memory_)
+        munmap(const_cast<uint8_t*>(memory_), length_);
+    }
+
+    virtual bool rewind() OVERRIDE {
+      offset_ = 0;
+      return true;
+    }
+
+    // SkStream implementation.
+    virtual size_t read(void* buffer, size_t size) OVERRIDE {
+      if (!buffer && !size) {
+        // This is request for the length of the stream.
+        return length_;
+      }
+
+      size_t remaining = length_ - offset_;
+      if (size > remaining)
+        size = remaining;
+      if (buffer)
+        memcpy(buffer, memory_ + offset_, size);
+
+      offset_ += size;
+      return size;
+    }
+
+    virtual const void* getMemoryBase() OVERRIDE {
+      return memory_;
+    }
+
+  private:
+    const uint8_t* memory_;
+    size_t offset_, length_;
+};
+
 FontConfigIPC::FontConfigIPC(int fd)
     : fd_(fd) {
 }
 
 FontConfigIPC::~FontConfigIPC() {
   close(fd_);
 }
 
 bool FontConfigIPC::matchFamilyName(const char familyName[],
                                     SkTypeface::Style requestedStyle,
@@ skipping 60 matching lines @@
   Pickle reply(reinterpret_cast<char*>(reply_buf), r);
   bool result;
   PickleIterator iter(reply);
   if (!reply.ReadBool(&iter, &result) ||
       !result) {
     if (result_fd)
       close(result_fd);
     return NULL;
   }
 
-  return new SkFDStream(result_fd, true);
+  return new SkFileDescriptorStream(result_fd);
 }
 
 }  // namespace content