Merge lp:~abreu-alexandre/webbrowser-app/rtm-intent-support into lp:webbrowser-app/rtm-14.09

[Alexandre Abreu]

Backport for the intent:// support.

Backport for the intent:// support.

[Olivier Tilloy (osomon)]

LGTM.

review: Approve

=== modified file 'src/app/webcontainer/CMakeLists.txt'
--- src/app/webcontainer/CMakeLists.txt	2014-09-18 13:37:07 +0000
+++ src/app/webcontainer/CMakeLists.txt	2015-02-02 14:22:27 +0000
@@ -18,13 +18,14 @@
     webapp-container-helper.cpp
     session-utils.cpp
     url-pattern-utils.cpp
+    intent-filter.cpp
 )
 
 add_executable(${WEBAPP_CONTAINER} ${WEBAPP_CONTAINER_SRC})
 
 target_link_libraries(${WEBAPP_CONTAINER} ${COMMONLIB})
 
-qt5_use_modules(${WEBAPP_CONTAINER} Core Widgets Quick Sql DBus)
+qt5_use_modules(${WEBAPP_CONTAINER} Core Widgets Quick Qml Sql DBus)
 
 install(TARGETS ${WEBAPP_CONTAINER}
         RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

=== modified file 'src/app/webcontainer/WebViewImplWebkit.qml'
--- src/app/webcontainer/WebViewImplWebkit.qml	2015-01-19 10:00:13 +0000
+++ src/app/webcontainer/WebViewImplWebkit.qml	2015-02-02 14:22:27 +0000
@@ -96,29 +96,12 @@
         return webappUrlPatterns && webappUrlPatterns.length !== 0
     }
 
