Issue 5231 - Use Java 7 features

adblockplussbrowser/src/org/adblockplus/sbrowser/contentblocker/engine/Subscription.java

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2016 Eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 10 matching lines @@
 import java.io.BufferedOutputStream;
 import java.io.BufferedReader;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.StringReader;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
@@ skipping 18 matching lines @@
   public static final String KEY_UPDATE_TIMESTAMP = "_update_timestamp";
   public static final String KEY_TRIED_UPDATE_TIMESTAMP = "_tried_update_timestamp";
   public static final String KEY_DOWNLOAD_COUNT = "_download_count";
   public static final String KEY_ENABLED = "_enabled";
   public static final String KEY_HAS_FILTERS = "_has_filters";
   public static final String KEY_META_HASH = "_meta_hash";
 
   public static final long MINIMAL_DOWNLOAD_INTERVAL = Engine.MILLIS_PER_HOUR / 4;
   public static final long DOWNLOAD_RETRY_INTERVAL = Engine.MILLIS_PER_HOUR;
 
-  private static final HashSet<String> ALLOWED_META_KEYS = new HashSet<String>();
+  private static final HashSet<String> ALLOWED_META_KEYS = new HashSet<>();
   private static final Locale LOCALE_EN = Locale.ENGLISH;
 
   private final long updateInterval = Engine.MILLIS_PER_DAY
       + (long) (Engine.MILLIS_PER_HOUR * 8. * Math.random());
 
   /**
    * List of meta keys that are allowed to import from a downloaded
    * subscription.
    */
   private static final String[] ALLOWED_META_KEYS_ARRAY =
   {
       "checksum", KEY_VERSION, KEY_TITLE, "last modified", "expires", "homepage", "licence"
   };
 
   private final URL url;
   private final Type type;
