Implement API for accessing fonts installed locally on the system.

content/browser/font_access/font_access_service_impl.cc

+// Copyright 2016 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/font_access/font_access_service_impl.h"

[nasko, 2016/02/12 22:05:18]

Empty line between the comment and the first include.

[Daniel Nishi, 2016/02/12 22:49:39]

Done.

+
+#include "base/files/file.h"
+#include "base/files/file_util.h"
+#include "base/sequenced_task_runner.h"
+#include "content/browser/font_access/font_getter.h"
+#include "content/public/browser/browser_thread.h"
+#include "mojo/public/cpp/system/buffer.h"
+#include "net/base/mime_util.h"
+
+namespace content {
+FontAccessServiceImpl::FontAccessServiceImpl(

[nasko, 2016/02/12 22:05:17]

Empty line after namespace and before the constructor.

[Daniel Nishi, 2016/02/12 22:49:39]

Done.

+    base::Callback<scoped_ptr<FontCacheMap>(void)> getter,
+    mojo::InterfaceRequest<FontAccessService> request)
+    : binding_(this, std::move(request)),
+      cache_map_getter_(getter),
+      weak_factory_(this) {}
+
+FontAccessServiceImpl::~FontAccessServiceImpl() {}
+
+void FontAccessServiceImpl::GetFontList(const GetFontListCallback& callback) {
+  ClobberCacheAndReply(base::Bind(&FontAccessServiceImpl::GetFontListFromCache,

[nasko, 2016/02/12 22:05:18]

What's the point of having a cache if every call to GetFontList will clobber it?

[Daniel Nishi, 2016/02/12 22:49:39]

The list itself may grow stale, but the cache allows us to quickly look up font
paths after the first call.

This saves 2-3 seconds per GetFontData call on certain OSes.

+                                  weak_factory_.GetWeakPtr(), callback));
+}
+
+void FontAccessServiceImpl::GetFontData(const mojo::String& family,
+                                        const mojo::String& style,
+                                        const GetFontDataCallback& callback) {
+  std::string path = FindPathInCache(family.get(), style.get());
+  // If service doesn't exist, or if the cache missed.
+  if (path.empty()) {
+    ClobberCacheAndReply(base::Bind(&FontAccessServiceImpl::GetFontDataInternal,
+                                    weak_factory_.GetWeakPtr(), family.get(),
+                                    style.get(), callback));
+    return;
+  }
+
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&FontAccessServiceImpl::GetFileInfo, path),
+      base::Bind(&FontAccessServiceImpl::GetFileDataCallback,
+                 weak_factory_.GetWeakPtr(), callback, path));
+}
+
+void FontAccessServiceImpl::Create(
+    mojo::InterfaceRequest<FontAccessService> request) {
+  new FontAccessServiceImpl(base::Bind(&content::GetFontCacheMap),
+                            std::move(request));
+}
+
+FontAccessServiceImpl::BlobInfo::BlobInfo() : size(0) {}
+FontAccessServiceImpl::BlobInfo::~BlobInfo() {}

[nasko, 2016/02/12 22:05:17]

Empty line between the two methods.

[Daniel Nishi, 2016/02/12 22:49:39]

Done.