-    function navigationRequestedDelegate(request) {
-        if (!request.isMainFrame) {
-            request.action = WebView.AcceptRequest
-            return
-        }
-
-        // Pass-through if we are not running as a named webapp (--webapp='Gmail')
-        // or if we dont have a list of url patterns specified to filter the
-        // browsing actions
-        if ( ! haveValidUrlPatterns() && ! isRunningAsANamedWebapp()) {
-            request.action = WebView.AcceptRequest
-            return
-        }
-
-        var action = WebView.IgnoreRequest
-        var url = request.url.toString()
-
+    function shouldAllowNavigationTo(url) {
         // The list of url patterns defined by the webapp takes precedence over command line
         if (isRunningAsANamedWebapp()) {
             if (unityWebapps.model.exists(unityWebapps.name) &&
                 unityWebapps.model.doesUrlMatchesWebapp(unityWebapps.name, url)) {
-                request.action = WebView.AcceptRequest
-                return;
+                return true;
             }
         }
 
@@ -129,12 +112,36 @@
             for (var i = 0; i < webappUrlPatterns.length; ++i) {
                 var pattern = webappUrlPatterns[i]
                 if (url.match(pattern)) {
-                    action = WebView.AcceptRequest
-                    break
+                    return true;
                 }
             }
         }
 
+        return false;
+    }
+
+    function navigationRequestedDelegate(request) {
+        if (!request.isMainFrame) {
+            request.action = WebView.AcceptRequest
+            return
+        }
+
+        // Pass-through if we are not running as a named webapp (--webapp='Gmail')
+        // or if we dont have a list of url patterns specified to filter the
+        // browsing actions
+        if ( ! haveValidUrlPatterns() && ! isRunningAsANamedWebapp()) {
+            request.action = WebView.AcceptRequest
+            return
+        }
+
+        var action = WebView.IgnoreRequest
+        var url = request.url.toString()
+
+        if (shouldAllowNavigationTo(url)) {
+            request.action = WebView.AcceptRequest
+            return;
+        }
+
         request.action = action
         if (action === WebView.IgnoreRequest) {
             console.debug('Opening: ' + url + ' in the browser window.')

=== added file 'src/app/webcontainer/intent-filter.cpp'
--- src/app/webcontainer/intent-filter.cpp	1970-01-01 00:00:00 +0000
+++ src/app/webcontainer/intent-filter.cpp	2015-02-02 14:22:27 +0000
@@ -0,0 +1,243 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This file is part of webbrowser-app.
+ *
+ * webbrowser-app is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * webbrowser-app is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "intent-filter.h"
+
+#include <QtCore/QRegularExpression>
+#include <QDebug>
+#include <QFile>
+#include <QJSEngine>
+#include <QJSValue>
+#include <QUrl>
+
+
+namespace {
+
+const char INTENT_SCHEME_STRING[] = "intent";
+const char INTENT_START_FRAGMENT_TAG[] = "Intent";
+const char INTENT_URI_PACKAGE_PREFIX[] = "package=";
+const char INTENT_URI_ACTION_PREFIX[] = "action=";
+const char INTENT_URI_CATEGORY_PREFIX[] = "category=";
+const char INTENT_URI_COMPONENT_PREFIX[] = "component=";
+const char INTENT_URI_SCHEME_PREFIX[] = "scheme=";
+const char INTENT_END_FRAGMENT_TAG[] = ";end";
+
+void trimUriSeparator(QString& uriComponent)
+{
+    uriComponent.remove(QRegExp("^/*")).remove(QRegExp("/*$"));
+}
+
+}
+
+class IntentFilterPrivate
+{
+public:
+
+    static const QString DEFAULT_PASS_THROUGH_FILTER;
+
+public:
+
+    IntentFilterPrivate(const QString& content);
+
+    QJSValue evaluate(const IntentUriDescription& intent);
+    QJSValue evaluate(const QString& customContent
+                      , const IntentUriDescription& intent);
+
+private:
+
+    QJSValue callFunction(
+            QJSValue & function
+            , const IntentUriDescription& intent);
+
+    QString _content;
+    QJSEngine _engine;
+    QJSValue _function;
+
+};
+
+// static
+const QString IntentFilterPrivate::DEFAULT_PASS_THROUGH_FILTER =
+        "(function(intent) { return intent; })";
+
+IntentFilterPrivate::IntentFilterPrivate(const QString& content)
+    : _content(content)
+{
+    if (_content.isEmpty())
+    {
+        _content = DEFAULT_PASS_THROUGH_FILTER;
+    }
+    _function = _engine.evaluate(_content);
+}
+
+QJSValue IntentFilterPrivate::callFunction(QJSValue & function
+                                          , const IntentUriDescription& intent)
+{
+    if (!function.isCallable())
+    {
+        qCritical() << "Invalid intent filter function (not callable)";
+        return QJSValue();
+    }
+
+    QVariantMap o;
+    o.insert("scheme", intent.scheme);
+    o.insert("uri", intent.uriPath);
+    o.insert("host", intent.host);
+
+    QJSValueList jsargs;
+    jsargs << _engine.toScriptValue(o);
+    return function.call(jsargs);
+}
+
+QJSValue IntentFilterPrivate::evaluate(const QString& customContent
+                                       , const IntentUriDescription& intent)
+{
+    QJSValue f = _engine.evaluate(customContent);
+    return callFunction(f, intent);
+}
+
+QJSValue IntentFilterPrivate::evaluate(const IntentUriDescription& intent)
+{
+    return callFunction(_function, intent);
+}
+
+// static
+bool IntentFilter::isValidLocalIntentFilterFile(const QString& filename)
+{
+    QFile f(filename);
+    if (!f.exists() || !f.open(QIODevice::ReadOnly))
+    {
+        return false;
+    }
+
+    // Perform basic validation
+    QJSEngine engine;
+    QJSValue result = engine.evaluate(QString(f.readAll()), filename);
+    return !result.isNull() && result.isCallable();
+}
+
+// static
+bool IntentFilter::isValidIntentFilterResult(const QVariantMap& result)
+{
+    return result.contains("scheme")
+        && result.value("scheme").canConvert(QVariant::String)
+        && result.contains("uri")
+        && result.value("uri").canConvert(QVariant::String);
+}
+
+// static
+bool IntentFilter::isValidIntentDescription(const IntentUriDescription& intentDescription)
+{
+    return !intentDescription.uriPath.isEmpty()
+        || !intentDescription.package.isEmpty();
+}
+
+
+IntentFilter::IntentFilter(const QString& content, QObject *parent) :
+    QObject(parent),
+    d_ptr(new IntentFilterPrivate(content))
+{
+}
+
+IntentFilter::~IntentFilter()
+{
+    delete d_ptr;
+}
+
+QVariantMap IntentFilter::applyFilter(const QString& intentUri)
+{
+    Q_D(IntentFilter);
+
+    QVariantMap result;
+    IntentUriDescription intentDescription =
+            parseIntentUri(QUrl::fromUserInput(intentUri));
+    if (!isValidIntentDescription(intentDescription))
+    {
+        return result;
+    }
+    QJSValue value = d->evaluate(intentDescription);
+    if (value.isObject()
+            && value.toVariant().canConvert(QVariant::Map))
+    {
+        QVariantMap r = value.toVariant().toMap();
+        if (isValidIntentFilterResult(r))
+        {
+            result = r;
+        }
+        else
+        {
+            // Fallback to a noop
+            result = d->evaluate(
+                        IntentFilterPrivate::DEFAULT_PASS_THROUGH_FILTER
+                        , intentDescription).toVariant().toMap();
+        }
+    }
+    return result;
+}
+
+bool IntentFilter::isValidIntentUri(const QString& intentUri) const
+{
+    // a bit overkill but anyway ...
+    return isValidIntentDescription(parseIntentUri(QUrl::fromUserInput(intentUri)));
+}
+
+IntentUriDescription
+parseIntentUri(const QUrl& intentUri)
+{
+    IntentUriDescription result;
+    if (intentUri.scheme() != INTENT_SCHEME_STRING
+            || !intentUri.fragment().startsWith(INTENT_START_FRAGMENT_TAG)
+            || !intentUri.fragment().endsWith(INTENT_END_FRAGMENT_TAG))
+    {
+        return result;
+    }
+    QString host = intentUri.host();
+    trimUriSeparator(host);
+    QString path = intentUri.path();
+    if (intentUri.hasQuery())
+    {
+        path += "?" + intentUri.query();
+        trimUriSeparator(path);
+    }
+    result.host = host;
+    result.uriPath = path;
+    QStringList infos = intentUri.fragment().split(";");
+    Q_FOREACH(const QString& info, infos)
+    {
+        if (info.startsWith(INTENT_URI_PACKAGE_PREFIX))
+        {
+            result.package = info.split(INTENT_URI_PACKAGE_PREFIX)[1];
+        }
+        else if (info.startsWith(INTENT_URI_ACTION_PREFIX))
+        {
+            result.action = info.split(INTENT_URI_ACTION_PREFIX)[1];
+        }
+        else if (info.startsWith(INTENT_URI_CATEGORY_PREFIX))
+        {
+            result.category = info.split(INTENT_URI_CATEGORY_PREFIX)[1];
+        }
+        else if (info.startsWith(INTENT_URI_COMPONENT_PREFIX))
+        {
+            result.component = info.split(INTENT_URI_COMPONENT_PREFIX)[1];
+        }
+        else if (info.startsWith(INTENT_URI_SCHEME_PREFIX))
+        {
+            result.scheme = info.split(INTENT_URI_SCHEME_PREFIX)[1];
+        }
+    }
+    return result;
+}

=== added file 'src/app/webcontainer/intent-filter.h'
--- src/app/webcontainer/intent-filter.h	1970-01-01 00:00:00 +0000
+++ src/app/webcontainer/intent-filter.h	2015-02-02 14:22:27 +0000
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This file is part of webbrowser-app.
+ *
+ * webbrowser-app is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * webbrowser-app is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _INTENT_FILTER_H_
+#define _INTENT_FILTER_H_
+
+#include <QObject>
+#include <QString>
+#include <QVariantMap>
+
+
+class QUrl;
+class IntentFilterPrivate;
+struct IntentUriDescription;
+
+/**
+ * @brief The IntentFilter class
+ */
+class IntentFilter : public QObject
+{
+    Q_OBJECT
+
+public:
+    IntentFilter(const QString& content,
+            QObject *parent = 0);
+    ~IntentFilter();
+
+    /**
+     * @brief isValidLocalIntentFilterFile
+     * @return
+     */
+    static bool isValidLocalIntentFilterFile(const QString& filename);
+
+    /**
+     * @brief isValidIntentDescription
+     * @return
+     */
+    static bool isValidIntentDescription(const IntentUriDescription& );
+
+    /**
+     * @brief isValidIntentFilterResult
+     * @return
+     */
+    static bool isValidIntentFilterResult(const QVariantMap& );
+
+    /**
+     * @brief apply
+     * @return
+     */
+    Q_INVOKABLE QVariantMap applyFilter(const QString& intentUri);
+
+    /**
+     * @brief isValidIntentUri
+     * @return
+     */
+    Q_INVOKABLE bool isValidIntentUri(const QString& intentUri) const;
+
+
+private:
+
+    IntentFilterPrivate* d_ptr;
+    Q_DECLARE_PRIVATE(IntentFilter)
+};
+
+
+struct IntentUriDescription
+{
+    QString uriPath;
+
+    // optional
+    QString host;
+
+    QString package;
+    QString action;
+    QString category;
+    QString component;
+    QString scheme;
+};
+
+/**
+ * @brief Parse a URI that is supposed to be an intent as defined here
+ *
+ * https://developer.chrome.com/multidevice/android/intents
+ *
+ * @param intentUri
+ * @return
+ */
+IntentUriDescription parseIntentUri(const QUrl& intentUri);
+
+#endif // _INTENT_FILTER_H_

=== modified file 'src/app/webcontainer/url-pattern-utils.h'
--- src/app/webcontainer/url-pattern-utils.h	2015-01-19 10:00:13 +0000
+++ src/app/webcontainer/url-pattern-utils.h	2015-02-02 14:22:27 +0000
@@ -27,11 +27,25 @@
 
 namespace UrlPatternUtils {
 
+/**
+ * @brief transformWebappSearchPatternToSafePattern
+ * @param doTransformUrlPath
+ * @return
+ */
 QString transformWebappSearchPatternToSafePattern(const QString&
                                                   , bool doTransformUrlPath = true);
 
+/**
+ * @brief isLocalHtml5ApplicationHomeUrl
+ * @return
+ */
 bool isLocalHtml5ApplicationHomeUrl(const QUrl&);
 
+/**
+ * @brief filterAndTransformUrlPatterns
+ * @param includePatterns
+ * @return
+ */
 QStringList filterAndTransformUrlPatterns(const QStringList & includePatterns);
 
 }

=== modified file 'src/app/webcontainer/webapp-container.cpp'
--- src/app/webcontainer/webapp-container.cpp	2015-01-19 10:00:13 +0000
+++ src/app/webcontainer/webapp-container.cpp	2015-02-02 14:22:27 +0000
@@ -20,6 +20,7 @@
 #include "webapp-container.h"
 
 #include "chrome-cookie-store.h"
+#include "intent-filter.h"
 #include "local-cookie-store.h"
 #include "online-accounts-cookie-store.h"
 #include "session-utils.h"
@@ -104,6 +105,7 @@
 }
 
 const QString WebappContainer::URL_PATTERN_SEPARATOR = ",";
+const QString WebappContainer::LOCAL_INTENT_FILTER_FILENAME = "local-intent-filter.js";
 
 
 WebappContainer::WebappContainer(int& argc, char** argv):
@@ -212,6 +214,9 @@
             return false;
         }
 
