jdk-sandbox: comparison jdk/src/share/classes/java/awt/Font.java

equal deleted inserted replaced

-:af4853bc7e87
+:1ae5a9028dd4
 import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.peer.FontPeer;
 import java.io.*;
 import java.lang.ref.SoftReference;
+import java.security.AccessController;
+import java.security.PrivilegedExceptionAction;
 import java.text.AttributedCharacterIterator.Attribute;
 import java.text.CharacterIterator;
 import java.text.StringCharacterIterator;
 import java.util.HashMap;
 import java.util.Hashtable;
 import sun.font.AttributeMap;
 import sun.font.AttributeValues;
 import sun.font.EAttribute;
 import sun.font.CompositeFont;
+import sun.font.CreatedFontTracker;
 import sun.font.Font2D;
 import sun.font.Font2DHandle;
 import sun.font.FontManager;
 import sun.font.GlyphLayout;
 import sun.font.FontLineMetrics;
 }
 }
 }
 /* used to implement Font.createFont */
-private Font(File fontFile, int fontFormat, boolean isCopy)
+private Font(File fontFile, int fontFormat,
+boolean isCopy, CreatedFontTracker tracker)
 throws FontFormatException {
 this.createdFont = true;
 /* Font2D instances created by this method track their font file
 * so that when the Font2D is GC'd it can also remove the file.
 */
 this.font2DHandle =
-FontManager.createFont2D(fontFile, fontFormat, isCopy).handle;
+FontManager.createFont2D(fontFile, fontFormat,
+isCopy, tracker).handle;
 this.name = this.font2DHandle.font2D.getFontName(Locale.getDefault());
 this.style = Font.PLAIN;
 this.size = 1;
 this.pointSize = 1f;
 }
 return font;
 }
 return new Font(attributes);
+}
+/**
+* Used with the byte count tracker for fonts created from streams.
+* If a thread can create temp files anyway, no point in counting
+* font bytes.
+*/
+private static boolean hasTempPermission() {
+if (System.getSecurityManager() == null) {
+return true;
+}
+File f = null;
+boolean hasPerm = false;
+try {
+f = File.createTempFile("+~JT", ".tmp", null);
+f.delete();
+f = null;
+hasPerm = true;
+} catch (Throwable t) {
+/* inc. any kind of SecurityException */
+}
+return hasPerm;
 }
 /**
 * Returns a new <code>Font</code> using the specified font type
 * and input data.  The new <code>Font</code> is
 if (fontFormat != Font.TRUETYPE_FONT &&
 fontFormat != Font.TYPE1_FONT) {
 throw new IllegalArgumentException ("font format not recognized");
 }
-final InputStream fStream = fontStream;
+boolean copiedFontData = false;
-Object ret = java.security.AccessController.doPrivileged(
-new java.security.PrivilegedAction() {
+try {
-public Object run() {
+final File tFile = AccessController.doPrivileged(
-File tFile = null;
+new PrivilegedExceptionAction<File>() {
-FileOutputStream outStream = null;
+public File run() throws IOException {
-try {
+return File.createTempFile("+~JF", ".tmp", null);
-tFile = File.createTempFile("+~JF", ".tmp", null);
+}
-/* Temp file deleted by font shutdown hook */
+}
-BufferedInputStream inStream =
+);
-new BufferedInputStream(fStream);
-outStream = new FileOutputStream(tFile);
+int totalSize = 0;
-int bytesRead = 0;
+CreatedFontTracker tracker = null;
-int bufSize = 8192;
+try {
-byte [] buf = new byte[bufSize];
+final OutputStream outStream =
-while (bytesRead != -1) {
+AccessController.doPrivileged(
-try {
+new PrivilegedExceptionAction<OutputStream>() {
-bytesRead = inStream.read(buf, 0, bufSize);
+public OutputStream run() throws IOException {
-} catch (Throwable t) {
+return new FileOutputStream(tFile);
-throw new IOException();
+}
 }
-if (bytesRead != -1) {
+);
-outStream.write(buf, 0, bytesRead);
+if (!hasTempPermission()) {
-}
+tracker = CreatedFontTracker.getTracker();
 }
-/* don't close the input stream */
+try {
-outStream.close();
+byte[] buf = new byte[8192];
-} catch (IOException e) {
+for (;;) {
-if (outStream != null) {
+int bytesRead = fontStream.read(buf);
-try {
+if (bytesRead < 0) {
-outStream.close();
+break;
-} catch (Exception e1) {
+}
-}
+if (tracker != null) {
-}
+if (totalSize+bytesRead > tracker.MAX_FILE_SIZE) {
-if (tFile != null) {
+throw new IOException("File too big.");
-try {
+}
-tFile.delete();
+if (totalSize+tracker.getNumBytes() >
-}  catch (Exception e2) {
+tracker.MAX_TOTAL_BYTES)
-}
+{
-}
+throw new IOException("Total files too big.");
-return e;
+}
-}
+totalSize += bytesRead;
-return tFile;
+tracker.addBytes(bytesRead);
 }
-});
+outStream.write(buf, 0, bytesRead);
+}
-if (ret instanceof File) {
+/* don't close the input stream */
-return new Font((File)ret, fontFormat, true);
+} finally {
-} else if (ret instanceof IOException) {
+outStream.close();
-throw (IOException)ret;
+}
-} else {
+/* After all references to a Font2D are dropped, the file
-throw new FontFormatException("Couldn't access font stream");
+* will be removed. To support long-lived AppContexts,
+* we need to then decrement the byte count by the size
+* of the file.
+* If the data isn't a valid font, the implementation will
+* delete the tmp file and decrement the byte count
+* in the tracker object before returning from the
+* constructor, so we can set 'copiedFontData' to true here
+* without waiting for the results of that constructor.
+*/
+copiedFontData = true;
+Font font = new Font(tFile, fontFormat, true, tracker);
+return font;
+} finally {
+if (!copiedFontData) {
+if (tracker != null) {
+tracker.subBytes(totalSize);
+}
+AccessController.doPrivileged(
+new PrivilegedExceptionAction<Void>() {
+public Void run() {
+tFile.delete();
+return null;
+}
+}
+);
+}
+}
+} catch (Throwable t) {
+if (t instanceof FontFormatException) {
+throw (FontFormatException)t;
+}
+if (t instanceof IOException) {
+throw (IOException)t;
+}
+Throwable cause = t.getCause();
+if (cause instanceof FontFormatException) {
+throw (FontFormatException)cause;
+}
+throw new IOException("Problem reading font data.");
 }
 }
 /**
 * Returns a new <code>Font</code> using the specified font type
 * @see GraphicsEnvironment#registerFont(Font)
 * @since 1.5
 */
 public static Font createFont(int fontFormat, File fontFile)
 throws java.awt.FontFormatException, java.io.IOException {
+fontFile = new File(fontFile.getPath());
 if (fontFormat != Font.TRUETYPE_FONT &&
 fontFormat != Font.TYPE1_FONT) {
 throw new IllegalArgumentException ("font format not recognized");
 }
 SecurityManager sm = System.getSecurityManager();
 sm.checkPermission(filePermission);
 }
 if (!fontFile.canRead()) {
 throw new IOException("Can't read " + fontFile);
 }
-return new Font(fontFile, fontFormat, false);
+return new Font(fontFile, fontFormat, false, null);
 }
 /**
 * Returns a copy of the transform associated with this
 * <code>Font</code>.  This transform is not necessarily the one

changeset 2624	1ae5a9028dd4
parent 715	f16baef3a20e
parent 2606	09ad5edb5330
child 3017	217bf37bb0ea