Upstream NFC beam URL sharing code and add it to ChromeShell.

chrome/android/java/src/org/chromium/chrome/browser/nfc/BeamCallback.java

Index: chrome/android/java/src/org/chromium/chrome/browser/nfc/BeamCallback.java
diff --git a/chrome/android/java/src/org/chromium/chrome/browser/nfc/BeamCallback.java b/chrome/android/java/src/org/chromium/chrome/browser/nfc/BeamCallback.java
new file mode 100644
index 0000000000000000000000000000000000000000..18cbccf6214c60421517b0e99d158ce6befa4d6e
--- /dev/null
+++ b/chrome/android/java/src/org/chromium/chrome/browser/nfc/BeamCallback.java
@@ -0,0 +1,150 @@
+// Copyright 2014 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.chrome.browser.nfc;
+
+import android.app.Activity;
+import android.nfc.NdefMessage;
+import android.nfc.NdefRecord;
+import android.nfc.NfcAdapter.CreateNdefMessageCallback;
+import android.nfc.NfcAdapter.OnNdefPushCompleteCallback;
+import android.nfc.NfcEvent;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.text.TextUtils;
+import android.widget.Toast;
+
+import org.chromium.base.ThreadUtils;
+import org.chromium.chrome.R;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/**
+ * Beam callback that gets passed to Android to get triggered when devices are tapped to
+ * each other.
+ */
+class BeamCallback implements CreateNdefMessageCallback, OnNdefPushCompleteCallback {
+
+    private static class Status {
+        public final Integer errorStrID;
+        public final String result;
+
+        Status(Integer errorStrID) {
+            assert errorStrID != null;
+            this.errorStrID = errorStrID;
+            this.result = null;
+        }
+
+        Status(String result) {
+            assert result != null;
+            this.result = result;
+            this.errorStrID = null;
+        }
+    }
+
+    // In ICS returning null from createNdefMessage will cause beam to send our market
+    // link so we need to hook to the return from the beam overlay to display the error.
+    // But in SDK_INT >= 16, beam won't activate, so the hook wouldn't go off. (b/5943350)
+    private static final boolean NFC_BUGS_ACTIVE = Build.VERSION.SDK_INT < 16;
+
+    // Arbitrarily chosen interval to delay toast to allow NFC animations to finish
+    // and our app to return to foreground.
+    private static final int TOAST_ERROR_DELAY_MS = 400;
+
+    private final Activity mActivity;
+    private final BeamProvider mProvider;
+
+    // We use this to delay the error message in ICS because it would be hidden behind
+    // the system beam overlay. It is only accessed by the NFC thread
+    private Runnable mErrorRunnableIfBeamSent;
+
+    BeamCallback(Activity activity, BeamProvider provider) {
+        mActivity = activity;
+        mProvider = provider;
+    }
+
+    @Override
+    public NdefMessage createNdefMessage(NfcEvent event) {
+        // Default status is an error
+        Status status = new Status(R.string.nfc_beam_error_bad_url);
+        try {
+            status = ThreadUtils.runOnUiThread(new Callable<Status>() {
+                @Override
+                public Status call() {
+                    String url = mProvider.getTabUrlForBeam();
+                    if (url == null) return new Status(R.string.nfc_beam_error_overlay_active);
+                    if (!isValidUrl(url)) return new Status(R.string.nfc_beam_error_bad_url);
+                    return new Status(url);
+                }
+            }).get(2000, TimeUnit.MILLISECONDS); // Arbitrarily chosen timeout for query.
+        } catch (TimeoutException e) {
+            // Squelch this exception, we'll treat it as a bad tab
+        } catch (ExecutionException e) {
+            // And this
+        } catch (InterruptedException e) {
+            // And squelch this one too
+        }
+
+        if (status.errorStrID != null) {
+            onInvalidBeam(status.errorStrID);
+            return null;
+        }
+
+        //UmaRecordAction.beamCallbackSuccess();
+        mErrorRunnableIfBeamSent = null;
+        return new NdefMessage(new NdefRecord[] {NdefRecord.createUri(status.result)});
+    }
+
+    /**
+     * Trigger an error about NFC if we don't want to send anything. Also
+     * records a UMA stat. On ICS we only show the error if they attempt to
+     * beam, since the recipient will receive the market link. On JB we'll
+     * always show the error, since the beam animation won't trigger, which
+     * could be confusing to the user.
+     *
+     * @param errorStringId The resid of the string to display as error.
+     */
+    private void onInvalidBeam(final int errorStringId) {
+        //UmaRecordAction.beamInvalidAppState();

[newt (away), 2014/09/30 22:34:36]

uncomment this !!!!!

[aurimas (slooooooooow), 2014/09/30 22:45:26]

Done.

+        Runnable errorRunnable = new Runnable() {
+            @Override
+            public void run() {
+                Toast.makeText(mActivity, errorStringId, Toast.LENGTH_SHORT).show();
+            }
+        };
+        if (NFC_BUGS_ACTIVE) {
+            mErrorRunnableIfBeamSent = errorRunnable;
+        } else {
+            ThreadUtils.runOnUiThread(errorRunnable);
+        }
+    }
+
+    @Override
+    public void onNdefPushComplete(NfcEvent event) {
+        if (mErrorRunnableIfBeamSent != null) {
+            Handler h = new Handler(Looper.getMainLooper());
+            h.postDelayed(mErrorRunnableIfBeamSent, TOAST_ERROR_DELAY_MS);
+            mErrorRunnableIfBeamSent = null;
+        }
+    }
+
+    /**
+     * @return Whether given URL is valid and sharable via Beam.
+     */
+    private static boolean isValidUrl(String url) {
+        if (TextUtils.isEmpty(url)) return false;
+        try {
+            String urlProtocol = (new URL(url)).getProtocol();
+            return urlProtocol.matches("http|https");
+        } catch (MalformedURLException e) {
+            return false;
+        }
+    }
+}