+        // Handle an optional intent filter. The default filter does nothing.
+        setupLocalIntentFilterIfAny(context);
+
         m_component->completeCreate();
 
         return true;
@@ -220,6 +225,30 @@
     }
 }
 
+void WebappContainer::setupLocalIntentFilterIfAny(QQmlContext* context)
+{
+    if(!context)
+    {
+        return;
+    }
+
+    QString localIntentFilterFileContent;
+    if (IntentFilter::isValidLocalIntentFilterFile(LOCAL_INTENT_FILTER_FILENAME))
+    {
+        QFile f(LOCAL_INTENT_FILTER_FILENAME);
+        if (f.open(QIODevice::ReadOnly))
+        {
+            localIntentFilterFileContent = QString(f.readAll());
+        }
+        f.close();
+
+        qDebug() << "Using local intent filter file:"
+                 << LOCAL_INTENT_FILTER_FILENAME;
+    }
+    m_intentFilter.reset(new IntentFilter(localIntentFilterFileContent, NULL));
+    context->setContextProperty("webappIntentFilter", m_intentFilter.data());
+}
+
 bool WebappContainer::isValidLocalApplicationRunningContext() const
 {
     return m_webappModelSearchPath.isEmpty() &&

=== modified file 'src/app/webcontainer/webapp-container.h'
--- src/app/webcontainer/webapp-container.h	2015-01-19 10:00:13 +0000
+++ src/app/webcontainer/webapp-container.h	2015-02-02 14:22:27 +0000
@@ -28,6 +28,9 @@
 #include <QStringList>
 #include <QScopedPointer>
 
+class IntentFilter;
+class QQmlContext;
+
 class WebappContainer : public BrowserApplication
 {
     Q_OBJECT
@@ -49,6 +52,8 @@
     bool isValidLocalApplicationRunningContext() const;
     bool isValidLocalResource(const QString& resourceName) const;
     bool shouldNotValidateCommandLineUrls() const;
+    bool isValidLocalIntentFilterFile(const QString& filename) const;
+    void setupLocalIntentFilterIfAny(QQmlContext* context);
 
 private:
     QString m_webappName;
@@ -64,8 +69,10 @@
     QString m_localCookieStoreDbPath;
     QString m_userAgentOverride;
     QScopedPointer<WebappContainerHelper> m_webappContainerHelper;
+    QScopedPointer<IntentFilter> m_intentFilter;
 
     static const QString URL_PATTERN_SEPARATOR;
+    static const QString LOCAL_INTENT_FILTER_FILENAME;
 };
 
 #endif // __WEBAPP_CONTAINER_H__

=== modified file 'src/app/webcontainer/webapp-container.qml'
--- src/app/webcontainer/webapp-container.qml	2015-01-20 15:47:51 +0000
+++ src/app/webcontainer/webapp-container.qml	2015-02-02 14:22:27 +0000
@@ -32,6 +32,7 @@
 
     property string localCookieStoreDbPath: ""
 
+    property var intentFilterHandler
     property string url: ""
     property string webappName: ""
     property string webappModelSearchPath: ""
@@ -50,6 +51,9 @@
 
     title: getWindowTitle()
 
+    // Used for testing
+    signal intentUriHandleResult(string uri)
+
     function getWindowTitle() {
         var webappViewTitle =
                 webappViewLoader.item
@@ -274,6 +278,63 @@
         webappViewLoader.sourceComponent = webappViewComponent
     }
 
+    function makeUrlFromIntentResult(intentFilterResult) {
+        var scheme = null
+        var hostname = null
+        var url = root.currentWebview.url || root.url
+        if (intentFilterResult.host
+                && intentFilterResult.host.length !== 0) {
+            hostname = intentFilterResult.host
+        }
+        else {
+            var matchHostname = url.toString().match(/.*:\/\/([^/]*)\/.*/)
+            if (matchHostname.length > 1) {
+                hostname = matchHostname[1]
+            }
+        }
+        if (intentFilterResult.scheme
+                && intentFilterResult.scheme.length !== 0) {
+            scheme = intentFilterResult.scheme
+        }
+        else {
+            var matchScheme = url.toString().match(/(.*):\/\/[^/]*\/.*/)
+            if (matchScheme.length > 1) {
+                scheme = matchScheme[1]
+            }
+        }
+        return scheme
+                + '://'
+                + hostname
+                + "/"
+                + (intentFilterResult.uri
+                    ? intentFilterResult.uri : "")
+    }
+
+    /**
+     * Identity function for non-intent URIs.
+     *
+     * Otherwise if the URI is an intent, tries to apply a webapp
+     * local filter (or identity) and reconstruct the target URI based
+     * on its result.
+     */
+    function handleIntentUri(uri) {
+        var _uri = uri;
+        if (webappIntentFilter
+                && webappIntentFilter.isValidIntentUri(_uri)) {
+            var result = webappIntentFilter.applyFilter(_uri)
+            _uri = makeUrlFromIntentResult(result)
+
+            console.log("Intent URI '" + uri + "' was mapped to '" + _uri + "'")
+        }
+
+        // Report the result of the intent uri filtering (if any)
+        // Done for testing purposed. It is not possible at this point
+        // to have AP call a slot and retrieve its result synchronously.
+        intentUriHandleResult(_uri)
+
+        return _uri
+    }
+
     // Handle runtime requests to open urls as defined
     // by the freedesktop application dbus interface's open
     // method for DBUS application activation:
@@ -294,6 +355,15 @@
                 return;
             }
 
