diff options
| -rw-r--r-- | base/base.gyp | 1 | ||||
| -rw-r--r-- | base/mac/foundation_util.h | 11 | ||||
| -rw-r--r-- | base/mac/foundation_util.mm | 10 | ||||
| -rw-r--r-- | skia/ext/skia_utils_mac.h | 4 | ||||
| -rw-r--r-- | ui/gfx/render_text_mac.cc | 369 | ||||
| -rw-r--r-- | ui/gfx/render_text_mac.h | 96 | ||||
| -rw-r--r-- | ui/gfx/render_text_unittest.cc | 12 | ||||
| -rw-r--r-- | ui/ui.gyp | 26 | ||||
| -rw-r--r-- | ui/ui_unittests.gypi | 2 |
9 files changed, 510 insertions, 21 deletions
diff --git a/base/base.gyp b/base/base.gyp index bb2563b..54ef20a 100644 --- a/base/base.gyp +++ b/base/base.gyp @@ -166,6 +166,7 @@ 'link_settings': { 'libraries': [ '$(SDKROOT)/System/Library/Frameworks/AppKit.framework', + '$(SDKROOT)/System/Library/Frameworks/ApplicationServices.framework', '$(SDKROOT)/System/Library/Frameworks/Carbon.framework', '$(SDKROOT)/System/Library/Frameworks/CoreFoundation.framework', '$(SDKROOT)/System/Library/Frameworks/Foundation.framework', diff --git a/base/mac/foundation_util.h b/base/mac/foundation_util.h index 64adb8b..6428fa6 100644 --- a/base/mac/foundation_util.h +++ b/base/mac/foundation_util.h @@ -5,6 +5,7 @@ #ifndef BASE_MAC_FOUNDATION_UTIL_H_ #define BASE_MAC_FOUNDATION_UTIL_H_ +#include <ApplicationServices/ApplicationServices.h> #include <CoreFoundation/CoreFoundation.h> #include <string> @@ -103,6 +104,11 @@ TYPE_NAME_FOR_CF_TYPE_DECL(CFNumber); TYPE_NAME_FOR_CF_TYPE_DECL(CFSet); TYPE_NAME_FOR_CF_TYPE_DECL(CFString); +TYPE_NAME_FOR_CF_TYPE_DECL(CGColor); + +TYPE_NAME_FOR_CF_TYPE_DECL(CTFont); +TYPE_NAME_FOR_CF_TYPE_DECL(CTRun); + #undef TYPE_NAME_FOR_CF_TYPE_DECL // Retain/release calls for memory management in C++. @@ -248,6 +254,11 @@ CF_CAST_DECL(CFNumber); CF_CAST_DECL(CFSet); CF_CAST_DECL(CFString); +CF_CAST_DECL(CGColor); + +CF_CAST_DECL(CTFont); +CF_CAST_DECL(CTRun); + CF_CAST_DECL(SecACL); CF_CAST_DECL(SecTrustedApplication); diff --git a/base/mac/foundation_util.mm b/base/mac/foundation_util.mm index 7290615..d9cbbfb 100644 --- a/base/mac/foundation_util.mm +++ b/base/mac/foundation_util.mm @@ -201,6 +201,11 @@ TYPE_NAME_FOR_CF_TYPE_DEFN(CFNumber); TYPE_NAME_FOR_CF_TYPE_DEFN(CFSet); TYPE_NAME_FOR_CF_TYPE_DEFN(CFString); +TYPE_NAME_FOR_CF_TYPE_DEFN(CGColor); + +TYPE_NAME_FOR_CF_TYPE_DEFN(CTFont); +TYPE_NAME_FOR_CF_TYPE_DEFN(CTRun); + #undef TYPE_NAME_FOR_CF_TYPE_DEFN void NSObjectRetain(void* obj) { @@ -329,6 +334,11 @@ CF_CAST_DEFN(CFNumber); CF_CAST_DEFN(CFSet); CF_CAST_DEFN(CFString); +CF_CAST_DEFN(CGColor); + +CF_CAST_DEFN(CTFont); +CF_CAST_DEFN(CTRun); + #if !defined(OS_IOS) CF_CAST_DEFN(SecACL); CF_CAST_DEFN(SecTrustedApplication); diff --git a/skia/ext/skia_utils_mac.h b/skia/ext/skia_utils_mac.h index 4af2ba9..79b9599 100644 --- a/skia/ext/skia_utils_mac.h +++ b/skia/ext/skia_utils_mac.h @@ -59,10 +59,10 @@ CGRect SkIRectToCGRect(const SkIRect& rect); CGRect SkRectToCGRect(const SkRect& rect); // Converts CGColorRef to the ARGB layout Skia expects. -SkColor CGColorRefToSkColor(CGColorRef color); +SK_API SkColor CGColorRefToSkColor(CGColorRef color); // Converts ARGB to CGColorRef. -CGColorRef SkColorToCGColorRef(SkColor color); +SK_API CGColorRef SkColorToCGColorRef(SkColor color); // Converts NSColor to ARGB. Returns raw rgb values and does no colorspace // conversion. Only valid for colors in calibrated and device color spaces. diff --git a/ui/gfx/render_text_mac.cc b/ui/gfx/render_text_mac.cc new file mode 100644 index 0000000..b157ecc --- /dev/null +++ b/ui/gfx/render_text_mac.cc @@ -0,0 +1,369 @@ +// 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 "ui/gfx/render_text_mac.h" + +#include <ApplicationServices/ApplicationServices.h> + +#include <cmath> +#include <utility> + +#include "base/mac/foundation_util.h" +#include "base/mac/scoped_cftyperef.h" +#include "base/sys_string_conversions.h" +#include "skia/ext/skia_utils_mac.h" + +namespace { + +// Returns the pixel height of |ct_font|. +CGFloat GetCTFontPixelSize(CTFontRef ct_font) { + return CTFontGetAscent(ct_font) + CTFontGetDescent(ct_font); +} + +// Creates a CTFont with the given font name and pixel size. Ownership is +// transferred to the caller. +// +// Note: This code makes use of pixel sizes (rather than view coordinate sizes) +// because it draws to an underlying Skia canvas, which is normally pixel based. +CTFontRef CreateCTFontWithPixelSize(const std::string& font_name, + const int target_pixel_size) { + // Epsilon value used for comparing font sizes. + const CGFloat kEpsilon = 0.001; + // The observed pixel to points ratio for Lucida Grande on 10.6. Other fonts + // have other ratios and the documentation doesn't provide a guarantee that + // the relation is linear. So this ratio is used as a first try before + // falling back to the bisection method. + const CGFloat kPixelsToPointsRatio = 0.849088; + + base::mac::ScopedCFTypeRef<CFStringRef> font_name_cf_string( + base::SysUTF8ToCFStringRef(font_name)); + + // First, try using |kPixelsToPointsRatio|. + CGFloat point_size = target_pixel_size * kPixelsToPointsRatio; + base::mac::ScopedCFTypeRef<CTFontRef> ct_font( + CTFontCreateWithName(font_name_cf_string, point_size, NULL)); + CGFloat actual_pixel_size = GetCTFontPixelSize(ct_font); + if (std::fabs(actual_pixel_size - target_pixel_size) < kEpsilon) + return ct_font.release(); + + // |kPixelsToPointsRatio| wasn't correct. Use the bisection method to find the + // right size. + + // First, find the initial bisection range, so that the point size that + // corresponds to |target_pixel_size| is between |lo| and |hi|. + CGFloat lo = 0; + CGFloat hi = point_size; + while (actual_pixel_size < target_pixel_size) { + lo = hi; + hi *= 2; + ct_font.reset(CTFontCreateWithName(font_name_cf_string, hi, NULL)); + actual_pixel_size = GetCTFontPixelSize(ct_font); + } + + // Now, bisect to find the right size. + while (lo < hi) { + point_size = (hi - lo) * 0.5 + lo; + ct_font.reset(CTFontCreateWithName(font_name_cf_string, point_size, NULL)); + actual_pixel_size = GetCTFontPixelSize(ct_font); + if (std::fabs(actual_pixel_size - target_pixel_size) < kEpsilon) + break; + if (target_pixel_size > actual_pixel_size) + lo = point_size; + else + hi = point_size; + } + + return ct_font.release(); +} + +} // namespace + +namespace gfx { + +RenderTextMac::RenderTextMac() : common_baseline_(0), runs_valid_(false) { +} + +RenderTextMac::~RenderTextMac() { +} + +base::i18n::TextDirection RenderTextMac::GetTextDirection() { + return base::i18n::LEFT_TO_RIGHT; +} + +Size RenderTextMac::GetStringSize() { + EnsureLayout(); + return string_size_; +} + +int RenderTextMac::GetBaseline() { + EnsureLayout(); + return common_baseline_; +} + +SelectionModel RenderTextMac::FindCursorPosition(const Point& point) { + // TODO(asvitkine): Implement this. http://crbug.com/131618 + return SelectionModel(); +} + +std::vector<RenderText::FontSpan> RenderTextMac::GetFontSpansForTesting() { + EnsureLayout(); + if (!runs_valid_) + ComputeRuns(); + + std::vector<RenderText::FontSpan> spans; + for (size_t i = 0; i < runs_.size(); ++i) { + gfx::Font font(runs_[i].font_name, runs_[i].text_size); + const CFRange cf_range = CTRunGetStringRange(runs_[i].ct_run); + const ui::Range range(cf_range.location, + cf_range.location + cf_range.length); + spans.push_back(RenderText::FontSpan(font, range)); + } + + return spans; +} + +SelectionModel RenderTextMac::AdjacentCharSelectionModel( + const SelectionModel& selection, + VisualCursorDirection direction) { + // TODO(asvitkine): Implement this. http://crbug.com/131618 + return SelectionModel(); +} + +SelectionModel RenderTextMac::AdjacentWordSelectionModel( + const SelectionModel& selection, + VisualCursorDirection direction) { + // TODO(asvitkine): Implement this. http://crbug.com/131618 + return SelectionModel(); +} + +void RenderTextMac::GetGlyphBounds(size_t index, + ui::Range* xspan, + int* height) { + // TODO(asvitkine): Implement this. http://crbug.com/131618 +} + +std::vector<Rect> RenderTextMac::GetSubstringBounds(ui::Range range) { + // TODO(asvitkine): Implement this. http://crbug.com/131618 + return std::vector<Rect>(); +} + +bool RenderTextMac::IsCursorablePosition(size_t position) { + // TODO(asvitkine): Implement this. http://crbug.com/131618 + return false; +} + +void RenderTextMac::ResetLayout() { + line_.reset(); + runs_.clear(); + runs_valid_ = false; +} + +void RenderTextMac::EnsureLayout() { + if (line_.get()) + return; + runs_.clear(); + runs_valid_ = false; + + const Font& font = GetFont(); + CTFontRef ct_font = + CreateCTFontWithPixelSize(font.GetFontName(), font.GetFontSize()); + + const void* keys[] = { kCTFontAttributeName }; + const void* values[] = { ct_font }; + base::mac::ScopedCFTypeRef<CFDictionaryRef> attributes( + CFDictionaryCreate(NULL, keys, values, arraysize(keys), NULL, NULL)); + + base::mac::ScopedCFTypeRef<CFStringRef> cf_text( + base::SysUTF16ToCFStringRef(text())); + base::mac::ScopedCFTypeRef<CFAttributedStringRef> attr_text( + CFAttributedStringCreate(NULL, cf_text, attributes)); + base::mac::ScopedCFTypeRef<CFMutableAttributedStringRef> attr_text_mutable( + CFAttributedStringCreateMutableCopy(NULL, 0, attr_text)); + + ApplyStyles(attr_text_mutable, ct_font); + line_.reset(CTLineCreateWithAttributedString(attr_text_mutable)); + + CGFloat ascent = 0; + CGFloat descent = 0; + CGFloat leading = 0; + // TODO(asvitkine): Consider using CTLineGetBoundsWithOptions() on 10.8+. + double width = CTLineGetTypographicBounds(line_, &ascent, &descent, &leading); + string_size_ = Size(width, ascent + descent + leading); + common_baseline_ = ascent; +} + +void RenderTextMac::DrawVisualText(Canvas* canvas) { + DCHECK(line_); + if (!runs_valid_) + ComputeRuns(); + + internal::SkiaTextRenderer renderer(canvas); + ApplyFadeEffects(&renderer); + ApplyTextShadows(&renderer); + + for (size_t i = 0; i < runs_.size(); ++i) { + const TextRun& run = runs_[i]; + renderer.SetForegroundColor(run.foreground); + renderer.SetTextSize(run.text_size); + renderer.SetFontFamilyWithStyle(run.font_name, run.font_style); + renderer.DrawPosText(&run.glyph_positions[0], &run.glyphs[0], + run.glyphs.size()); + renderer.DrawDecorations(run.origin.x(), run.origin.y(), run.width, + run.style); + } +} + +RenderTextMac::TextRun::TextRun() + : ct_run(NULL), + origin(SkPoint::Make(0, 0)), + width(0), + font_style(Font::NORMAL), + text_size(0), + foreground(SK_ColorBLACK) { +} + +RenderTextMac::TextRun::~TextRun() { +} + +void RenderTextMac::ApplyStyles(CFMutableAttributedStringRef attr_string, + CTFontRef font) { + // https://developer.apple.com/library/mac/#documentation/Carbon/Reference/CoreText_StringAttributes_Ref/Reference/reference.html + for (size_t i = 0; i < style_ranges().size(); ++i) { + const StyleRange& style = style_ranges()[i]; + const CFRange range = CFRangeMake(style.range.start(), + style.range.length()); + + // Note: CFAttributedStringSetAttribute() does not appear to retain the + // values passed in, as can be verified via CFGetRetainCount(). + // + // TODO(asvitkine): The attributed string appears to hold weak refs to these + // objects (it does not release them either), so we need to keep track of + // them ourselves and release them at an appropriate time. + + CGColorRef foreground = gfx::SkColorToCGColorRef(style.foreground); + CFAttributedStringSetAttribute(attr_string, range, + kCTForegroundColorAttributeName, + foreground); + + if (style.underline) { + CTUnderlineStyle value = kCTUnderlineStyleSingle; + CFNumberRef underline = CFNumberCreate(NULL, kCFNumberSInt32Type, &value); + CFAttributedStringSetAttribute(attr_string, range, + kCTUnderlineStyleAttributeName, + underline); + } + + if (style.font_style & (Font::BOLD | Font::ITALIC)) { + int traits = 0; + if (style.font_style & Font::BOLD) + traits |= kCTFontBoldTrait; + if (style.font_style & Font::ITALIC) + traits |= kCTFontItalicTrait; + CTFontRef styled_font = + CTFontCreateCopyWithSymbolicTraits(font, 0.0, NULL, traits, traits); + // TODO(asvitkine): Handle |styled_font| == NULL case better. + if (styled_font) { + CFAttributedStringSetAttribute(attr_string, range, kCTFontAttributeName, + styled_font); + } + } + } +} + +void RenderTextMac::ComputeRuns() { + DCHECK(line_); + + CFArrayRef ct_runs = CTLineGetGlyphRuns(line_); + const CFIndex ct_runs_count = CFArrayGetCount(ct_runs); + + Point offset(GetTextOrigin()); + // Skia will draw glyphs with respect to the baseline. + offset.Offset(0, common_baseline_); + + const SkScalar x = SkIntToScalar(offset.x()); + const SkScalar y = SkIntToScalar(offset.y()); + SkPoint run_origin = SkPoint::Make(offset.x(), offset.y()); + + const CFRange empty_cf_range = CFRangeMake(0, 0); + for (CFIndex i = 0; i < ct_runs_count; ++i) { + CTRunRef ct_run = + base::mac::CFCast<CTRunRef>(CFArrayGetValueAtIndex(ct_runs, i)); + const size_t glyph_count = CTRunGetGlyphCount(ct_run); + const double run_width = + CTRunGetTypographicBounds(ct_run, empty_cf_range, NULL, NULL, NULL); + if (glyph_count == 0) { + run_origin.offset(run_width, 0); + continue; + } + + runs_.push_back(TextRun()); + TextRun* run = &runs_.back(); + run->ct_run = ct_run; + run->origin = run_origin; + run->width = run_width; + run->glyphs.resize(glyph_count); + CTRunGetGlyphs(ct_run, empty_cf_range, &run->glyphs[0]); + // CTRunGetGlyphs() sometimes returns glyphs with value 65535 and zero + // width (this has been observed at the beginning of a string containing + // Arabic content). Passing these to Skia will trigger an assertion; + // instead set their values to 0. + for (size_t glyph = 0; glyph < glyph_count; glyph++) { + if (run->glyphs[glyph] == 65535) + run->glyphs[glyph] = 0; + } + + run->glyph_positions.resize(glyph_count); + const CGPoint* positions_ptr = CTRunGetPositionsPtr(ct_run); + std::vector<CGPoint> positions; + if (positions_ptr == NULL) { + positions.resize(glyph_count); + CTRunGetPositions(ct_run, empty_cf_range, &positions[0]); + positions_ptr = &positions[0]; + } + for (size_t glyph = 0; glyph < glyph_count; glyph++) { + SkPoint* point = &run->glyph_positions[glyph]; + point->set(x + SkDoubleToScalar(positions_ptr[glyph].x), + y + SkDoubleToScalar(positions_ptr[glyph].y)); + } + + // TODO(asvitkine): Style boundaries are not necessarily per-run. Handle + // this better. + CFDictionaryRef attributes = CTRunGetAttributes(ct_run); + CTFontRef ct_font = + base::mac::GetValueFromDictionary<CTFontRef>(attributes, + kCTFontAttributeName); + base::mac::ScopedCFTypeRef<CFStringRef> font_name_ref( + CTFontCopyFamilyName(ct_font)); + run->font_name = base::SysCFStringRefToUTF8(font_name_ref); + run->text_size = GetCTFontPixelSize(ct_font); + + CTFontSymbolicTraits traits = CTFontGetSymbolicTraits(ct_font); + if (traits & kCTFontBoldTrait) + run->font_style |= Font::BOLD; + if (traits & kCTFontItalicTrait) + run->font_style |= Font::ITALIC; + + const CGColorRef foreground = + base::mac::GetValueFromDictionary<CGColorRef>( + attributes, kCTForegroundColorAttributeName); + if (foreground) + run->foreground = gfx::CGColorRefToSkColor(foreground); + + const CFNumberRef underline = + base::mac::GetValueFromDictionary<CFNumberRef>( + attributes, kCTUnderlineStyleAttributeName); + CTUnderlineStyle value = kCTUnderlineStyleNone; + if (underline && CFNumberGetValue(underline, kCFNumberSInt32Type, &value)) + run->style.underline = (value == kCTUnderlineStyleSingle); + + run_origin.offset(run_width, 0); + } + runs_valid_ = true; +} + +RenderText* RenderText::CreateInstance() { + return new RenderTextMac; +} + +} // namespace gfx diff --git a/ui/gfx/render_text_mac.h b/ui/gfx/render_text_mac.h new file mode 100644 index 0000000..ccd9c75 --- /dev/null +++ b/ui/gfx/render_text_mac.h @@ -0,0 +1,96 @@ +// 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. + +#ifndef UI_GFX_RENDER_TEXT_MAC_H_ +#define UI_GFX_RENDER_TEXT_MAC_H_ + +#include <ApplicationServices/ApplicationServices.h> + +#include <string> +#include <vector> + +#include "base/mac/scoped_cftyperef.h" +#include "ui/gfx/render_text.h" + +namespace gfx { + +// RenderTextMac is the Mac implementation of RenderText that uses CoreText for +// layout and Skia for drawing. +// +// Note: The current implementation only supports drawing and sizing the text, +// but not text selection or cursor movement. +class RenderTextMac : public RenderText { + public: + RenderTextMac(); + virtual ~RenderTextMac(); + + // Overridden from RenderText: + virtual base::i18n::TextDirection GetTextDirection() OVERRIDE; + virtual Size GetStringSize() OVERRIDE; + virtual int GetBaseline() OVERRIDE; + virtual SelectionModel FindCursorPosition(const Point& point) OVERRIDE; + virtual std::vector<FontSpan> GetFontSpansForTesting() OVERRIDE; + + protected: + // Overridden from RenderText: + virtual SelectionModel AdjacentCharSelectionModel( + const SelectionModel& selection, + VisualCursorDirection direction) OVERRIDE; + virtual SelectionModel AdjacentWordSelectionModel( + const SelectionModel& selection, + VisualCursorDirection direction) OVERRIDE; + virtual void GetGlyphBounds(size_t index, + ui::Range* xspan, + int* height) OVERRIDE; + virtual std::vector<Rect> GetSubstringBounds(ui::Range range) OVERRIDE; + virtual bool IsCursorablePosition(size_t position) OVERRIDE; + virtual void ResetLayout() OVERRIDE; + virtual void EnsureLayout() OVERRIDE; + virtual void DrawVisualText(Canvas* canvas) OVERRIDE; + + private: + struct TextRun { + CTRunRef ct_run; + SkPoint origin; + std::vector<uint16> glyphs; + std::vector<SkPoint> glyph_positions; + SkScalar width; + std::string font_name; + int font_style; + SkScalar text_size; + SkColor foreground; + StyleRange style; + + TextRun(); + ~TextRun(); + }; + + // Applies RenderText styles to |attr_string| with the given |ct_font|. + void ApplyStyles(CFMutableAttributedStringRef attr_string, CTFontRef ct_font); + + // Updates |runs_| based on |line_| and sets |runs_valid_| to true. + void ComputeRuns(); + + // The Core Text line of text. Created by |EnsureLayout()|. + base::mac::ScopedCFTypeRef<CTLineRef> line_; + + // Visual dimensions of the text. Computed by |EnsureLayout()|. + Size string_size_; + + // Common baseline for this line of text. Computed by |EnsureLayout()|. + SkScalar common_baseline_; + + // Visual text runs. Only valid if |runs_valid_| is true. Computed by + // |ComputeRuns()|. + std::vector<TextRun> runs_; + + // Indicates that |runs_| are valid, set by |ComputeRuns()|. + bool runs_valid_; + + DISALLOW_COPY_AND_ASSIGN(RenderTextMac); +}; + +} // namespace gfx + +#endif // UI_GFX_RENDER_TEXT_MAC_H_ diff --git a/ui/gfx/render_text_unittest.cc b/ui/gfx/render_text_unittest.cc index a8ca541..bd0b24c 100644 --- a/ui/gfx/render_text_unittest.cc +++ b/ui/gfx/render_text_unittest.cc @@ -307,6 +307,9 @@ TEST_F(RenderTextTest, StyleRangesAdjust) { EXPECT_EQ(ui::Range(0, 1), render_text->style_ranges()[0].range); } +// TODO(asvitkine): Cursor movements tests disabled on Mac because RenderTextMac +// does not implement this yet. http://crbug.com/131618 +#if !defined(OS_MACOSX) void TestVisualCursorMotionInObscuredField(RenderText* render_text, const string16& text, bool select) { @@ -797,6 +800,7 @@ TEST_F(RenderTextTest, SelectAll) { render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false); EXPECT_EQ(ui::Range(4), render_text->selection()); } +#endif // !defined(OS_MACOSX) // TODO(xji): Make these work on Windows. #if defined(OS_LINUX) @@ -968,6 +972,9 @@ TEST_F(RenderTextTest, StringSizeSanity) { EXPECT_GT(string_size.height(), 0); } +// TODO(asvitkine): This test fails because PlatformFontMac uses point font +// sizes instead of pixel sizes like other implementations. +#if !defined(OS_MACOSX) TEST_F(RenderTextTest, StringSizeEmptyString) { const Font font; scoped_ptr<RenderText> render_text(RenderText::CreateInstance()); @@ -980,6 +987,7 @@ TEST_F(RenderTextTest, StringSizeEmptyString) { render_text->SetText(UTF8ToUTF16(" ")); EXPECT_EQ(font.GetHeight(), render_text->GetStringSize().height()); } +#endif // !defined(OS_MACOSX) TEST_F(RenderTextTest, StringSizeBoldWidth) { scoped_ptr<RenderText> render_text(RenderText::CreateInstance()); @@ -1155,6 +1163,9 @@ TEST_F(RenderTextTest, SameFontForParentheses) { } } +// TODO(asvitkine): Cursor movements tests disabled on Mac because RenderTextMac +// does not implement this yet. http://crbug.com/131618 +#if !defined(OS_MACOSX) TEST_F(RenderTextTest, DisplayRectShowsCursorLTR) { scoped_ptr<RenderText> render_text(RenderText::CreateInstance()); render_text->SetText(WideToUTF16(L"abcdefghijklmnopqrstuvwxzyabcdefg")); @@ -1266,5 +1277,6 @@ TEST_F(RenderTextTest, DisplayRectShowsCursorRTL) { SetRTL(was_rtl); EXPECT_EQ(was_rtl, base::i18n::IsRTL()); } +#endif // !defined(OS_MACOSX) } // namespace gfx @@ -407,6 +407,8 @@ 'gfx/rect_base_impl.h', 'gfx/render_text.cc', 'gfx/render_text.h', + 'gfx/render_text_mac.cc', + 'gfx/render_text_mac.h', 'gfx/render_text_linux.cc', 'gfx/render_text_linux.h', 'gfx/render_text_win.cc', @@ -665,14 +667,6 @@ ], }, }], - ['OS=="android"', { - 'sources!': [ - 'gfx/pango_util.h', - 'gfx/pango_util.cc', - 'gfx/platform_font_pango.h', - 'gfx/platform_font_pango.cc', - ], - }], ['use_x11==1', { 'all_dependent_settings': { 'ldflags': [ @@ -695,16 +689,6 @@ 'base/x/events_x.cc', ], }], - ['toolkit_views==0 and use_canvas_skia==0', { - 'sources!': [ - 'gfx/render_text.cc', - 'gfx/render_text.h', - 'gfx/render_text_linux.cc', - 'gfx/render_text_linux.h', - 'gfx/render_text_win.cc', - 'gfx/render_text_win.h', - ], - }], ['OS=="android"', { 'sources!': [ 'base/touch/touch_factory.cc', @@ -715,6 +699,12 @@ 'gfx/platform_font_pango.h', ], }], + ['OS=="android" or OS=="ios"', { + 'sources!': [ + 'gfx/render_text.cc', + 'gfx/render_text.h', + ], + }], ['OS=="linux"', { 'libraries': [ '-ldl', diff --git a/ui/ui_unittests.gypi b/ui/ui_unittests.gypi index f921397..4982add 100644 --- a/ui/ui_unittests.gypi +++ b/ui/ui_unittests.gypi @@ -198,7 +198,7 @@ '../build/linux/system.gyp:gtk', ], }], - ['toolkit_views==0 and use_canvas_skia==0', { + ['OS=="android" or OS=="ios"', { 'sources!': [ 'gfx/render_text_unittest.cc', ], |