From 81fc9f01241ed5d635d35328fa226a682c7a81d2 Mon Sep 17 00:00:00 2001 From: "avi@chromium.org" Date: Fri, 9 Sep 2011 23:05:34 +0000 Subject: Move AttributedStringCoder from chrome to content. Also, move a few Mac-only files to the new content/commmon/mac. BUG=95573 TEST=no change Review URL: http://codereview.chromium.org/7867016 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@100526 0039d316-1c4b-4281-b951-d872f2087c98 --- content/common/font_descriptor_mac.h | 34 ---- content/common/font_descriptor_mac.mm | 25 --- content/common/font_descriptor_mac_unittest.mm | 114 ------------ content/common/font_loader_mac.h | 63 ------- content/common/font_loader_mac.mm | 194 --------------------- content/common/mac/attributed_string_coder.h | 119 +++++++++++++ content/common/mac/attributed_string_coder.mm | 171 ++++++++++++++++++ .../common/mac/attributed_string_coder_unittest.mm | 135 ++++++++++++++ content/common/mac/font_descriptor.h | 34 ++++ content/common/mac/font_descriptor.mm | 25 +++ content/common/mac/font_descriptor_unittest.mm | 114 ++++++++++++ content/common/mac/font_loader.h | 63 +++++++ content/common/mac/font_loader.mm | 194 +++++++++++++++++++++ content/common/sandbox_mac_fontloading_unittest.mm | 2 +- content/common/view_messages.h | 2 +- 15 files changed, 857 insertions(+), 432 deletions(-) delete mode 100644 content/common/font_descriptor_mac.h delete mode 100644 content/common/font_descriptor_mac.mm delete mode 100644 content/common/font_descriptor_mac_unittest.mm delete mode 100644 content/common/font_loader_mac.h delete mode 100644 content/common/font_loader_mac.mm create mode 100644 content/common/mac/attributed_string_coder.h create mode 100644 content/common/mac/attributed_string_coder.mm create mode 100644 content/common/mac/attributed_string_coder_unittest.mm create mode 100644 content/common/mac/font_descriptor.h create mode 100644 content/common/mac/font_descriptor.mm create mode 100644 content/common/mac/font_descriptor_unittest.mm create mode 100644 content/common/mac/font_loader.h create mode 100644 content/common/mac/font_loader.mm (limited to 'content/common') diff --git a/content/common/font_descriptor_mac.h b/content/common/font_descriptor_mac.h deleted file mode 100644 index c3ac5a8..0000000 --- a/content/common/font_descriptor_mac.h +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright (c) 2011 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. - -#ifndef CONTENT_COMMON_FONT_DESCRIPTOR_MAC_H_ -#define CONTENT_COMMON_FONT_DESCRIPTOR_MAC_H_ -#pragma once - -#include "base/string16.h" - -#ifdef __OBJC__ -@class NSFont; -#else -class NSFont; -#endif - -// Container to allow serializing an NSFont over IPC. -struct FontDescriptor { - explicit FontDescriptor(NSFont* font); - FontDescriptor(string16 name, float size); - - FontDescriptor() : font_point_size(0) {} - - // Return an autoreleased NSFont corresponding to the font description. - NSFont* ToNSFont() const; - - // Name of the font. - string16 font_name; - - // Size in points. - float font_point_size; -}; - -#endif // CONTENT_COMMON_FONT_DESCRIPTOR_MAC_H_ diff --git a/content/common/font_descriptor_mac.mm b/content/common/font_descriptor_mac.mm deleted file mode 100644 index c8e3112..0000000 --- a/content/common/font_descriptor_mac.mm +++ /dev/null @@ -1,25 +0,0 @@ -// Copyright (c) 2011 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_descriptor_mac.h" - -#include - -#include "base/sys_string_conversions.h" - -FontDescriptor::FontDescriptor(NSFont* font) { - font_name = base::SysNSStringToUTF16([font fontName]); - font_point_size = [font pointSize]; -} - -FontDescriptor::FontDescriptor(string16 name, float size) { - font_name = name; - font_point_size = size; -} - -NSFont* FontDescriptor::ToNSFont() const { - NSString* font_name_ns = base::SysUTF16ToNSString(font_name); - NSFont* font = [NSFont fontWithName:font_name_ns size:font_point_size]; - return font; -} diff --git a/content/common/font_descriptor_mac_unittest.mm b/content/common/font_descriptor_mac_unittest.mm deleted file mode 100644 index f8fdfc8..0000000 --- a/content/common/font_descriptor_mac_unittest.mm +++ /dev/null @@ -1,114 +0,0 @@ -// Copyright (c) 2011 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_descriptor_mac.h" - -#include - -#include "base/logging.h" -#include "base/utf_string_conversions.h" -#include "base/sys_string_conversions.h" -#include "testing/gtest_mac.h" -#include "testing/platform_test.h" - -namespace { - -class FontSerializationTest : public PlatformTest {}; - -const std::string kCourierFontName("Courier"); - -// Compare 2 fonts, make sure they point at the same font definition and have -// the same style. Only Bold & Italic style attributes are tested since those -// are the only ones we care about at the moment. -bool CompareFonts(NSFont* font1, NSFont* font2) { - ATSFontRef id1 = CTFontGetPlatformFont(reinterpret_cast(font1), 0); - ATSFontRef id2 = CTFontGetPlatformFont(reinterpret_cast(font2), 0); - - if (id1 != id2) { - LOG(ERROR) << "ATSFontRefs for " - << [[font1 fontName] UTF8String] - << " and " - << [[font2 fontName] UTF8String] - << " are different"; - return false; - } - - CGFloat size1 = [font1 pointSize]; - CGFloat size2 = [font2 pointSize]; - if (size1 != size2) { - LOG(ERROR) << "font sizes for " - << [[font1 fontName] UTF8String] << " (" << size1 << ")" - << "and" - << [[font2 fontName] UTF8String] << " (" << size2 << ")" - << " are different"; - return false; - } - - NSFontTraitMask traits1 = [[NSFontManager sharedFontManager] - traitsOfFont:font1]; - NSFontTraitMask traits2 = [[NSFontManager sharedFontManager] - traitsOfFont:font2]; - - bool is_bold1 = traits1 & NSBoldFontMask; - bool is_bold2 = traits2 & NSBoldFontMask; - bool is_italic1 = traits1 & NSItalicFontMask; - bool is_italic2 = traits2 & NSItalicFontMask; - - if (is_bold1 != is_bold2 || is_italic1 != is_italic2) { - LOG(ERROR) << "Style information for " - << [[font1 fontName] UTF8String] - << " and " - << [[font2 fontName] UTF8String] - << " are different"; - return false; - } - - return true; -} - -// Create an NSFont via a FontDescriptor object. -NSFont* MakeNSFont(const std::string& font_name, float font_point_size) { - FontDescriptor desc; - desc.font_name = UTF8ToUTF16(font_name); - desc.font_point_size = font_point_size; - return desc.ToNSFont(); -} - -// Verify that serialization and deserialization of fonts with various styles -// is performed correctly by FontDescriptor. -TEST_F(FontSerializationTest, StyledFonts) { - NSFont* plain_font = [NSFont systemFontOfSize:12.0]; - ASSERT_TRUE(plain_font != nil); - FontDescriptor desc_plain(plain_font); - EXPECT_TRUE(CompareFonts(plain_font, desc_plain.ToNSFont())); - - NSFont* bold_font = [NSFont boldSystemFontOfSize:30.0]; - ASSERT_TRUE(bold_font != nil); - FontDescriptor desc_bold(bold_font); - EXPECT_TRUE(CompareFonts(bold_font, desc_bold.ToNSFont())); - - NSFont* italic_bold_font = - [[NSFontManager sharedFontManager] - fontWithFamily:base::SysUTF8ToNSString(kCourierFontName) - traits:(NSBoldFontMask | NSItalicFontMask) - weight:5 - size:18.0]; - ASSERT_TRUE(italic_bold_font != nil); - FontDescriptor desc_italic_bold(italic_bold_font); - EXPECT_TRUE(CompareFonts(italic_bold_font, desc_italic_bold.ToNSFont())); -} - -// Test that FontDescriptor doesn't crash when used with bad parameters. -// This is important since FontDescriptors are constructed with parameters -// sent over IPC and bad values must not trigger unexpected behavior. -TEST_F(FontSerializationTest, BadParameters) { - EXPECT_NSNE(MakeNSFont(kCourierFontName, 12), nil); - EXPECT_NSNE(MakeNSFont(kCourierFontName, std::numeric_limits::min()), - nil); - EXPECT_NSNE(MakeNSFont(kCourierFontName, 0), nil); - EXPECT_NSNE(MakeNSFont(kCourierFontName, std::numeric_limits::max()), - nil); -} - -} // namespace diff --git a/content/common/font_loader_mac.h b/content/common/font_loader_mac.h deleted file mode 100644 index 410e076..0000000 --- a/content/common/font_loader_mac.h +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright (c) 2011 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. - -#ifndef CONTENT_COMMON_FONT_LOADER_MAC_H_ -#define CONTENT_COMMON_FONT_LOADER_MAC_H_ -#pragma once - -#include - -#include "base/shared_memory.h" - -#ifdef __OBJC__ -@class NSFont; -#else -class NSFont; -#endif - -// Provides functionality to transmit fonts over IPC. -// -// Note about font formats: .dfont (datafork suitcase) fonts are currently not -// supported by this code since CGFontCreateWithDataProvider() can't handle them -// directly. - -class FontLoader { - public: - // Load a font specified by |font_to_encode| into a shared memory buffer - // suitable for sending over IPC. - // - // On return: - // returns true on success, false on failure. - // |font_data| - shared memory buffer containing the raw data for the font - // file. - // |font_data_size| - size of data contained in |font_data|. - // |font_id| - unique identifier for the on-disk file we load for the font. - static bool LoadFontIntoBuffer(NSFont* font_to_encode, - base::SharedMemory* font_data, - uint32* font_data_size, - uint32* font_id); - - // Given a shared memory buffer containing the raw data for a font file, load - // the font and return a CGFontRef. - // - // |data| - A shared memory handle pointing to the raw data from a font file. - // |data_size| - Size of |data|. - // - // On return: - // returns true on success, false on failure. - // |out| - A CGFontRef corresponding to the designated font. - // The caller is responsible for releasing this value via CGFontRelease() - // when done. - static bool CGFontRefFromBuffer(base::SharedMemoryHandle font_data, - uint32 font_data_size, - CGFontRef* out); - - - // TODO(jeremy): Remove once http://webk.it/66935 lands. - static bool ATSFontContainerFromBuffer(base::SharedMemoryHandle font_data, - uint32 font_data_size, - ATSFontContainerRef* font_container); -}; - -#endif // CONTENT_COMMON_FONT_LOADER_MAC_H_ diff --git a/content/common/font_loader_mac.mm b/content/common/font_loader_mac.mm deleted file mode 100644 index 867e1d3..0000000 --- a/content/common/font_loader_mac.mm +++ /dev/null @@ -1,194 +0,0 @@ -// Copyright (c) 2011 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_loader_mac.h" - -#import - -#include "base/basictypes.h" -#include "base/file_path.h" -#include "base/file_util.h" -#include "base/logging.h" -#include "base/mac/foundation_util.h" -#include "base/mac/mac_util.h" -#include "base/mac/scoped_cftyperef.h" -#include "base/sys_string_conversions.h" - -extern "C" { - -// Work around http://crbug.com/93191, a really nasty memory smasher bug. -// On Mac OS X 10.7 ("Lion"), ATS writes to memory it doesn't own. -// SendDeactivateFontsInContainerMessage, called by ATSFontDeactivate, -// may trash memory whenever dlsym(RTLD_DEFAULT, -// "_CTFontManagerUnregisterFontForData") returns NULL. In that case, it tries -// to locate that symbol in the CoreText framework, doing some extremely -// sloppy string handling resulting in a likelihood that the string -// "Text.framework/Versions/A/CoreText" will be written over memory that it -// doesn't own. The kicker here is that Apple dlsym always inserts its own -// leading underscore, so ATS actually winds up looking up a -// __CTFontManagerUnregisterFontForData symbol, which doesn't even exist in -// CoreText. It's only got the single-underscore variant corresponding to an -// underscoreless extern "C" name. -// -// Providing a single-underscored extern "C" function by this name results in -// a __CTFontManagerUnregisterFontForData symbol that, as long as it's public -// (not private extern) and unstripped, ATS will find. If it finds it, it -// avoids making amateur string mistakes that ruin everyone else's good time. -// -// Since ATS wouldn't normally be able to call this function anyway, it's just -// left as a no-op here. -// -// This file seems as good as any other to place this function. It was chosen -// because it already interfaces with ATS for other reasons. -// -// SendDeactivateFontsInContainerMessage on 10.6 ("Snow Leopard") appears to -// share this bug but this sort of memory corruption wasn't detected until -// 10.7. The implementation in 10.5 ("Leopard") does not have this problem. -__attribute__((visibility("default"))) -void _CTFontManagerUnregisterFontForData(NSUInteger, int) { -} - -} // extern "C" - -// static -bool FontLoader::LoadFontIntoBuffer(NSFont* font_to_encode, - base::SharedMemory* font_data, - uint32* font_data_size, - uint32* font_id) { - CHECK(font_data); - CHECK(font_data_size); - CHECK(font_id); - *font_data_size = 0; - *font_id = 0; - - // Used only for logging. - std::string font_name([[font_to_encode fontName] UTF8String]); - - // Load appropriate NSFont. - if (!font_to_encode) { - LOG(ERROR) << "Failed to load font " << font_name; - return false; - } - - // NSFont -> ATSFontRef. - ATSFontRef ats_font = - CTFontGetPlatformFont(reinterpret_cast(font_to_encode), NULL); - if (!ats_font) { - LOG(ERROR) << "Conversion to ATSFontRef failed for " << font_name; - return false; - } - - // Retrieve the ATSFontContainerRef corresponding to the font file we want to - // load. This is a unique identifier that allows the caller determine if the - // font file in question is already loaded. - COMPILE_ASSERT(sizeof(ATSFontContainerRef) == sizeof(font_id), - uint32_cant_hold_fontcontainer_ref); - ATSFontContainerRef fontContainer = kATSFontContainerRefUnspecified; - if (ATSFontGetContainer(ats_font, 0, &fontContainer) != noErr) { - LOG(ERROR) << "Failed to get font container ref for " << font_name; - return false; - } - - // ATSFontRef -> File path. - // Warning: Calling this function on a font activated from memory will result - // in failure with a -50 - paramErr. This may occur if - // CreateCGFontFromBuffer() is called in the same process as this function - // e.g. when writing a unit test that exercises these two functions together. - // If said unit test were to load a system font and activate it from memory - // it becomes impossible for the system to the find the original file ref - // since the font now lives in memory as far as it's concerned. - FSRef font_fsref; - if (ATSFontGetFileReference(ats_font, &font_fsref) != noErr) { - LOG(ERROR) << "Failed to find font file for " << font_name; - return false; - } - FilePath font_path = FilePath(base::mac::PathFromFSRef(font_fsref)); - - // Load file into shared memory buffer. - int64 font_file_size_64 = -1; - if (!file_util::GetFileSize(font_path, &font_file_size_64)) { - LOG(ERROR) << "Couldn't get font file size for " << font_path.value(); - return false; - } - - if (font_file_size_64 <= 0 || font_file_size_64 >= kint32max) { - LOG(ERROR) << "Bad size for font file " << font_path.value(); - return false; - } - - int32 font_file_size_32 = static_cast(font_file_size_64); - if (!font_data->CreateAndMapAnonymous(font_file_size_32)) { - LOG(ERROR) << "Failed to create shmem area for " << font_name; - return false; - } - - int32 amt_read = file_util::ReadFile(font_path, - reinterpret_cast(font_data->memory()), - font_file_size_32); - if (amt_read != font_file_size_32) { - LOG(ERROR) << "Failed to read font data for " << font_path.value(); - return false; - } - - *font_data_size = font_file_size_32; - *font_id = fontContainer; - return true; -} - -// static -bool FontLoader::CGFontRefFromBuffer(base::SharedMemoryHandle font_data, - uint32 font_data_size, - CGFontRef* out) { - *out = NULL; - - using base::SharedMemory; - DCHECK(SharedMemory::IsHandleValid(font_data)); - DCHECK_GT(font_data_size, 0U); - - SharedMemory shm(font_data, /*read_only=*/true); - if (!shm.Map(font_data_size)) - return false; - - NSData* data = [NSData dataWithBytes:shm.memory() - length:font_data_size]; - base::mac::ScopedCFTypeRef provider( - CGDataProviderCreateWithCFData(base::mac::NSToCFCast(data))); - if (!provider) - return false; - - *out = CGFontCreateWithDataProvider(provider.get()); - - if (*out == NULL) - return false; - - return true; -} - -// TODO(jeremy): Remove once http://webk.it/66935 lands. -// static -bool FontLoader::ATSFontContainerFromBuffer(base::SharedMemoryHandle font_data, - uint32 font_data_size, - ATSFontContainerRef* font_container) -{ - CHECK(font_container); - - using base::SharedMemory; - DCHECK(SharedMemory::IsHandleValid(font_data)); - DCHECK_GT(font_data_size, 0U); - - SharedMemory shm(font_data, true); - if (!shm.Map(font_data_size)) - return false; - - // A value of 3 means the font is private and can't be seen by anyone else. - // This is the value used by WebKit when activating remote fonts. - const ATSFontContext kFontContextPrivate = 3; - OSStatus err = ATSFontActivateFromMemory(shm.memory(), font_data_size, - kFontContextPrivate, kATSFontFormatUnspecified, NULL, - kATSOptionFlagsDefault, font_container); - if (err != noErr || !font_container) - return false; - - return true; -} diff --git a/content/common/mac/attributed_string_coder.h b/content/common/mac/attributed_string_coder.h new file mode 100644 index 0000000..054cb45 --- /dev/null +++ b/content/common/mac/attributed_string_coder.h @@ -0,0 +1,119 @@ +// Copyright (c) 2011 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. + +#ifndef CONTENT_COMMON_MAC_ATTRIBUTED_STRING_CODER_H_ +#define CONTENT_COMMON_MAC_ATTRIBUTED_STRING_CODER_H_ +#pragma once + +#include + +#include "base/memory/scoped_ptr.h" +#include "base/string16.h" +#include "content/common/mac/font_descriptor.h" +#include "ipc/ipc_message_utils.h" +#include "ui/base/range/range.h" + +#if __OBJC__ +@class NSAttributedString; +@class NSDictionary; +#else +class NSAttributedString; +class NSDictionary; +#endif + +namespace mac { + +// This class will serialize the font information of an NSAttributedString so +// that it can be sent over IPC. This class only stores the information of the +// NSFontAttributeName. The motive is that of security: using NSArchiver and +// friends to send objects from the renderer to the browser could lead to +// deserialization of arbitrary objects. This class restricts serialization to +// a specific object class and specific attributes of that object. +class AttributedStringCoder { + public: + // A C++ IPC-friendly representation of the NSFontAttributeName attribute + // set. + class FontAttribute { + public: + FontAttribute(NSDictionary* ns_attributes, ui::Range effective_range); + FontAttribute(FontDescriptor font, ui::Range range); + FontAttribute(); + ~FontAttribute(); + + // Creates an autoreleased NSDictionary that can be attached to an + // NSAttributedString. + NSDictionary* ToAttributesDictionary() const; + + // Whether or not the attribute should be placed in the EncodedString. This + // can return false, e.g. if the Cocoa-based constructor can't find any + // information to encode. + bool ShouldEncode() const; + + // Accessors: + FontDescriptor font_descriptor() const { return font_descriptor_; } + ui::Range effective_range() const { return effective_range_; } + + private: + FontDescriptor font_descriptor_; + ui::Range effective_range_; + }; + + // A class that contains the pertinent information from an NSAttributedString, + // which can be serialized over IPC. + class EncodedString { + public: + explicit EncodedString(string16 string); + EncodedString(); + ~EncodedString(); + + // Accessors: + string16 string() const { return string_; } + const std::vector& attributes() const { + return attributes_; + } + std::vector* attributes() { return &attributes_; } + + private: + // The plain-text string. + string16 string_; + // The set of attributes that style |string_|. + std::vector attributes_; + }; + + // Takes an NSAttributedString, extracts the pertinent attributes, and returns + // an object that represents it. Caller owns the result. + static const EncodedString* Encode(NSAttributedString* str); + + // Returns an autoreleased NSAttributedString from an encoded representation. + static NSAttributedString* Decode(const EncodedString* str); + + private: + AttributedStringCoder(); +}; + +} // namespace mac + +// IPC ParamTraits specialization ////////////////////////////////////////////// + +namespace IPC { + +template <> +struct ParamTraits { + typedef mac::AttributedStringCoder::EncodedString param_type; + static void Write(Message* m, const param_type& p); + static bool Read(const Message* m, void** iter, param_type* r); + static void Log(const param_type& p, std::string* l); +}; + +template <> +struct ParamTraits { + typedef mac::AttributedStringCoder::FontAttribute param_type; + static void Write(Message* m, const param_type& p); + static bool Read(const Message* m, void** iter, param_type* r); + static void Log(const param_type& p, std::string* l); +}; + +} // namespace IPC + +#endif // CONTENT_COMMON_MAC_ATTRIBUTED_STRING_CODER_H_ diff --git a/content/common/mac/attributed_string_coder.mm b/content/common/mac/attributed_string_coder.mm new file mode 100644 index 0000000..ca4847d --- /dev/null +++ b/content/common/mac/attributed_string_coder.mm @@ -0,0 +1,171 @@ +// Copyright (c) 2011 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/mac/attributed_string_coder.h" + +#include + +#include "base/logging.h" +#include "base/memory/scoped_nsobject.h" +#include "base/sys_string_conversions.h" +#include "base/utf_string_conversions.h" +#include "content/common/common_param_traits.h" +#include "content/common/view_messages.h" +#include "ipc/ipc_message_utils.h" + +namespace mac { + +// static +const AttributedStringCoder::EncodedString* AttributedStringCoder::Encode( + NSAttributedString* str) { + // Create the return value. + EncodedString* encoded_string = + new EncodedString(base::SysNSStringToUTF16([str string])); + // Iterate over all the attributes in the string. + NSUInteger length = [str length]; + for (NSUInteger i = 0; i < length; ) { + NSRange effective_range; + NSDictionary* ns_attributes = [str attributesAtIndex:i + effectiveRange:&effective_range]; + // Convert the attributes to IPC-friendly types. + FontAttribute attrs(ns_attributes, ui::Range(effective_range)); + // Only encode the attributes if the filtered set contains font information. + if (attrs.ShouldEncode()) { + encoded_string->attributes()->push_back(attrs); + } + // Advance the iterator to the position outside of the effective range. + i = NSMaxRange(effective_range); + } + return encoded_string; +} + +// static +NSAttributedString* AttributedStringCoder::Decode( + const AttributedStringCoder::EncodedString* str) { + // Create the return value. + NSString* plain_text = base::SysUTF16ToNSString(str->string()); + scoped_nsobject decoded_string( + [[NSMutableAttributedString alloc] initWithString:plain_text]); + // Iterate over all the encoded attributes, attaching each to the string. + const std::vector attributes = str->attributes(); + for (std::vector::const_iterator it = attributes.begin(); + it != attributes.end(); ++it) { + // Protect against ranges that are outside the range of the string. + const ui::Range& range = it->effective_range(); + if (range.GetMin() > [plain_text length] || + range.GetMax() > [plain_text length]) { + continue; + } + [decoded_string addAttributes:it->ToAttributesDictionary() + range:range.ToNSRange()]; + } + return [decoded_string.release() autorelease]; +} + +// Data Types ////////////////////////////////////////////////////////////////// + +AttributedStringCoder::EncodedString::EncodedString(string16 string) + : string_(string) { +} + +AttributedStringCoder::EncodedString::EncodedString() + : string_() { +} + +AttributedStringCoder::EncodedString::~EncodedString() { +} + +AttributedStringCoder::FontAttribute::FontAttribute(NSDictionary* dict, + ui::Range effective_range) + : font_descriptor_(), + effective_range_(effective_range) { + NSFont* font = [dict objectForKey:NSFontAttributeName]; + if (font) { + font_descriptor_ = FontDescriptor(font); + } +} + +AttributedStringCoder::FontAttribute::FontAttribute(FontDescriptor font, + ui::Range range) + : font_descriptor_(font), + effective_range_(range) { +} + +AttributedStringCoder::FontAttribute::FontAttribute() + : font_descriptor_(), + effective_range_() { +} + +AttributedStringCoder::FontAttribute::~FontAttribute() { +} + +NSDictionary* AttributedStringCoder::FontAttribute::ToAttributesDictionary( + void) const { + DCHECK(ShouldEncode()); + NSFont* font = font_descriptor_.ToNSFont(); + return [NSDictionary dictionaryWithObject:font forKey:NSFontAttributeName]; +} + +bool AttributedStringCoder::FontAttribute::ShouldEncode() const { + return !font_descriptor_.font_name.empty(); +} + +} // namespace mac + +// IPC ParamTraits specialization ////////////////////////////////////////////// + +namespace IPC { + +using mac::AttributedStringCoder; + +void ParamTraits::Write( + Message* m, const param_type& p) { + WriteParam(m, p.string()); + WriteParam(m, p.attributes()); +} + +bool ParamTraits::Read( + const Message* m, void** iter, param_type* p) { + bool success = true; + + string16 result; + success &= ReadParam(m, iter, &result); + *p = AttributedStringCoder::EncodedString(result); + + success &= ReadParam(m, iter, p->attributes()); + return success; +} + +void ParamTraits::Log( + const param_type& p, std::string* l) { + l->append(UTF16ToUTF8(p.string())); +} + +void ParamTraits::Write( + Message* m, const param_type& p) { + WriteParam(m, p.font_descriptor()); + WriteParam(m, p.effective_range()); +} + +bool ParamTraits::Read( + const Message* m, void** iter, param_type* p) { + bool success = true; + + FontDescriptor font; + success &= ReadParam(m, iter, &font); + + ui::Range range; + success &= ReadParam(m, iter, &range); + + if (success) { + *p = AttributedStringCoder::FontAttribute(font, range); + } + return success; +} + +void ParamTraits::Log( + const param_type& p, std::string* l) { +} + +} // namespace IPC diff --git a/content/common/mac/attributed_string_coder_unittest.mm b/content/common/mac/attributed_string_coder_unittest.mm new file mode 100644 index 0000000..993c842 --- /dev/null +++ b/content/common/mac/attributed_string_coder_unittest.mm @@ -0,0 +1,135 @@ +// Copyright (c) 2011 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 + +#include "base/memory/scoped_nsobject.h" +#include "base/memory/scoped_ptr.h" +#include "base/utf_string_conversions.h" +#import "content/common/mac/attributed_string_coder.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "testing/gtest_mac.h" + +using mac::AttributedStringCoder; + +class AttributedStringCoderTest : public testing::Test { + public: + NSMutableAttributedString* NewAttrString() { + NSString* str = @"The quick brown fox jumped over the lazy dog."; + return [[NSMutableAttributedString alloc] initWithString:str]; + } + + NSDictionary* FontAttribute(NSString* name, CGFloat size) { + NSFont* font = [NSFont fontWithName:name size:size]; + return [NSDictionary dictionaryWithObject:font forKey:NSFontAttributeName]; + } + + NSAttributedString* EncodeAndDecode(NSAttributedString* str) { + scoped_ptr encoded_str( + AttributedStringCoder::Encode(str)); + return AttributedStringCoder::Decode(encoded_str.get()); + } +}; + +TEST_F(AttributedStringCoderTest, SimpleString) { + scoped_nsobject attr_str(NewAttrString()); + [attr_str addAttributes:FontAttribute(@"Helvetica", 12.5) + range:NSMakeRange(0, [attr_str length])]; + + NSAttributedString* decoded = EncodeAndDecode(attr_str.get()); + EXPECT_NSEQ(attr_str.get(), decoded); +} + +TEST_F(AttributedStringCoderTest, NoAttributes) { + scoped_nsobject attr_str(NewAttrString()); + NSAttributedString* decoded = EncodeAndDecode(attr_str.get()); + EXPECT_NSEQ(attr_str.get(), decoded); +} + +TEST_F(AttributedStringCoderTest, StripColor) { + scoped_nsobject attr_str(NewAttrString()); + const NSUInteger kStringLength = [attr_str length]; + [attr_str addAttribute:NSFontAttributeName + value:[NSFont systemFontOfSize:26] + range:NSMakeRange(0, kStringLength)]; + [attr_str addAttribute:NSForegroundColorAttributeName + value:[NSColor redColor] + range:NSMakeRange(0, kStringLength)]; + + NSAttributedString* decoded = EncodeAndDecode(attr_str.get()); + + NSRange range; + NSDictionary* attrs = [decoded attributesAtIndex:0 effectiveRange:&range]; + EXPECT_TRUE(NSEqualRanges(NSMakeRange(0, kStringLength), range)); + EXPECT_NSEQ([NSFont systemFontOfSize:26], + [attrs objectForKey:NSFontAttributeName]); + EXPECT_FALSE([attrs objectForKey:NSForegroundColorAttributeName]); +} + +TEST_F(AttributedStringCoderTest, MultipleFonts) { + scoped_nsobject attr_str(NewAttrString()); + [attr_str setAttributes:FontAttribute(@"Courier", 12) + range:NSMakeRange(0, 10)]; + [attr_str addAttributes:FontAttribute(@"Helvetica", 16) + range:NSMakeRange(12, 6)]; + [attr_str addAttributes:FontAttribute(@"Helvetica", 14) + range:NSMakeRange(15, 5)]; + + NSAttributedString* decoded = EncodeAndDecode(attr_str); + + EXPECT_NSEQ(attr_str.get(), decoded); +} + +TEST_F(AttributedStringCoderTest, NoPertinentAttributes) { + scoped_nsobject attr_str(NewAttrString()); + [attr_str addAttribute:NSForegroundColorAttributeName + value:[NSColor blueColor] + range:NSMakeRange(0, 10)]; + [attr_str addAttribute:NSBackgroundColorAttributeName + value:[NSColor blueColor] + range:NSMakeRange(15, 5)]; + [attr_str addAttribute:NSKernAttributeName + value:[NSNumber numberWithFloat:2.6] + range:NSMakeRange(11, 3)]; + + NSAttributedString* decoded = EncodeAndDecode(attr_str.get()); + + scoped_nsobject expected(NewAttrString()); + EXPECT_NSEQ(expected.get(), decoded); +} + +TEST_F(AttributedStringCoderTest, NilString) { + NSAttributedString* decoded = EncodeAndDecode(nil); + EXPECT_TRUE(decoded); + EXPECT_EQ(0U, [decoded length]); +} + +TEST_F(AttributedStringCoderTest, OutOfRange) { + AttributedStringCoder::EncodedString encoded(ASCIIToUTF16("Hello World")); + encoded.attributes()->push_back( + AttributedStringCoder::FontAttribute( + FontDescriptor([NSFont systemFontOfSize:12]), + ui::Range(0, 5))); + encoded.attributes()->push_back( + AttributedStringCoder::FontAttribute( + FontDescriptor([NSFont systemFontOfSize:14]), + ui::Range(5, 100))); + encoded.attributes()->push_back( + AttributedStringCoder::FontAttribute( + FontDescriptor([NSFont systemFontOfSize:16]), + ui::Range(100, 5))); + + NSAttributedString* decoded = AttributedStringCoder::Decode(&encoded); + EXPECT_TRUE(decoded); + + NSRange range; + NSDictionary* attrs = [decoded attributesAtIndex:0 effectiveRange:&range]; + EXPECT_NSEQ([NSFont systemFontOfSize:12], + [attrs objectForKey:NSFontAttributeName]); + EXPECT_TRUE(NSEqualRanges(range, NSMakeRange(0, 5))); + + attrs = [decoded attributesAtIndex:5 effectiveRange:&range]; + EXPECT_FALSE([attrs objectForKey:NSFontAttributeName]); + EXPECT_EQ(0U, [attrs count]); +} diff --git a/content/common/mac/font_descriptor.h b/content/common/mac/font_descriptor.h new file mode 100644 index 0000000..750976f --- /dev/null +++ b/content/common/mac/font_descriptor.h @@ -0,0 +1,34 @@ +// Copyright (c) 2011 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. + +#ifndef CONTENT_COMMON_MAC_FONT_DESCRIPTOR_H_ +#define CONTENT_COMMON_MAC_FONT_DESCRIPTOR_H_ +#pragma once + +#include "base/string16.h" + +#ifdef __OBJC__ +@class NSFont; +#else +class NSFont; +#endif + +// Container to allow serializing an NSFont over IPC. +struct FontDescriptor { + explicit FontDescriptor(NSFont* font); + FontDescriptor(string16 name, float size); + + FontDescriptor() : font_point_size(0) {} + + // Return an autoreleased NSFont corresponding to the font description. + NSFont* ToNSFont() const; + + // Name of the font. + string16 font_name; + + // Size in points. + float font_point_size; +}; + +#endif // CONTENT_COMMON_MAC_FONT_DESCRIPTOR_H_ diff --git a/content/common/mac/font_descriptor.mm b/content/common/mac/font_descriptor.mm new file mode 100644 index 0000000..65ab40e --- /dev/null +++ b/content/common/mac/font_descriptor.mm @@ -0,0 +1,25 @@ +// Copyright (c) 2011 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/mac/font_descriptor.h" + +#include + +#include "base/sys_string_conversions.h" + +FontDescriptor::FontDescriptor(NSFont* font) { + font_name = base::SysNSStringToUTF16([font fontName]); + font_point_size = [font pointSize]; +} + +FontDescriptor::FontDescriptor(string16 name, float size) { + font_name = name; + font_point_size = size; +} + +NSFont* FontDescriptor::ToNSFont() const { + NSString* font_name_ns = base::SysUTF16ToNSString(font_name); + NSFont* font = [NSFont fontWithName:font_name_ns size:font_point_size]; + return font; +} diff --git a/content/common/mac/font_descriptor_unittest.mm b/content/common/mac/font_descriptor_unittest.mm new file mode 100644 index 0000000..7054c22 --- /dev/null +++ b/content/common/mac/font_descriptor_unittest.mm @@ -0,0 +1,114 @@ +// Copyright (c) 2011 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/mac/font_descriptor.h" + +#include + +#include "base/logging.h" +#include "base/utf_string_conversions.h" +#include "base/sys_string_conversions.h" +#include "testing/gtest_mac.h" +#include "testing/platform_test.h" + +namespace { + +class FontSerializationTest : public PlatformTest {}; + +const std::string kCourierFontName("Courier"); + +// Compare 2 fonts, make sure they point at the same font definition and have +// the same style. Only Bold & Italic style attributes are tested since those +// are the only ones we care about at the moment. +bool CompareFonts(NSFont* font1, NSFont* font2) { + ATSFontRef id1 = CTFontGetPlatformFont(reinterpret_cast(font1), 0); + ATSFontRef id2 = CTFontGetPlatformFont(reinterpret_cast(font2), 0); + + if (id1 != id2) { + LOG(ERROR) << "ATSFontRefs for " + << [[font1 fontName] UTF8String] + << " and " + << [[font2 fontName] UTF8String] + << " are different"; + return false; + } + + CGFloat size1 = [font1 pointSize]; + CGFloat size2 = [font2 pointSize]; + if (size1 != size2) { + LOG(ERROR) << "font sizes for " + << [[font1 fontName] UTF8String] << " (" << size1 << ")" + << "and" + << [[font2 fontName] UTF8String] << " (" << size2 << ")" + << " are different"; + return false; + } + + NSFontTraitMask traits1 = [[NSFontManager sharedFontManager] + traitsOfFont:font1]; + NSFontTraitMask traits2 = [[NSFontManager sharedFontManager] + traitsOfFont:font2]; + + bool is_bold1 = traits1 & NSBoldFontMask; + bool is_bold2 = traits2 & NSBoldFontMask; + bool is_italic1 = traits1 & NSItalicFontMask; + bool is_italic2 = traits2 & NSItalicFontMask; + + if (is_bold1 != is_bold2 || is_italic1 != is_italic2) { + LOG(ERROR) << "Style information for " + << [[font1 fontName] UTF8String] + << " and " + << [[font2 fontName] UTF8String] + << " are different"; + return false; + } + + return true; +} + +// Create an NSFont via a FontDescriptor object. +NSFont* MakeNSFont(const std::string& font_name, float font_point_size) { + FontDescriptor desc; + desc.font_name = UTF8ToUTF16(font_name); + desc.font_point_size = font_point_size; + return desc.ToNSFont(); +} + +// Verify that serialization and deserialization of fonts with various styles +// is performed correctly by FontDescriptor. +TEST_F(FontSerializationTest, StyledFonts) { + NSFont* plain_font = [NSFont systemFontOfSize:12.0]; + ASSERT_TRUE(plain_font != nil); + FontDescriptor desc_plain(plain_font); + EXPECT_TRUE(CompareFonts(plain_font, desc_plain.ToNSFont())); + + NSFont* bold_font = [NSFont boldSystemFontOfSize:30.0]; + ASSERT_TRUE(bold_font != nil); + FontDescriptor desc_bold(bold_font); + EXPECT_TRUE(CompareFonts(bold_font, desc_bold.ToNSFont())); + + NSFont* italic_bold_font = + [[NSFontManager sharedFontManager] + fontWithFamily:base::SysUTF8ToNSString(kCourierFontName) + traits:(NSBoldFontMask | NSItalicFontMask) + weight:5 + size:18.0]; + ASSERT_TRUE(italic_bold_font != nil); + FontDescriptor desc_italic_bold(italic_bold_font); + EXPECT_TRUE(CompareFonts(italic_bold_font, desc_italic_bold.ToNSFont())); +} + +// Test that FontDescriptor doesn't crash when used with bad parameters. +// This is important since FontDescriptors are constructed with parameters +// sent over IPC and bad values must not trigger unexpected behavior. +TEST_F(FontSerializationTest, BadParameters) { + EXPECT_NSNE(MakeNSFont(kCourierFontName, 12), nil); + EXPECT_NSNE(MakeNSFont(kCourierFontName, std::numeric_limits::min()), + nil); + EXPECT_NSNE(MakeNSFont(kCourierFontName, 0), nil); + EXPECT_NSNE(MakeNSFont(kCourierFontName, std::numeric_limits::max()), + nil); +} + +} // namespace diff --git a/content/common/mac/font_loader.h b/content/common/mac/font_loader.h new file mode 100644 index 0000000..7cd6682 --- /dev/null +++ b/content/common/mac/font_loader.h @@ -0,0 +1,63 @@ +// Copyright (c) 2011 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. + +#ifndef CONTENT_COMMON_MAC_FONT_LOADER_H_ +#define CONTENT_COMMON_MAC_FONT_LOADER_H_ +#pragma once + +#include + +#include "base/shared_memory.h" + +#ifdef __OBJC__ +@class NSFont; +#else +class NSFont; +#endif + +// Provides functionality to transmit fonts over IPC. +// +// Note about font formats: .dfont (datafork suitcase) fonts are currently not +// supported by this code since CGFontCreateWithDataProvider() can't handle them +// directly. + +class FontLoader { + public: + // Load a font specified by |font_to_encode| into a shared memory buffer + // suitable for sending over IPC. + // + // On return: + // returns true on success, false on failure. + // |font_data| - shared memory buffer containing the raw data for the font + // file. + // |font_data_size| - size of data contained in |font_data|. + // |font_id| - unique identifier for the on-disk file we load for the font. + static bool LoadFontIntoBuffer(NSFont* font_to_encode, + base::SharedMemory* font_data, + uint32* font_data_size, + uint32* font_id); + + // Given a shared memory buffer containing the raw data for a font file, load + // the font and return a CGFontRef. + // + // |data| - A shared memory handle pointing to the raw data from a font file. + // |data_size| - Size of |data|. + // + // On return: + // returns true on success, false on failure. + // |out| - A CGFontRef corresponding to the designated font. + // The caller is responsible for releasing this value via CGFontRelease() + // when done. + static bool CGFontRefFromBuffer(base::SharedMemoryHandle font_data, + uint32 font_data_size, + CGFontRef* out); + + + // TODO(jeremy): Remove once http://webk.it/66935 lands. + static bool ATSFontContainerFromBuffer(base::SharedMemoryHandle font_data, + uint32 font_data_size, + ATSFontContainerRef* font_container); +}; + +#endif // CONTENT_COMMON_MAC_FONT_LOADER_H_ diff --git a/content/common/mac/font_loader.mm b/content/common/mac/font_loader.mm new file mode 100644 index 0000000..93eb03f --- /dev/null +++ b/content/common/mac/font_loader.mm @@ -0,0 +1,194 @@ +// Copyright (c) 2011 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/mac/font_loader.h" + +#import + +#include "base/basictypes.h" +#include "base/file_path.h" +#include "base/file_util.h" +#include "base/logging.h" +#include "base/mac/foundation_util.h" +#include "base/mac/mac_util.h" +#include "base/mac/scoped_cftyperef.h" +#include "base/sys_string_conversions.h" + +extern "C" { + +// Work around http://crbug.com/93191, a really nasty memory smasher bug. +// On Mac OS X 10.7 ("Lion"), ATS writes to memory it doesn't own. +// SendDeactivateFontsInContainerMessage, called by ATSFontDeactivate, +// may trash memory whenever dlsym(RTLD_DEFAULT, +// "_CTFontManagerUnregisterFontForData") returns NULL. In that case, it tries +// to locate that symbol in the CoreText framework, doing some extremely +// sloppy string handling resulting in a likelihood that the string +// "Text.framework/Versions/A/CoreText" will be written over memory that it +// doesn't own. The kicker here is that Apple dlsym always inserts its own +// leading underscore, so ATS actually winds up looking up a +// __CTFontManagerUnregisterFontForData symbol, which doesn't even exist in +// CoreText. It's only got the single-underscore variant corresponding to an +// underscoreless extern "C" name. +// +// Providing a single-underscored extern "C" function by this name results in +// a __CTFontManagerUnregisterFontForData symbol that, as long as it's public +// (not private extern) and unstripped, ATS will find. If it finds it, it +// avoids making amateur string mistakes that ruin everyone else's good time. +// +// Since ATS wouldn't normally be able to call this function anyway, it's just +// left as a no-op here. +// +// This file seems as good as any other to place this function. It was chosen +// because it already interfaces with ATS for other reasons. +// +// SendDeactivateFontsInContainerMessage on 10.6 ("Snow Leopard") appears to +// share this bug but this sort of memory corruption wasn't detected until +// 10.7. The implementation in 10.5 ("Leopard") does not have this problem. +__attribute__((visibility("default"))) +void _CTFontManagerUnregisterFontForData(NSUInteger, int) { +} + +} // extern "C" + +// static +bool FontLoader::LoadFontIntoBuffer(NSFont* font_to_encode, + base::SharedMemory* font_data, + uint32* font_data_size, + uint32* font_id) { + CHECK(font_data); + CHECK(font_data_size); + CHECK(font_id); + *font_data_size = 0; + *font_id = 0; + + // Used only for logging. + std::string font_name([[font_to_encode fontName] UTF8String]); + + // Load appropriate NSFont. + if (!font_to_encode) { + LOG(ERROR) << "Failed to load font " << font_name; + return false; + } + + // NSFont -> ATSFontRef. + ATSFontRef ats_font = + CTFontGetPlatformFont(reinterpret_cast(font_to_encode), NULL); + if (!ats_font) { + LOG(ERROR) << "Conversion to ATSFontRef failed for " << font_name; + return false; + } + + // Retrieve the ATSFontContainerRef corresponding to the font file we want to + // load. This is a unique identifier that allows the caller determine if the + // font file in question is already loaded. + COMPILE_ASSERT(sizeof(ATSFontContainerRef) == sizeof(font_id), + uint32_cant_hold_fontcontainer_ref); + ATSFontContainerRef fontContainer = kATSFontContainerRefUnspecified; + if (ATSFontGetContainer(ats_font, 0, &fontContainer) != noErr) { + LOG(ERROR) << "Failed to get font container ref for " << font_name; + return false; + } + + // ATSFontRef -> File path. + // Warning: Calling this function on a font activated from memory will result + // in failure with a -50 - paramErr. This may occur if + // CreateCGFontFromBuffer() is called in the same process as this function + // e.g. when writing a unit test that exercises these two functions together. + // If said unit test were to load a system font and activate it from memory + // it becomes impossible for the system to the find the original file ref + // since the font now lives in memory as far as it's concerned. + FSRef font_fsref; + if (ATSFontGetFileReference(ats_font, &font_fsref) != noErr) { + LOG(ERROR) << "Failed to find font file for " << font_name; + return false; + } + FilePath font_path = FilePath(base::mac::PathFromFSRef(font_fsref)); + + // Load file into shared memory buffer. + int64 font_file_size_64 = -1; + if (!file_util::GetFileSize(font_path, &font_file_size_64)) { + LOG(ERROR) << "Couldn't get font file size for " << font_path.value(); + return false; + } + + if (font_file_size_64 <= 0 || font_file_size_64 >= kint32max) { + LOG(ERROR) << "Bad size for font file " << font_path.value(); + return false; + } + + int32 font_file_size_32 = static_cast(font_file_size_64); + if (!font_data->CreateAndMapAnonymous(font_file_size_32)) { + LOG(ERROR) << "Failed to create shmem area for " << font_name; + return false; + } + + int32 amt_read = file_util::ReadFile(font_path, + reinterpret_cast(font_data->memory()), + font_file_size_32); + if (amt_read != font_file_size_32) { + LOG(ERROR) << "Failed to read font data for " << font_path.value(); + return false; + } + + *font_data_size = font_file_size_32; + *font_id = fontContainer; + return true; +} + +// static +bool FontLoader::CGFontRefFromBuffer(base::SharedMemoryHandle font_data, + uint32 font_data_size, + CGFontRef* out) { + *out = NULL; + + using base::SharedMemory; + DCHECK(SharedMemory::IsHandleValid(font_data)); + DCHECK_GT(font_data_size, 0U); + + SharedMemory shm(font_data, /*read_only=*/true); + if (!shm.Map(font_data_size)) + return false; + + NSData* data = [NSData dataWithBytes:shm.memory() + length:font_data_size]; + base::mac::ScopedCFTypeRef provider( + CGDataProviderCreateWithCFData(base::mac::NSToCFCast(data))); + if (!provider) + return false; + + *out = CGFontCreateWithDataProvider(provider.get()); + + if (*out == NULL) + return false; + + return true; +} + +// TODO(jeremy): Remove once http://webk.it/66935 lands. +// static +bool FontLoader::ATSFontContainerFromBuffer(base::SharedMemoryHandle font_data, + uint32 font_data_size, + ATSFontContainerRef* font_container) +{ + CHECK(font_container); + + using base::SharedMemory; + DCHECK(SharedMemory::IsHandleValid(font_data)); + DCHECK_GT(font_data_size, 0U); + + SharedMemory shm(font_data, true); + if (!shm.Map(font_data_size)) + return false; + + // A value of 3 means the font is private and can't be seen by anyone else. + // This is the value used by WebKit when activating remote fonts. + const ATSFontContext kFontContextPrivate = 3; + OSStatus err = ATSFontActivateFromMemory(shm.memory(), font_data_size, + kFontContextPrivate, kATSFontFormatUnspecified, NULL, + kATSOptionFlagsDefault, font_container); + if (err != noErr || !font_container) + return false; + + return true; +} diff --git a/content/common/sandbox_mac_fontloading_unittest.mm b/content/common/sandbox_mac_fontloading_unittest.mm index bca576d..911110f 100644 --- a/content/common/sandbox_mac_fontloading_unittest.mm +++ b/content/common/sandbox_mac_fontloading_unittest.mm @@ -9,7 +9,7 @@ #include "base/mac/scoped_cftyperef.h" #include "base/memory/scoped_ptr.h" #include "base/shared_memory.h" -#include "content/common/font_loader_mac.h" +#include "content/common/mac/font_loader.h" #include "content/common/sandbox_mac_unittest_helper.h" #include "testing/gtest/include/gtest/gtest.h" diff --git a/content/common/view_messages.h b/content/common/view_messages.h index 9a281f54..d127d71 100644 --- a/content/common/view_messages.h +++ b/content/common/view_messages.h @@ -40,7 +40,7 @@ #include "webkit/plugins/webplugininfo.h" #if defined(OS_MACOSX) -#include "content/common/font_descriptor_mac.h" +#include "content/common/mac/font_descriptor.h" #endif // Define enums used in this file inside an include-guard. -- cgit v1.1