+            requestedUrl = handleIntentUri(requestedUrl);
+
+            // Add a small guard to prevent browsing to invalid urls
+            if (currentWebview
+                    && currentWebview.shouldAllowNavigationTo
+                    && !currentWebview.shouldAllowNavigationTo(requestedUrl)) {
+                return;
+            }
+
             root.url = requestedUrl
             root.currentWebview.url = requestedUrl
         }

=== modified file 'tests/autopilot/webapp_container/tests/__init__.py'
--- tests/autopilot/webapp_container/tests/__init__.py	2015-01-19 10:00:13 +0000
+++ tests/autopilot/webapp_container/tests/__init__.py	2015-02-02 14:22:27 +0000
@@ -20,7 +20,7 @@
 
 from autopilot.testcase import AutopilotTestCase
 from autopilot.platform import model
-from testtools.matchers import Equals
+from testtools.matchers import Equals, GreaterThan
 from autopilot.matchers import Eventually
 
 import ubuntuuitoolkit as uitk
@@ -94,6 +94,19 @@
                         Eventually(Equals(100), timeout=20))
         self.assertThat(webview.loading, Eventually(Equals(False)))
 
+    def get_intent_filtered_uri(self, uri):
+        webviewContainer = self.get_webcontainer_window()
+        watcher = webviewContainer.watch_signal(
+            'intentUriHandleResult(QString)')
+        previous = watcher.num_emissions
+        webviewContainer.slots.handleIntentUri(uri)
+        self.assertThat(
+            lambda: watcher.num_emissions,
+            Eventually(GreaterThan(previous)))
+        result = webviewContainer.get_signal_emissions(
+            'intentUriHandleResult(QString)')[-1][0]
+        return result
+
     def browse_to(self, url):
         webview = self.get_oxide_webview()
         webview.url = url