-  private final HashMap<String, String> meta = new HashMap<String, String>();
-  private final HashSet<String> filters = new HashSet<String>();
+  private final HashMap<String, String> meta = new HashMap<>();
+  private final HashSet<String> filters = new HashSet<>();
 
   private boolean metaDataValid = true;
   private boolean filtersValid = true;
 
   static
   {
     for (final String s : ALLOWED_META_KEYS_ARRAY)
     {
       ALLOWED_META_KEYS.add(s);
     }
@@ skipping 266 matching lines @@
       {
         sb.append('0');
       }
       sb.append(Integer.toHexString(value));
     }
     return sb.toString();
   }
 
   private static String createMetaDataHash(final HashMap<String, String> meta) throws IOException
   {
-    final ArrayList<String> keyValues = new ArrayList<String>();
+    final ArrayList<String> keyValues = new ArrayList<>();
     for (final Entry<String, String> e : meta.entrySet())
     {
       if (!KEY_META_HASH.equals(e.getKey()))
       {
         keyValues.add(e.getKey() + ":" + e.getValue());
       }
     }
     return createFilterHash(keyValues);
   }
 
   private static String createFilterHash(List<String> filters) throws IOException
   {
     try
     {
       final MessageDigest md5 = MessageDigest.getInstance("MD5");
       Collections.sort(filters);
       for (final String filter : filters)
       {
-        md5.update(filter.getBytes(Engine.CHARSET_UTF_8));
+        md5.update(filter.getBytes(StandardCharsets.UTF_8));
       }
       return byteArrayToHexString(md5.digest());
     }
     catch (final NoSuchAlgorithmException e)
     {
       throw new IOException("MD5 is unavailable: " + e.getMessage(), e);
     }
   }
 
   public void serializeMetaData(final File metaFile) throws IOException
   {
     this.putMeta(KEY_META_HASH, createMetaDataHash(this.meta));
-    final DataOutputStream metaOut = new DataOutputStream(new GZIPOutputStream(
-        new BufferedOutputStream(new FileOutputStream(metaFile))));
-    try
+    try (final DataOutputStream metaOut = new DataOutputStream(new GZIPOutputStream(
+        new BufferedOutputStream(new FileOutputStream(metaFile)))))
     {
       metaOut.writeUTF(this.url != null ? this.url.toString() : "");
       metaOut.writeInt(this.meta.size());
       for (final Entry<String, String> e : this.meta.entrySet())
       {
         metaOut.writeUTF(e.getKey());
         metaOut.writeUTF(e.getValue());
       }
     }
-    finally
-    {
-      metaOut.close();
-    }
   }
 
   public void serializeFilters(final File filtersFile) throws IOException
   {
-    final DataOutputStream filtersOut = new DataOutputStream(new GZIPOutputStream(
-        new BufferedOutputStream(new FileOutputStream(filtersFile))));
-    try
+    try (final DataOutputStream filtersOut = new DataOutputStream(new GZIPOutputStream(
+        new BufferedOutputStream(new FileOutputStream(filtersFile)))))
     {
       filtersOut.writeInt(this.filters.size());
       filtersOut.writeUTF(createFilterHash(new ArrayList<String>(this.filters)));
       for (final String s : this.filters)
       {
-        final byte[] b = s.getBytes(Engine.CHARSET_UTF_8);
+        final byte[] b = s.getBytes(StandardCharsets.UTF_8);
         filtersOut.writeInt(b.length);
         filtersOut.write(b);
       }
     }
-    finally
-    {
-      filtersOut.close();
-    }
   }
 
   public void serializeSubscription(final File metaFile, final File filtersFile) throws IOException
   {
     this.serializeMetaData(metaFile);
     this.serializeFilters(filtersFile);
   }
 
   public static Subscription deserializeSubscription(final File metaFile)
   {
     Subscription sub = null;
-    DataInputStream in = null;
-    try
+    try (final DataInputStream in = new DataInputStream(new GZIPInputStream(new BufferedInputStream(
+        new FileInputStream(metaFile)))))
     {
-      in = new DataInputStream(new GZIPInputStream(new BufferedInputStream(
-          new FileInputStream(metaFile))));
       final String urlString = in.readUTF();
       sub = new Subscription(!TextUtils.isEmpty(urlString) ? new URL(urlString) : null);
       sub.metaDataValid = false;
       final int numMetaEntries = in.readInt();
       for (int i = 0; i < numMetaEntries; i++)
       {
         final String key = in.readUTF();
         final String value = in.readUTF();
         sub.meta.put(key, value);
       }
       sub.metaDataValid = createMetaDataHash(sub.meta).equals(sub.getMeta(KEY_META_HASH));
     }
     catch (Throwable t)
     {
       // We catch Throwable here in order to return whatever we could retrieve from the meta file
     }
-    finally
-    {
-      if (in != null)
-      {
-        try
-        {
-          in.close();
-        }
-        catch (IOException e)
-        {
-          // Ignored
-        }
-      }
-    }
     return sub;
   }
 
   public void deserializeFilters(final File filtersFile)
   {
     this.clearFilters();
     this.filtersValid = false;
-    DataInputStream in = null;
-    try
+    try (final DataInputStream in = new DataInputStream(new GZIPInputStream(new BufferedInputStream(
+        new FileInputStream(filtersFile)))))
     {
-      in = new DataInputStream(new GZIPInputStream(new BufferedInputStream(
-          new FileInputStream(filtersFile))));
       final int numFilters = in.readInt();
       final String filtersHash = in.readUTF();
       for (int i = 0; i < numFilters; i++)
       {
         final int length = in.readInt();
         final byte[] b = new byte[length];
         in.readFully(b);
-        this.filters.add(new String(b, Engine.CHARSET_UTF_8));
+        this.filters.add(new String(b, StandardCharsets.UTF_8));
       }
       this.filtersValid = createFilterHash(new ArrayList<String>(this.filters)).equals(
           filtersHash);
       Log.d(TAG, "Filters valid: " + this.filtersValid);
     }
     catch (Throwable t)
     {
       // We catch Throwable here in order to load whatever we could retrieve from the filters file
     }
-    finally
-    {
-      if (in != null)
-      {
-        try
-        {
-          in.close();
-        }
-        catch (IOException e)
-        {
-          // Ignored
-        }
-      }
-    }
   }
 
   /**
    * Adds the given string, which should be a single filter to this
    * subscription.
    *
    * @param input
    */
   public Subscription parseLine(String input)
   {
@@ skipping 30 matching lines @@
   {
     for (String line : lines)
     {
       this.parseLine(line);
     }
     return this;
   }
 
   public Subscription parseText(final String string)
   {
-    final BufferedReader r = new BufferedReader(new StringReader(string));
-    try
+    try (final BufferedReader r = new BufferedReader(new StringReader(string)))
     {
       for (String line = r.readLine(); line != null; line = r.readLine())
       {
         this.parseLine(line);
       }
-      r.close();
     }
     catch (final IOException e)
     {
       // ignored ... we're reading from a String
     }
     return this;
   }
 
   boolean updateSubscription(final int responseCode, final String text,
       final Map<String, String> httpHeaders, final File metaFile, final File filtersFile)
@@ skipping 50 matching lines @@
     this.serializeMetaData(metaFile);
     if (filtersChanged)
     {
       this.serializeFilters(filtersFile);
       this.clearFilters();
     }
 
     return filtersChanged;
   }
 }