+
+void FontAccessServiceImpl::GetFontListFromCache(
+    const GetFontListCallback& callback) {
+  FontCacheMap::iterator iter;
+  mojo::Array<FontDescriptionPtr> font_infos(0);
+  for (auto& entry : *font_cache_map_) {

[nasko, 2016/02/12 22:05:18]

font_cache_map_.get()

[Daniel Nishi, 2016/02/12 22:49:39]

The operator* does a .get() and dereferences it. I need the object to do the
range based loop.

+    for (auto& face_entry : entry.second) {
+      FontDescriptionPtr font_ptr =
+          FontDescription::New();
+      font_ptr->family = entry.first;
+      font_ptr->style = face_entry.first;
+      font_ptr->fullName = face_entry.second.full_name;
+      font_infos.push_back(std::move(font_ptr));
+    }
+  }
+  callback.Run(std::move(font_infos));
+}
+
+void FontAccessServiceImpl::GetFontDataInternal(
+    const std::string& family,
+    const std::string& style,
+    const GetFontDataCallback& callback) {
+  std::string path = FindPathInCache(family, style);
+  if (path == "") {
+    callback.Run(mojo::ScopedHandleBase<mojo::SharedBufferHandle>(), 0);
+    return;
+  }
+
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&FontAccessServiceImpl::GetFileInfo, path),
+      base::Bind(&FontAccessServiceImpl::GetFileDataCallback,
+                 weak_factory_.GetWeakPtr(), callback, path));
+}
+
+std::string FontAccessServiceImpl::FindPathInCache(

[nasko, 2016/02/12 22:05:17]

Why is a method looking for a path returning a std::string? We should be using
FilePath if it is truly a filesystem path and only converting it to string if
needed.

[Daniel Nishi, 2016/02/12 22:49:39]

base::FilePath is now used.

+    const std::string& family,
+    const std::string& style) {
+  if (!font_cache_map_.get())
+    return std::string();
+
+  FontCacheMap::iterator iter;
+  iter = font_cache_map_->find(family);
+  if (iter != font_cache_map_->end()) {
+    FontStyleMap::iterator faceIter;
+    faceIter = iter->second.find(style);
+    if (faceIter != iter->second.end()) {
+      return faceIter->second.path;
+    }
+  }
+  return std::string();
+}
+
+void FontAccessServiceImpl::ClobberCacheAndReply(const base::Closure closure) {
+  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
+  scoped_refptr<base::SequencedTaskRunner> tr = pool->GetSequencedTaskRunner(
+      pool->GetNamedSequenceToken(std::string(kFontAccessToken)));
+  base::PostTaskAndReplyWithResult(
+      tr.get(), FROM_HERE, cache_map_getter_,
+      base::Bind(&FontAccessServiceImpl::SwapCacheAndReply,
+                 weak_factory_.GetWeakPtr(), closure));
+}
+
+void FontAccessServiceImpl::SwapCacheAndReply(const base::Closure closure,
+                                              scoped_ptr<FontCacheMap> cache) {
+  font_cache_map_.swap(cache);
+  closure.Run();
+}
+
+// static
+FontAccessServiceImpl::BlobInfo FontAccessServiceImpl::GetFileInfo(
+    const std::string& path) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
+  base::FilePath filepath(base::FilePath::FromUTF8Unsafe(path));
+  base::File::Info info;
+  BlobInfo realInfo;

[nasko, 2016/02/12 22:05:17]

real_info

[Daniel Nishi, 2016/02/12 22:49:39]

Done.

+  realInfo.is_valid = base::GetFileInfo(filepath, &info);
+  if (!realInfo.is_valid) {
+      return realInfo;

[nasko, 2016/02/12 22:05:18]

style: Indent only two spaces. One line if statements don't need {}.

[Daniel Nishi, 2016/02/12 22:49:39]

Done.

+  }
+
+  realInfo.size = info.size;
+  realInfo.last_modified = info.last_modified;
+  net::GetMimeTypeFromFile(filepath, &realInfo.mime);
+
+  return realInfo;
+}
+
+// static
+mojo::ScopedSharedBufferHandle FontAccessServiceImpl::GetSharedBuffer(
+    const std::string& path,
+    uint64_t size) {
+  mojo::SharedBuffer buffer(size);
+  base::FilePath filepath(base::FilePath::FromUTF8Unsafe(path));
+  base::File file(filepath, base::File::FLAG_OPEN | base::File::FLAG_READ);
+  void* data;
+  mojo::MapBuffer(buffer.handle.get(), 0, size, &data,
+                  MOJO_MAP_BUFFER_FLAG_NONE);
+  bool valid_read = file.Read(0, static_cast<char*>(data), size);
+  if (!valid_read) {
+      return mojo::ScopedHandleBase<mojo::SharedBufferHandle>();

[nasko, 2016/02/12 22:05:18]

style: Indent only two spaces. One line if statements don't need {}.

[Daniel Nishi, 2016/02/12 22:49:39]

Done.

+  }
+
+

[nasko, 2016/02/12 22:05:18]

No need for two empty lines, one is fine.

[Daniel Nishi, 2016/02/12 22:49:39]

Done.

+  return std::move(buffer.handle);
+}
+
+void FontAccessServiceImpl::GetFileDataCallback(
+    const FontAccessService::GetFontDataCallback& callback,
+    const std::string& path,
+    BlobInfo info) {
+  if (!info.is_valid) {
+      callback.Run(mojo::ScopedHandleBase<mojo::SharedBufferHandle>(), 0);

[nasko, 2016/02/12 22:05:18]

style: Indent only two spaces.

[Daniel Nishi, 2016/02/12 22:49:39]

Done.

+      return;
+  }
+
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&FontAccessServiceImpl::GetSharedBuffer, path, info.size),
+      base::Bind(&FontAccessServiceImpl::PassBufferAndSize, callback,
+                 info.size));
+}
+
+void FontAccessServiceImpl::PassBufferAndSize(
+    const FontAccessService::GetFontDataCallback& callback,
+    uint64_t size,
+    mojo::ScopedSharedBufferHandle handle) {
+  callback.Run(std::move(handle), size);
+}
+
+}  // content