Upstream: Launch WebAPK without showing intent picker when user taps link in WebAPK scope

chrome/android/javatests/src/org/chromium/chrome/browser/externalnav/ExternalNavigationHandlerTest.java

 // 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.chrome.browser.externalnav;
 
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.ActivityInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.net.Uri;
 import android.os.SystemClock;
 import android.provider.Browser;
 import android.test.InstrumentationTestCase;
 import android.test.mock.MockContext;
 import android.test.mock.MockPackageManager;
 import android.test.suitebuilder.annotation.SmallTest;
 
 import org.chromium.base.CommandLine;
 import org.chromium.base.metrics.RecordHistogram;
 import org.chromium.chrome.browser.IntentHandler;
 import org.chromium.chrome.browser.externalnav.ExternalNavigationHandler.OverrideUrlLoadingResult;
 import org.chromium.chrome.browser.tab.Tab;
 import org.chromium.chrome.browser.tab.TabRedirectHandler;
 import org.chromium.chrome.browser.util.FeatureUtilities;
 import org.chromium.ui.base.PageTransition;
+import org.chromium.webapk.lib.common.WebApkConstants;
 
 import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.List;
 
 /**
  * Instrumentation tests for {@link ExternalNavigationHandler}.
  */
 public class ExternalNavigationHandlerTest extends InstrumentationTestCase {
 
     // Expectations
     private static final int IGNORE = 0x0;
     private static final int START_INCOGNITO = 0x1;
     private static final int START_CHROME = 0x2;
-    private static final int START_FILE = 0x4;
-    private static final int START_OTHER_ACTIVITY = 0x8;
-    private static final int INTENT_SANITIZATION_EXCEPTION = 0x10;
+    private static final int START_WEBAPK = 0x4;
+    private static final int START_FILE = 0x8;
+    private static final int START_OTHER_ACTIVITY = 0x10;
+    private static final int INTENT_SANITIZATION_EXCEPTION = 0x20;
 
     private static final String SEARCH_RESULT_URL_FOR_TOM_HANKS =
             "https://www.google.com/search?q=tom+hanks";
     private static final String IMDB_WEBPAGE_FOR_TOM_HANKS = "http://m.imdb.com/name/nm0000158";
     private static final String INTENT_URL_WITH_FALLBACK_URL =
             "intent:///name/nm0000158#Intent;scheme=imdb;package=com.imdb.mobile;"
             + "S." + ExternalNavigationHandler.EXTRA_BROWSER_FALLBACK_URL + "="
             + Uri.encode(IMDB_WEBPAGE_FOR_TOM_HANKS) + ";end";
     private static final String INTENT_URL_WITH_FALLBACK_URL_WITHOUT_PACKAGE_NAME =
             "intent:///name/nm0000158#Intent;scheme=imdb;"
@@ skipping 10 matching lines @@
             + "S." + ExternalNavigationHandler.EXTRA_BROWSER_FALLBACK_URL + "="
             + Uri.encode("http://url.myredirector.com/aaa") + ";end";
 
     private static final String PLUS_STREAM_URL = "https://plus.google.com/stream";
     private static final String CALENDAR_URL = "http://www.google.com/calendar";
     private static final String KEEP_URL = "http://www.google.com/keep";
 
     private static final String TEXT_APP_1_PACKAGE_NAME = "text_app_1";
     private static final String TEXT_APP_2_PACKAGE_NAME = "text_app_2";
 
+    private static final String WEBAPK_SCOPE = "https://www.template.com";
+    private static final String WEBAPK_PACKAGE_NAME = "org.chromium.webapk.template";
+
+    private static final String WEBAPK_WITH_NATIVE_APP_SCOPE =
+            "https://www.webapk.with.native.com";
+    private static final String WEBAPK_WITH_NATIVE_APP_PACKAGE_NAME =
+            "org.chromium.webapk.with.native";
+    private static final String NATIVE_APP_PACKAGE_NAME = "com.webapk.with.native.android";
+
+    private static final String COUNTERFEIT_WEBAPK_SCOPE = "http://www.counterfeight.webapk.com";
+    private static final String COUNTERFEIT_WEBAPK_PACKAGE_NAME =
+            "org.chromium.webapk.counterfeight";
+
     private final TestExternalNavigationDelegate mDelegate;
     private ExternalNavigationHandler mUrlHandler;
 
     public ExternalNavigationHandlerTest() {
         mDelegate = new TestExternalNavigationDelegate();
         mUrlHandler = new ExternalNavigationHandler(mDelegate);
     }
 
     @Override
     protected void setUp() throws Exception {
@@ skipping 657 matching lines @@
         checkUrl("intent://012345678?body=hello%20there/#Intent;scheme=sms;end")
                 .withReferrer(referer)
                 .expecting(OverrideUrlLoadingResult.OVERRIDE_WITH_EXTERNAL_INTENT,
                         START_OTHER_ACTIVITY);
 
         assertNotNull(mDelegate.startActivityIntent);
         assertEquals(TEXT_APP_2_PACKAGE_NAME, mDelegate.startActivityIntent.getPackage());
     }
 
     /**
-     * Test that tapping on a link which is outside of the referrer Web APK's scope brings the
+     * Test that tapping on a link which is outside of the referrer WebAPK's scope brings the
      * user back to Chrome.
      */
     @SmallTest
     public void testLeaveWebApk_LinkOutOfScope() {
         checkUrl(SEARCH_RESULT_URL_FOR_TOM_HANKS)
-                .withIsWebApk(true)
+                .withWebApkPackageName(WEBAPK_PACKAGE_NAME)
                 .expecting(OverrideUrlLoadingResult.OVERRIDE_WITH_EXTERNAL_INTENT, START_CHROME);
     }
 
+    /**
+     * Test that tapping a link which falls solely in the scope of a WebAPK launches a WebAPK
+     * without showing the intent picker.
+     */
+    @SmallTest
+    public void testLaunchWebApk_BypassIntentPicker() {
+        checkUrl(WEBAPK_SCOPE)
+                .expecting(OverrideUrlLoadingResult.OVERRIDE_WITH_EXTERNAL_INTENT, START_WEBAPK);
+    }
+
+    /**
+     * Test that tapping a link which falls in the scope of multiple intent handlers, one of which
+     * is a WebAPK, shows the intent picker.
+     */
+    @SmallTest
+    public void testLaunchWebApk_ShowIntentPickerMultipleIntentHandlers() {
+        checkUrl(WEBAPK_WITH_NATIVE_APP_SCOPE)
+                .expecting(OverrideUrlLoadingResult.OVERRIDE_WITH_EXTERNAL_INTENT,
+                        START_OTHER_ACTIVITY);
+    }
+
+    /**
+     * Test that tapping a link which falls into the scope of a different WebAPK launches a WebAPK
+     * without showing the intent picker.

[Xi Han, 2016/06/07 19:16:47]

This is because the other WebAPK is the only handler for the URL WEBAPK_SCOPE,
right? It is better to explain it clear.

[pkotwicz, 2016/06/07 22:07:07]

I changed the comment to say "solely falls into the scope". Let me know if you
have a suggestion on how to make the comment clearer

[Xi Han, 2016/06/08 14:00:11]

Thanks for updating the comment!

+     */
+    @SmallTest
+    public void testLaunchWebApk_BypassIntentPickerFromAnotherWebApk() {
+        checkUrl(WEBAPK_SCOPE)
+                .withReferrer(WEBAPK_WITH_NATIVE_APP_SCOPE)
+                .withWebApkPackageName(WEBAPK_WITH_NATIVE_APP_PACKAGE_NAME)
+                .expecting(OverrideUrlLoadingResult.OVERRIDE_WITH_EXTERNAL_INTENT, START_WEBAPK);
+    }
+
+    /**
+     * Test that a link which falls into the scope of an invalid WebAPK (e.g. it was incorrectly
+     * signed) does not get any special WebAPK handling. The first time that the user taps on the
+     * link, the intent picker should be shown.
+     */
+    @SmallTest
+    public void testLaunchWebApk_ShowIntentPickerInvalidWebApk() {
+        checkUrl(COUNTERFEIT_WEBAPK_SCOPE)
+                .expecting(OverrideUrlLoadingResult.OVERRIDE_WITH_EXTERNAL_INTENT,
+                        START_OTHER_ACTIVITY);
+    }
+
+    /**
+     * Test that tapping a link which falls into the scope of the current WebAPK stays within the
+     * WebAPK.
+     */
+    @SmallTest
+    public void testLaunchWebApk_StayInSameWebApk() {
+        checkUrl(WEBAPK_SCOPE + "/new.html")
+                .withReferrer(WEBAPK_SCOPE)
+                .withWebApkPackageName(WEBAPK_PACKAGE_NAME)
+                .expecting(OverrideUrlLoadingResult.NO_OVERRIDE, IGNORE);
+    }
+
     private static ResolveInfo newResolveInfo(String packageName, String name) {
         ActivityInfo ai = new ActivityInfo();
         ai.packageName = packageName;
         ai.name = name;
         ResolveInfo ri = new ResolveInfo();
         ri.activityInfo = ai;
         return ri;
     }
 
     private static class TestExternalNavigationDelegate implements ExternalNavigationDelegate {
         private Context mContext;
 
         public void setContext(Context context) {
             mContext = context;
         }
 
         @Override
         public List<ResolveInfo> queryIntentActivities(Intent intent) {
             List<ResolveInfo> list = new ArrayList<ResolveInfo>();
             // TODO(yfriedman): We shouldn't have a separate global override just for tests - we
             // should mimic the appropriate intent resolution intead.
             if (mQueryIntentOverride != null) {
                 if (mQueryIntentOverride.booleanValue()) {
                     list.add(newResolveInfo("foo", "foo"));
                 } else {
                     return list;
                 }
             }
-            if (intent.getDataString().startsWith("http://")
+            String dataString = intent.getDataString();
+            if (dataString.startsWith("http://")
                     || intent.getDataString().startsWith("https://")) {
                 list.add(newResolveInfo("chrome", "chrome"));
             }
-            if (intent.getDataString().startsWith("http://m.youtube.com")
+            if (dataString.startsWith("http://m.youtube.com")
                     || intent.getDataString().startsWith("http://youtube.com")) {
                 list.add(newResolveInfo("youtube", "youtube"));
-            } else if (intent.getDataString().startsWith(PLUS_STREAM_URL)) {
+            } else if (dataString.startsWith(PLUS_STREAM_URL)) {
                 list.add(newResolveInfo("plus", "plus"));
             } else if (intent.getDataString().startsWith(CALENDAR_URL)) {
                 list.add(newResolveInfo("calendar", "calendar"));
-            } else if (intent.getDataString().startsWith("sms")) {
+            } else if (dataString.startsWith("sms")) {
                 list.add(newResolveInfo(
                         TEXT_APP_1_PACKAGE_NAME, TEXT_APP_1_PACKAGE_NAME + ".cls"));
                 list.add(newResolveInfo(
                         TEXT_APP_2_PACKAGE_NAME, TEXT_APP_2_PACKAGE_NAME + ".cls"));
+            } else if (dataString.startsWith(WEBAPK_SCOPE)) {
+                list.add(newResolveInfo(WEBAPK_PACKAGE_NAME, WEBAPK_PACKAGE_NAME));
+            } else if (dataString.startsWith(WEBAPK_WITH_NATIVE_APP_SCOPE)) {
+                list.add(newResolveInfo(WEBAPK_WITH_NATIVE_APP_PACKAGE_NAME,
+                        WEBAPK_WITH_NATIVE_APP_PACKAGE_NAME));
+                list.add(newResolveInfo(NATIVE_APP_PACKAGE_NAME, NATIVE_APP_PACKAGE_NAME));
+            } else if (dataString.startsWith(COUNTERFEIT_WEBAPK_SCOPE)) {
+                list.add(newResolveInfo(COUNTERFEIT_WEBAPK_PACKAGE_NAME, COUNTERFEIT_WEBAPK_SCOPE));
             } else {
                 list.add(newResolveInfo("foo", "foo"));
             }
             return list;
         }
 
         @Override
         public boolean willChromeHandleIntent(Intent intent) {
             return !isSpecializedHandlerAvailable(queryIntentActivities(intent));
         }
 
         @Override
         public boolean isSpecializedHandlerAvailable(List<ResolveInfo> resolveInfos) {
-            for (ResolveInfo resolveInfo : resolveInfos) {
-                String packageName = resolveInfo.activityInfo.packageName;
-                if (packageName.equals("youtube") || packageName.equals("calendar")) {
-                    return true;
-                }
-            }
-            return false;
+            return countSpecializedHandlers(resolveInfos) > 0;
         }
 
         @Override
+        public int countSpecializedHandlers(List<ResolveInfo> infos) {
+            if (infos == null) {
+                return 0;
+            }
+            int count = 0;
+            for (ResolveInfo info : infos) {
+                String packageName = info.activityInfo.packageName;
+                if (packageName.equals("youtube") || packageName.equals("calendar")
+                        || packageName.equals(WEBAPK_WITH_NATIVE_APP_PACKAGE_NAME)
+                        || packageName.equals(WEBAPK_PACKAGE_NAME)
+                        || packageName.equals(COUNTERFEIT_WEBAPK_PACKAGE_NAME)
+                        || packageName.equals(NATIVE_APP_PACKAGE_NAME)) {
+                    ++count;
+                }
+            }
+            return count;
+        }
+
+        @Override
+        public String findValidWebApkPackageName(List<ResolveInfo> infos) {
+            if (infos == null) {
+                return null;
+            }
+            for (ResolveInfo info : infos) {
+                String packageName = info.activityInfo.packageName;
+                if (packageName.equals(WEBAPK_PACKAGE_NAME)
+                        || packageName.equals(WEBAPK_WITH_NATIVE_APP_PACKAGE_NAME)) {
+                    return packageName;
+                }
+            }
+            return null;
+        }
+
+        @Override
         public String getPackageName() {
             return "test";
         }
 
         @Override
         public void startActivity(Intent intent) {
             startActivityIntent = intent;
         }
 
         @Override
@@ skipping 103 matching lines @@
 
     private class ExternalNavigationTestParams {
         private final String mUrl;
 
         private String mReferrerUrl;
         private boolean mIsIncognito;
         private int mPageTransition = PageTransition.LINK;
         private boolean mIsRedirect;
         private boolean mChromeAppInForegroundRequired = true;
         private boolean mIsBackgroundTabNavigation;
-        private boolean mIsWebApk;
+        private String mWebApkPackageName;
         private boolean mHasUserGesture;
         private TabRedirectHandler mRedirectHandler;
 
         private ExternalNavigationTestParams(String url) {
             mUrl = url;
         }
 
-        public ExternalNavigationTestParams withIsWebApk(boolean isWebApk) {
-            mIsWebApk = isWebApk;
+        public ExternalNavigationTestParams withWebApkPackageName(String webApkPackageName) {
+            mWebApkPackageName = webApkPackageName;
             return this;
         }
 
         public ExternalNavigationTestParams withReferrer(String referrerUrl) {
             mReferrerUrl = referrerUrl;
             return this;
         }
 
         public ExternalNavigationTestParams withIsIncognito(boolean isIncognito) {
             mIsIncognito = isIncognito;
@@ skipping 29 matching lines @@
 
         public ExternalNavigationTestParams withRedirectHandler(TabRedirectHandler handler) {
             mRedirectHandler = handler;
             return this;
         }
 
         public void expecting(OverrideUrlLoadingResult expectedOverrideResult,
                 int otherExpectation) {
             boolean expectStartIncognito = (otherExpectation & START_INCOGNITO) != 0;
             boolean expectStartActivity =
-                    (otherExpectation & (START_CHROME | START_OTHER_ACTIVITY)) != 0;
+                    (otherExpectation & (START_CHROME | START_WEBAPK | START_OTHER_ACTIVITY)) != 0;
             boolean expectStartChrome = (otherExpectation & START_CHROME) != 0;
+            boolean expectStartWebApk = (otherExpectation & START_WEBAPK) != 0;
             boolean expectStartOtherActivity = (otherExpectation & START_OTHER_ACTIVITY) != 0;
             boolean expectStartFile = (otherExpectation & START_FILE) != 0;
             boolean expectSaneIntent = expectStartOtherActivity
                     && (otherExpectation & INTENT_SANITIZATION_EXCEPTION) == 0;
 
             mDelegate.reset();
 
             ExternalNavigationParams params = new ExternalNavigationParams.Builder(
                     mUrl, mIsIncognito, mReferrerUrl,
                     mPageTransition, mIsRedirect)
                     .setApplicationMustBeInForeground(mChromeAppInForegroundRequired)
                     .setRedirectHandler(mRedirectHandler)
                     .setIsBackgroundTabNavigation(mIsBackgroundTabNavigation)
                     .setIsMainFrame(true)
-                    .setIsWebApk(mIsWebApk)
+                    .setWebApkPackageName(mWebApkPackageName)
                     .setHasUserGesture(mHasUserGesture)
                     .build();
             OverrideUrlLoadingResult result = mUrlHandler.shouldOverrideUrlLoading(params);
             boolean startActivityCalled = false;
             boolean startChromeCalled = false;
+            boolean startWebApkCalled = false;
             if (mDelegate.startActivityIntent != null) {
                 startActivityCalled = true;
                 String packageName = mDelegate.startActivityIntent.getPackage();
-                startChromeCalled =
-                        packageName != null && packageName.equals(mDelegate.getPackageName());
+                if (packageName != null) {
+                    startChromeCalled = packageName.equals(mDelegate.getPackageName());
+                    startWebApkCalled =
+                            packageName.startsWith(WebApkConstants.WEBAPK_PACKAGE_PREFIX);
+                }
             }
 
             assertEquals(expectedOverrideResult, result);
             assertEquals(expectStartIncognito, mDelegate.startIncognitoIntentCalled);
             assertEquals(expectStartActivity, startActivityCalled);
             assertEquals(expectStartChrome, startChromeCalled);
+            assertEquals(expectStartWebApk, startWebApkCalled);
             assertEquals(expectStartFile, mDelegate.startFileIntentCalled);
 
             if (startActivityCalled && expectSaneIntent) {
                 checkIntentSanity(mDelegate.startActivityIntent, "Intent");
                 if (mDelegate.startActivityIntent.getSelector() != null) {
                     checkIntentSanity(mDelegate.startActivityIntent.getSelector(),
                             "Intent's selector");
                 }
             }
         }
@@ skipping 21 matching lines @@
             return new TestPackageManager();
         }
 
         @Override
         public String getPackageName() {
             return "test.app.name";
         }
 
     }
 }