Fix for the font files being maped multiple times (Fontconfig).

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/debug/trace_event.h"
 #include "base/files/file_util.h"
 #include "base/pickle.h"
 #include "base/posix/unix_domain_socket_linux.h"
 #include "skia/ext/refptr.h"
 #include "skia/ext/skia_utils_base.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkStream.h"
 
 namespace content {
 
+class FontConfigIPC::FontMemoryStream
+    : public SkMemoryStream,
+      public base::SupportsWeakPtr<FontConfigIPC::FontMemoryStream> {

[Daniel Erat, 2014/11/06 20:33:55]

do you actually need SupportsWeakPtr here and the PurgeFontStreamCache() call
below, or could you just make this class's d'tor remove the corresponding stale
entry from the cache? that seems like it'd avoid a lot of unnecessary iterating
through the cache.

[Krzysztof Olczyk, 2014/11/07 11:38:00]

Yes, there was also the problem with the fact that openStream is called from
different threads and the streams are passed between threads. 

I've upload the new CL which just mmaps the font files by itself and create
memory streams out of it.

Could you take a look please?

+ public:
+  explicit FontMemoryStream(SkData* data) : SkMemoryStream(data) {}
+  ~FontMemoryStream() override {}
+};
+
 // Return a stream from the file descriptor, or NULL on failure.
-SkStream* StreamFromFD(int fd) {
+FontConfigIPC::FontMemoryStream* FontConfigIPC::StreamFromFD(int fd) {
   skia::RefPtr<SkData> data = skia::AdoptRef(SkData::NewFromFD(fd));
   if (!data) {
     return NULL;
   }
-  return new SkMemoryStream(data.get());
+  return new FontMemoryStream(data.get());
 }
 
 void CloseFD(int fd) {
   int err = IGNORE_EINTR(close(fd));
   DCHECK(!err);
 }
 
 FontConfigIPC::FontConfigIPC(int fd)
     : fd_(fd) {
 }
@@ skipping 46 matching lines @@
   if (outFamilyName)
     *outFamilyName = reply_family;
   if (outStyle)
     *outStyle = static_cast<SkTypeface::Style>(reply_style);
 
   return true;
 }
 
 SkStream* FontConfigIPC::openStream(const FontIdentity& identity) {
   TRACE_EVENT0("sandbox_ipc", "FontConfigIPC::openStream");
+
+  auto stream_cache_it = font_stream_cache_.find(identity.fID);
+  if (stream_cache_it != font_stream_cache_.end() && stream_cache_it->second)
+    return stream_cache_it->second.get();
+
+  PurgeFontStreamCache();
+
   Pickle request;
   request.WriteInt(METHOD_OPEN);
   request.WriteUInt32(identity.fID);
 
   int result_fd = -1;
   uint8_t reply_buf[256];
   const ssize_t r = UnixDomainSocket::SendRecvMsg(fd_, reply_buf,
                                                   sizeof(reply_buf),
                                                   &result_fd, request);
 
   if (r == -1)
     return NULL;
 
   Pickle reply(reinterpret_cast<char*>(reply_buf), r);
   bool result;
   PickleIterator iter(reply);
   if (!reply.ReadBool(&iter, &result) ||
       !result) {
     if (result_fd)
       CloseFD(result_fd);
     return NULL;
   }
 
-  SkStream* stream = StreamFromFD(result_fd);
+  FontMemoryStream* stream = StreamFromFD(result_fd);
   CloseFD(result_fd);
+  font_stream_cache_[identity.fID] = base::AsWeakPtr(stream);
   return stream;
 }
 
+void FontConfigIPC::PurgeFontStreamCache() {
+  auto stream_cache_it = font_stream_cache_.begin();
+  while (stream_cache_it != font_stream_cache_.end()) {
+    if (!stream_cache_it->second)
+      font_stream_cache_.erase(stream_cache_it++);
+    else
+      ++stream_cache_it;
+  }
+}
+
 }  // namespace content