Move legacyCreateTypeface to SkFontStyle.

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 <stdint.h>
 #include <sys/mman.h>
@@ skipping 46 matching lines @@
 FontConfigIPC::FontConfigIPC(int fd)
     : fd_(fd)
     , mapped_typefaces_(kMaxMappedTypefaces) {
 }
 
 FontConfigIPC::~FontConfigIPC() {
   CloseFD(fd_);
 }
 
 bool FontConfigIPC::matchFamilyName(const char familyName[],
-                                    SkTypeface::Style requestedStyle,
+                                    SkFontStyle requestedStyle,
                                     FontIdentity* outFontIdentity,
                                     SkString* outFamilyName,
-                                    SkTypeface::Style* outStyle) {
+                                    SkFontStyle* outStyle) {
   TRACE_EVENT0("sandbox_ipc", "FontConfigIPC::matchFamilyName");
   size_t familyNameLen = familyName ? strlen(familyName) : 0;
   if (familyNameLen > kMaxFontFamilyLength)
     return false;
 
   base::Pickle request;
   request.WriteInt(METHOD_MATCH);
   request.WriteData(familyName, familyNameLen);
-  request.WriteUInt32(requestedStyle);
+  request.WriteUInt32(static_cast<uint32_t>(requestedStyle));

[dcheng, 2016/04/11 19:51:06]

How does this work? Isn't SkFontStyle a class?
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/skia/i...

[bungeman-chromium, 2016/04/11 20:32:17]

It is a class, but is explicitly convertible to a uint32_t (since that's
essentially what it is). If it's preferable, we could write
skia::WriteSkFontStyle and skia::ReadSkFontStyle in skia_utils_base, but it
seemed like a lot of work for what was essentially just an uint32_t. However, it
wouldn't be too much work to do if you think it would be better to write it out
per-component and then read it back in per-component.

[dcheng, 2016/04/11 21:06:50]

Right, I see that it just wraps a union that's uint32_t sized. But I don't see
operator uint32_t() defined on SkFontStyle, so I'm wondering how the compiler
ends up performing this conversion.

In any case, I'd prefer to see this written with something more explicit like
base::TimeTicks::ToInternalValue() and base::TimeTicks::FromInternalValue(). We
could just call it ToUint32() and FromUint32() for SkFontStyle.

[bungeman-chromium, 2016/04/11 22:31:10]

The Skia change linked in the description is being pulled in via DEPS.
Done.

 
   uint8_t reply_buf[2048];
   const ssize_t r = base::UnixDomainSocket::SendRecvMsg(
       fd_, reply_buf, sizeof(reply_buf), NULL, request);
   if (r == -1)
     return false;
 
   base::Pickle reply(reinterpret_cast<char*>(reply_buf), r);
   base::PickleIterator iter(reply);
   bool result;
   if (!iter.ReadBool(&result))
     return false;
   if (!result)
     return false;
 
   SkString     reply_family;
   FontIdentity reply_identity;
   uint32_t     reply_style;
   if (!skia::ReadSkString(&iter, &reply_family) ||
       !skia::ReadSkFontIdentity(&iter, &reply_identity) ||
       !iter.ReadUInt32(&reply_style)) {
     return false;
   }
 
   if (outFontIdentity)
     *outFontIdentity = reply_identity;
   if (outFamilyName)
     *outFamilyName = reply_family;
   if (outStyle)
-    *outStyle = static_cast<SkTypeface::Style>(reply_style);
+    *outStyle = static_cast<SkFontStyle>(reply_style);
 
   return true;
 }
 
 static void DestroyMemoryMappedFile(const void*, void* context) {
   base::ThreadRestrictions::ScopedAllowIO allow_munmap;
   delete static_cast<base::MemoryMappedFile*>(context);
 }
 
 SkMemoryStream* FontConfigIPC::mapFileDescriptorToStream(int fd) {
@@ skipping 49 matching lines @@
   if (!typeface_stream)
     return nullptr;
   skia::RefPtr<SkTypeface> typeface_from_stream = skia::AdoptRef(
       SkTypeface::CreateFromStream(typeface_stream, identity.fTTCIndex));
   auto mapped_typefaces_insert_it =
       mapped_typefaces_.Put(identity, typeface_from_stream);
   return SkSafeRef(mapped_typefaces_insert_it->second.get());
 }
 
 }  // namespace content