=== added file 'tests/autopilot/webapp_container/tests/test_intent_uri_support.py'
--- tests/autopilot/webapp_container/tests/test_intent_uri_support.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/webapp_container/tests/test_intent_uri_support.py	2015-02-02 14:22:27 +0000
@@ -0,0 +1,116 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2014 Canonical
+#
+# This program 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.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+from contextlib import contextmanager
+import os
+import tempfile
+import shutil
+
+from testtools.matchers import Equals
+from autopilot.matchers import Eventually
+
+from webapp_container.tests import WebappContainerTestCaseWithLocalContentBase
+
+
+@contextmanager
+def generate_temp_webapp_with_intent(intent_filter_content=""):
+    tmpdir = tempfile.mkdtemp()
+    manifest_content = """
+    {
+        "includes": ["http://www.test.com/*"],
+        "name": "test",
+        "domain":"",
+        "homepage":"http://www.test.com/"
+    }
+    """
+    manifest_file = "{}/webapp-properties.json".format(tmpdir)
+    with open(manifest_file, "w+") as f:
+        f.write(manifest_content)
+    if len(intent_filter_content) != 0:
+        intent_filter_file = "{}/local-intent-filter.js".format(tmpdir)
+        with open(intent_filter_file, "w+") as f:
+            f.write(intent_filter_content)
+    old_cwd = os.getcwd()
+    try:
+        os.chdir(tmpdir)
+        yield tmpdir
+    finally:
+        os.chdir(old_cwd)
+        shutil.rmtree(tmpdir)
+
+
+# Those tests rely on get_intent_filtered_uri() which
+# relies on implementation detail to trigger part of the intent handling
+# code. This comes from the fact that the url-dispatcher is not easily
+# instrumentable , so a full feature flow coverage is quite tricky to get.
+# Those tests are not really functional in that sense.
+class WebappContainerIntentUriSupportTestCase(
+        WebappContainerTestCaseWithLocalContentBase):
+    def test_basic_intent_parsing(self):
+        rule = 'MAP *.test.com:80 ' + self.get_base_url_hostname()
+        with generate_temp_webapp_with_intent() as webapp_install_path:
+            args = ['--webappModelSearchPath='+webapp_install_path]
+            self.launch_webcontainer_app(
+                args,
+                {'UBUNTU_WEBVIEW_HOST_MAPPING_RULES': rule})
+            webview = self.get_oxide_webview()
+            webapp_url = 'http://www.test.com/'
+            self.assertThat(webview.url, Eventually(Equals(webapp_url)))
+
+            intent_uri = 'intent://maps.google.es/maps?ie=utf-8&gl=es\
+#Intent;scheme=http;package=com.google.android.apps.maps;end'
+            self.assertThat(
+                'http://maps.google.es/maps?ie=utf-8&gl=es',
+                Equals(self.get_intent_filtered_uri(intent_uri)))
+
+    def test_webapp_with_invalid_default_local_intent(self):
+        rule = 'MAP *.test.com:80 ' + self.get_base_url_hostname()
+        filter = "1"
+        with generate_temp_webapp_with_intent(filter) as webapp_install_path:
+            args = ['--webappModelSearchPath='+webapp_install_path]
+            self.launch_webcontainer_app(
+                args,
+                {'UBUNTU_WEBVIEW_HOST_MAPPING_RULES': rule})
+            webview = self.get_oxide_webview()
+            webapp_url = 'http://www.test.com/'
+            self.assertThat(webview.url, Eventually(Equals(webapp_url)))
+
+            intent_uri = 'intent://www.test.com/maps?ie=utf-8&gl=es\
+#Intent;scheme=http;package=com.google.android.apps.maps;end'
+            self.assertThat(
+                'http://www.test.com/maps?ie=utf-8&gl=es',
+                Equals(self.get_intent_filtered_uri(intent_uri)))
+
+    def test_with_valid_default_local_intent(self):
+        rule = 'MAP *.test.com:80 ' + self.get_base_url_hostname()
+        filter = "(function(r) { \
+            return { \
+                'scheme': 'https', \
+                'host': 'maps.test.com', \
+                'uri': r.uri }; })"
+        with generate_temp_webapp_with_intent(filter) as webapp_install_path:
+            args = ['--webappModelSearchPath='+webapp_install_path]
+            self.launch_webcontainer_app(
+                args,
+                {'UBUNTU_WEBVIEW_HOST_MAPPING_RULES': rule})
+            webview = self.get_oxide_webview()
+            webapp_url = 'http://www.test.com/'
+            self.assertThat(webview.url, Eventually(Equals(webapp_url)))
+
+            intent_uri = 'intent://www.test.com/maps?ie=utf-8&gl=es\
+#Intent;scheme=http;package=com.google.android.apps.maps;end'
+            self.assertThat(
+                'https://maps.test.com/maps?ie=utf-8&gl=es',
+                Equals(self.get_intent_filtered_uri(intent_uri)))

