Java code for fetching variations first run seed after receiving chrome.TOS_ACKED broadcast.

components/variations/android/java/src/org/chromium/components/variations/firstrun/VariationsSeedService.java

Index: components/variations/android/java/src/org/chromium/components/variations/firstrun/VariationsSeedService.java
diff --git a/components/variations/android/java/src/org/chromium/components/variations/firstrun/VariationsSeedService.java b/components/variations/android/java/src/org/chromium/components/variations/firstrun/VariationsSeedService.java
new file mode 100644
index 0000000000000000000000000000000000000000..24bb3ceb0cfac75330561285ad51563a9e6bb2cc
--- /dev/null
+++ b/components/variations/android/java/src/org/chromium/components/variations/firstrun/VariationsSeedService.java
@@ -0,0 +1,97 @@
+// Copyright 2015 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.
+
+package org.chromium.components.variations.firstrun;
+
+import android.app.IntentService;
+import android.content.Intent;
+
+import org.chromium.base.Log;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+
+/**
+ * Background service that fetches the variations seed before the actual first run of Chrome.
+ */
+public class VariationsSeedService extends IntentService {
+    private static final String TAG = "VariationsSeedServ";
+    private static final String VARIATIONS_SERVER_URL =
+            "https://clients4.google.com/chrome-variations/seed?osname=android";
+    private static final int BUFFER_SIZE = 4096;
+    private static final int READ_TIMEOUT = 10000; // time in ms
+    private static final int REQUEST_TIMEOUT = 15000; // time in ms
+
+    public VariationsSeedService() {
+        super(TAG);
+    }
+
+    @Override
+    public void onHandleIntent(Intent intent) {
+        try {
+            downloadContent(new URL(VARIATIONS_SERVER_URL));
+        } catch (MalformedURLException e) {
+            Log.w(TAG, "Variations server URL is malformed.", e);
+        }
+    }
+
+    private boolean downloadContent(URL variationsServerUrl) throws MalformedURLException {
+        try {
+            return doActualFetch(variationsServerUrl);
+        } catch (IOException e) {
+            Log.w(TAG, "Variations service has thrown IO Exception.", e);
+            return false;
+        }
+    }
+
+    private boolean doActualFetch(URL variationsServerUrl)
+            throws IOException, MalformedURLException {

[newt (away), 2015/11/10 06:20:15]

Remove the "throws" clause; this shouldn't throw IOException or
MalformedURLException. If a MalformedURLException is thrown inside the method (I
don't see where that would happen; but perhaps it does), then you should catch
it inside this method.

[Alexander Agulenko, 2015/11/10 06:40:12]

See my comment below.

+        InputStream inputStream = null;
+        HttpURLConnection connection = null;
+        try {
+            connection = (HttpURLConnection) variationsServerUrl.openConnection();
+            connection.setReadTimeout(READ_TIMEOUT);
+            connection.setConnectTimeout(REQUEST_TIMEOUT);
+            connection.setDoInput(true);
+            // TODO(agulenko): add gzip compression support.
+            // connection.setRequestProperty("A-IM", "gzip");
+            connection.connect();
+            int responseCode = connection.getResponseCode();
+            if (responseCode != HttpURLConnection.HTTP_OK) {
+                Log.d(TAG, "Response code = %d", responseCode);

[Alexei Svitkine (slow), 2015/11/10 16:23:24]

Nit: Move this above outside the if, or changing this message to "Non-200
response code = " or something.

[Alexander Agulenko, 2015/11/10 22:44:13]

Done.

+                return false;
+            }
+            inputStream = connection.getInputStream();
+
+            // Convert the InputStream into a byte array.
+            byte[] rawSeed = convertInputStreamToByteArray(inputStream);
+            String signature = connection.getHeaderField("X-Seed-Signature");
+            String country = connection.getHeaderField("X-Country");
+            VariationsSeedBridge.setVariationsFirstRunSeed(
+                    getApplicationContext(), rawSeed, signature, country);
+            return true;
+        } finally {

[newt (away), 2015/11/10 06:20:15]

just add the catch statement here (and delete the new downloadContent() method
that you added in this patch set)

[Alexander Agulenko, 2015/11/10 06:40:12]

I tried to make exactly as you suggest, but inputStream.close() also can throw
IOException -- that is the reason why I added additional layer with try/catch
blocks.

[Alexander Agulenko, 2015/11/10 06:41:55]

Of course, I can resolve it by making nested try/catch blocks, but it does not
seem to be the best idea.

[newt (away), 2015/11/10 17:17:51]

Actually, you should wrap inputStream.close() in a nested try/catch block, so
that if inputStream.close() fails, we'll still try to call
connection.disconnect().

[Steven Holte, 2015/11/10 20:51:10]

For tidiness, split into two funcions:

private byte[] getRawSeed(HttpURLConnection connection) {
  InputStream inputStream = null;
  try {
    inputStream = connection.getInputStream();
    return convertInputStreamToByteArray(inputStream);
  } finally {
    if (inputStream != null) {
       inputStream.close();
    }
  }
}

[Alexander Agulenko, 2015/11/10 22:44:13]

Done.

[Alexander Agulenko, 2015/11/10 22:44:13]

Check the comment below by Steven, it seems to be less messy than nested
try/catches.

+            if (inputStream != null) {
+                inputStream.close();
+            }
+            if (connection != null) {
+                connection.disconnect();
+            }
+        }
+    }
+
+    private byte[] convertInputStreamToByteArray(InputStream inputStream) throws IOException {
+        ByteArrayOutputStream byteBuffer = new ByteArrayOutputStream();
+        byte[] buffer = new byte[BUFFER_SIZE];
+        int charactersReadCount = 0;
+        while ((charactersReadCount = inputStream.read(buffer)) != -1) {
+            byteBuffer.write(buffer, 0, charactersReadCount);
+        }
+        return byteBuffer.toByteArray();
+    }
+}