Merge 105393 - [Chromium] Random characters got rendered as empty boxes or with incorrect glyphs ...

Source/WebCore/platform/graphics/chromium/GlyphPageTreeNodeChromiumWin.cpp

 /*
- * Copyright (c) 2008, 2009 Google Inc. All rights reserved.
+ * Copyright (c) 2008, 2009, 2012 Google Inc. All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  * 
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
@@ skipping 29 matching lines @@
 namespace WebCore {
 
 // Fills one page of font data pointers with 0 to indicate that there
 // are no glyphs for the characters.
 static void fillEmptyGlyphs(GlyphPage* page)
 {
     for (int i = 0; i < GlyphPage::size; ++i)
         page->setGlyphDataForIndex(i, 0, 0);
 }
 
-// Lazily initializes space glyph
-static Glyph initSpaceGlyph(HDC dc, Glyph* spaceGlyph)
+// Convert characters to glyph ids by GetGlyphIndices(), during which, we
+// ensure the font is loaded in memory to make it work in a sandboxed process.
+static bool getGlyphIndices(HFONT font, HDC dc, const UChar* characters, unsigned charactersLength, WORD* glyphBuffer, DWORD flag)
 {
-    if (*spaceGlyph)
-        return *spaceGlyph;
+    if (GetGlyphIndices(dc, characters, charactersLength, glyphBuffer, flag) != GDI_ERROR)
+        return true;
+    if (PlatformSupport::ensureFontLoaded(font)) {
+        if (GetGlyphIndices(dc, characters, charactersLength, glyphBuffer, flag) != GDI_ERROR)
+            return true;
+        // FIXME: Handle gracefully the error if this call also fails.
+        // See http://crbug.com/6401
+        LOG_ERROR("Unable to get the glyph indices after second attempt");
+    }
+    return false;
+}
 
+// Initializes space glyph
+static bool initSpaceGlyph(HFONT font, HDC dc, Glyph* spaceGlyph)
+{
     static wchar_t space = ' ';
-    GetGlyphIndices(dc, &space, 1, spaceGlyph, 0);
-    return *spaceGlyph;
+    return getGlyphIndices(font, dc, &space, 1, spaceGlyph, 0);
 }
 
 // Fills |length| glyphs starting at |offset| in a |page| in the Basic 
 // Multilingual Plane (<= U+FFFF). The input buffer size should be the
 // same as |length|. We can use the standard Windows GDI functions here. 
 // Returns true if any glyphs were found.
 static bool fillBMPGlyphs(unsigned offset,
                           unsigned length,
                           UChar* buffer,
                           GlyphPage* page,
-                          const SimpleFontData* fontData,
-                          bool recurse)
+                          const SimpleFontData* fontData)
 {
     HDC dc = GetDC((HWND)0);
     HGDIOBJ oldFont = SelectObject(dc, fontData->platformData().hfont());
 
     TEXTMETRIC tm = {0};
     if (!GetTextMetrics(dc, &tm)) {
-        SelectObject(dc, oldFont);
-        ReleaseDC(0, dc);
+        if (PlatformSupport::ensureFontLoaded(fontData->platformData().hfont())) {
+            if (!GetTextMetrics(dc, &tm)) {
+                // FIXME: Handle gracefully the error if this call also fails.
+                // See http://crbug.com/6401
+                LOG_ERROR("Unable to get the text metrics after second attempt");
 
-        if (recurse) {
-            if (PlatformSupport::ensureFontLoaded(fontData->platformData().hfont()))
-                return fillBMPGlyphs(offset, length, buffer, page, fontData, false);
-
-            fillEmptyGlyphs(page);
-            return false;
+                SelectObject(dc, oldFont);
+                ReleaseDC(0, dc);
+                fillEmptyGlyphs(page);
+                return false;
+            }
         } else {
-            // FIXME: Handle gracefully the error if this call also fails.
-            // See http://crbug.com/6401
-            LOG_ERROR("Unable to get the text metrics after second attempt");
+            SelectObject(dc, oldFont);
+            ReleaseDC(0, dc);
             fillEmptyGlyphs(page);
             return false;
         }
     }
 
     // FIXME: GetGlyphIndices() sets each item of localGlyphBuffer[]
     // with the one of the values listed below.
     //  * With the GGI_MARK_NONEXISTING_GLYPHS flag
     //    + If the font has a glyph available for the character,
     //      localGlyphBuffer[i] > 0x0.
@@ skipping 19 matching lines @@
     // when call GetGlyphIndices without flag GGI_MARK_NONEXISTING_GLYPHS,
     // because the corresponding glyph index is set as 0x20 when current font
     // does not have glyphs available for the character. According a blog post
     // http://blogs.msdn.com/michkap/archive/2006/06/28/649791.aspx
     // I think we should switch to the way about calling GetGlyphIndices with
     // flag GGI_MARK_NONEXISTING_GLYPHS, it should be OK according the
     // description of MSDN.
     // Also according to Jungshik and Hironori's suggestion and modification
     // we treat turetype and raster Font as different way when windows version
     // is less than Vista.
-    GetGlyphIndices(dc, buffer, length, localGlyphBuffer, GGI_MARK_NONEXISTING_GLYPHS);
+    if (!getGlyphIndices(fontData->platformData().hfont(), dc, buffer, length, localGlyphBuffer, GGI_MARK_NONEXISTING_GLYPHS)) {
+        SelectObject(dc, oldFont);
+        ReleaseDC(0, dc);
+        fillEmptyGlyphs(page);
+        return false;
+    }
 
     // Copy the output to the GlyphPage
     bool haveGlyphs = false;
     int invalidGlyph = 0xFFFF;
     const DWORD cffTableTag = 0x20464643; // 4-byte identifier for OpenType CFF table ('CFF ').
     if ((windowsVersion() < WindowsVista) && !(tm.tmPitchAndFamily & TMPF_TRUETYPE) && (GetFontData(dc, cffTableTag, 0, 0, 0) == GDI_ERROR))
         invalidGlyph = 0x1F;
 
     Glyph spaceGlyph = 0;  // Glyph for a space. Lazily filled.
+    bool spaceGlyphInitialized = false;
 
     for (unsigned i = 0; i < length; i++) {
         UChar c = buffer[i];
         Glyph glyph = localGlyphBuffer[i];
         const SimpleFontData* glyphFontData = fontData;
         // When this character should be a space, we ignore whatever the font
         // says and use a space. Otherwise, if fonts don't map one of these
         // space or zero width glyphs, we will get a box.
         if (Font::treatAsSpace(c)) {
             // Hard code the glyph indices for characters that should be
             // treated like spaces.
-            glyph = initSpaceGlyph(dc, &spaceGlyph);
+            if (!spaceGlyphInitialized) {
+                // If initSpaceGlyph fails, spaceGlyph stays 0 (= glyph is not present).
+                initSpaceGlyph(fontData->platformData().hfont(), dc, &spaceGlyph);
+                spaceGlyphInitialized = true;
+            }
+            glyph = spaceGlyph;
         } else if (glyph == invalidGlyph) {
             // WebKit expects both the glyph index and FontData
             // pointer to be 0 if the glyph is not present
             glyph = 0;
             glyphFontData = 0;
         } else
             haveGlyphs = true;
         page->setGlyphDataForCharacter(offset + i, glyph, glyphFontData);
     }
 
@@ skipping 52 matching lines @@
 // We're supposed to return true if there are any glyphs in the range
 // specified by |offset| and |length| in  our font,
 // false if there are none.
 bool GlyphPage::fill(unsigned offset, unsigned length, UChar* characterBuffer,
                      unsigned bufferLength, const SimpleFontData* fontData)
 {
     // We have to handle BMP and non-BMP characters differently.
     // FIXME: Add assertions to make sure that buffer is entirely in BMP
     // or entirely in non-BMP. 
     if (bufferLength == length)
-        return fillBMPGlyphs(offset, length, characterBuffer, this, fontData, true);
+        return fillBMPGlyphs(offset, length, characterBuffer, this, fontData);
 
     if (bufferLength == 2 * length) {
         // A non-BMP input buffer will be twice as long as output glyph buffer
         // because each character in the non-BMP input buffer will be 
         // represented by a surrogate pair (two UChar's).
         return fillNonBMPGlyphs(offset, length, characterBuffer, this, fontData);
     }
 
     ASSERT_NOT_REACHED();
     return false;
 }
 
 }  // namespace WebCore