=== modified file 'tests/unittests/CMakeLists.txt'
--- tests/unittests/CMakeLists.txt	2015-01-19 10:00:13 +0000
+++ tests/unittests/CMakeLists.txt	2015-02-02 14:22:27 +0000
@@ -18,3 +18,4 @@
 add_subdirectory(session-storage)
 add_subdirectory(favicon-fetcher)
 add_subdirectory(webapp-container-hook)
+add_subdirectory(intent-filter)

=== added directory 'tests/unittests/intent-filter'
=== added file 'tests/unittests/intent-filter/CMakeLists.txt'
--- tests/unittests/intent-filter/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/unittests/intent-filter/CMakeLists.txt	2015-02-02 14:22:27 +0000
@@ -0,0 +1,9 @@
+set(TEST tst_IntentFilterTests)
+set(SOURCES
+    ${webapp-container_SOURCE_DIR}/intent-filter.cpp
+    tst_IntentFilterTests.cpp
+)
+include_directories(${webapp-container_SOURCE_DIR})
+add_executable(${TEST} ${SOURCES})
+qt5_use_modules(${TEST} Core Test Qml)
+add_test(${TEST} ${CMAKE_CURRENT_BINARY_DIR}/${TEST} -xunitxml -o ${TEST}.xml)

=== added file 'tests/unittests/intent-filter/tst_IntentFilterTests.cpp'
--- tests/unittests/intent-filter/tst_IntentFilterTests.cpp	1970-01-01 00:00:00 +0000
+++ tests/unittests/intent-filter/tst_IntentFilterTests.cpp	2015-02-02 14:22:27 +0000
@@ -0,0 +1,218 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This file is part of webbrowser-app.
+ *
+ * webbrowser-app is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * webbrowser-app is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Qt
+#include <QtCore/QString>
+#include <QtTest/QtTest>
+
+// local
+#include "intent-filter.h"
+
+class IntentFilterTests : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+
+    void parseIntentUris_data()
+    {
+        QTest::addColumn<QString>("intentUris");
+
+        QTest::addColumn<QString>("scheme");
+        QTest::addColumn<QString>("package");
+        QTest::addColumn<QString>("uri");
+        QTest::addColumn<QString>("host");
+        QTest::addColumn<QString>("action");
+        QTest::addColumn<QString>("component");
+        QTest::addColumn<QString>("category");
+
+        QTest::addColumn<bool>("isValid");
+
+        QTest::newRow("Valid intent - host only")
+                << "intent://scan/#Intent;component=com;scheme=zxing;category=BROWSABLE;action=com;package=com.google.zxing.client.android;end"
+                << "zxing"
+                << "com.google.zxing.client.android"
+                << "/"
+                << "scan"
+                << "com"
+                << "com"
+                << "BROWSABLE"
+                << true;
+
+        QTest::newRow("Valid intent - no host w/ uri")
+                << "intent://scan/?a=1/#Intent;component=com;scheme=zxing;category=BROWSABLE;action=com;package=com.google.zxing.client.android;end"
+                << "zxing"
+                << "com.google.zxing.client.android"
+                << "?a=1"
+                << "scan"
+                << "com"
+                << "com"
+                << "BROWSABLE"
+                << true;
+
+        QTest::newRow("Valid intent - w/ host")
+                << "intent://host/my/long/path?a=1/#Intent;component=com;scheme=zxing;category=BROWSABLE;action=com;package=com.google.zxing.client.android;end"
+                << "zxing"
+                << "com.google.zxing.client.android"
+                << "my/long/path?a=1"
+                << "host"
+                << "com"
+                << "com"
+                << "BROWSABLE"
+                << true;
+
+        QTest::newRow("Valid intent - w/o host & uri-path")
+                << "intent://#Intent;scheme=trusper.referrertests;package=trusper.referrertests;end"
+                << "trusper.referrertests"
+                << "trusper.referrertests"
+                << ""
+                << ""
+                << ""
+                << ""
+                << ""
+                << true;
+
+        QTest::newRow("Valid intent - w/o host & uri-path and extra /")
+                << "intent:///#Intent;component=com;scheme=zxing;category=BROWSABLE;action=com;package=com.google.zxing.client.android;end"
+                << "zxing"
+                << "com.google.zxing.client.android"
+                << "/"
+                << ""
+                << "com"
+                << "com"
+                << "BROWSABLE"
+                << true;
+
+        QTest::newRow("Valid intent - w/o host & uri-path impler syntax")
+                << "intent://#Intent;component=com;scheme=zxing;category=BROWSABLE;action=com;package=com.google.zxing.client.android;end"
+                << "zxing"
+                << "com.google.zxing.client.android"
+                << ""
+                << ""
+                << "com"
+                << "com"
+                << "BROWSABLE"
+                << true;
+
+        QTest::newRow("Invalid intent")
+                << "intent:///#Inttent;component=com;scheme=zxing;category=BROWSABLE;action=com;package=com.google.zxing.client.android;end"
+                << ""
+                << ""
+                << ""
+                << ""
+                << ""
+                << ""
+                << ""
+                << false;
+    }
+
+    void parseIntentUris()
+    {
+        QFETCH(QString, intentUris);
+
+        QFETCH(QString, scheme);
+        QFETCH(QString, package);
+        QFETCH(QString, uri);
+        QFETCH(QString, host);
+        QFETCH(QString, action);
+        QFETCH(QString, component);
+        QFETCH(QString, category);
+
+        QFETCH(bool, isValid);
+
+        IntentUriDescription d = parseIntentUri(intentUris);
+
+        QCOMPARE(d.scheme, scheme);
+        QCOMPARE(d.package, package);
+        QCOMPARE(d.uriPath, uri);
+        QCOMPARE(d.host, host);
+        QCOMPARE(d.action, action);
+        QCOMPARE(d.component, component);
+        QCOMPARE(d.category, category);
+
+        QVERIFY(IntentFilter::isValidIntentDescription(d) == isValid);
+
+        QString emptyContent;
+        IntentFilter pf(emptyContent);
+        QVERIFY(pf.isValidIntentUri(intentUris) == isValid);
+    }
+
+    void applyFilters_data()
+    {
+        QTest::addColumn<QString>("intentUris");
+
+        QTest::addColumn<QString>("filterFunctionSource");
+
+        QTest::addColumn<QString>("scheme");
+        QTest::addColumn<QString>("uri");
+        QTest::addColumn<QString>("host");
+
+        QTest::newRow("Valid intent - default filter function")
+                << "intent://scan/#Intent;component=com;scheme=zxing;category=BROWSABLE;action=com;package=com.google.zxing.client.android;end"
+                <<  ""
+                << "zxing"
+                << "/"
+                << "scan";
+
+        QTest::newRow("Valid intent - default filter function")
+                << "intent://scan/#Intent;component=com;scheme=zxing;category=BROWSABLE;action=com;package=com.google.zxing.client.android;end"
+                <<  "(function(result) {return {'scheme': result.scheme+'custom', 'uri': result.uri+'custom', 'host': result.host+'custom'}; })"
+                << "zxingcustom"
+                << "/custom"
+                << "scancustom";
+
+        QTest::newRow("Valid intent - no (optional) host in filter result")
+                << "intent://host/my/long/path?a=1/#Intent;component=com;scheme=zxing;category=BROWSABLE;action=com;package=com.google.zxing.client.android;end"
+                <<  "(function(result) {return {'scheme': result.scheme+'custom', 'uri': result.uri+'custom' }; })"
+                << "zxingcustom"
+                << "my/long/path?a=1custom"
+                << "";
+
+        QTest::newRow("Valid intent - invalid filter fallback to default")
+                << "intent://host/my/long/path?a=1/#Intent;component=com;scheme=zxing;category=BROWSABLE;action=com;package=com.google.zxing.client.android;end"
+                <<  "(function(result) {return { 'uri': result.uri+'custom' }; })"
+                << "zxing"
+                << "my/long/path?a=1"
+                << "host";
+    }
+
+    void applyFilters()
+    {
+        QFETCH(QString, intentUris);
+
+        QFETCH(QString, filterFunctionSource);
+
+        QFETCH(QString, scheme);
+        QFETCH(QString, uri);
+        QFETCH(QString, host);
+
+        IntentFilter pf(filterFunctionSource);
+        QVERIFY(pf.isValidIntentUri(intentUris));
+
+        QVariantMap r = pf.applyFilter(intentUris);
+        QVERIFY(r.contains("scheme"));
+        QVERIFY(r.contains("uri"));
+
+        QCOMPARE(r.value("scheme").toString(), scheme);
+        QCOMPARE(r.value("host").toString(), host);
+        QCOMPARE(r.value("uri").toString(), uri);
+    }
+};
+
+QTEST_MAIN(IntentFilterTests)
+#include "tst_IntentFilterTests.moc"