Added plugin directory as well to make sure you have all you need to compile (hopefully)

11 files changed, 1221 insertions, 0 deletions

diff --git a/plugins/cordova-plugin-crosswalk-webview/LICENSE b/plugins/cordova-plugin-crosswalk-webview/LICENSE
new file mode 100644
index 00000000..578fa3bb
--- /dev/null
+++ b/plugins/cordova-plugin-crosswalk-webview/LICENSE
@@ -0,0 +1,235 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+/************************************************/
+This product bundles CordovaXWalkCoreExtensionBridge.java as well
+as the XWalk.pak and the Crosswalk JSApi which is available under a
+"3-clause BSD" license.  For details, see below:
+
+ Copyright (c) 2013 Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+    * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following disclaimer
+ in the documentation and/or other materials provided with the
+ distribution.
+    * Neither the name of Intel Corporation nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/plugins/cordova-plugin-crosswalk-webview/NOTICE b/plugins/cordova-plugin-crosswalk-webview/NOTICE
new file mode 100644
index 00000000..81636de1
--- /dev/null
+++ b/plugins/cordova-plugin-crosswalk-webview/NOTICE
@@ -0,0 +1,8 @@
+Apache Cordova
+Copyright 2014 The Apache Software Foundation
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org)
+
+This software includes software developed at Intel Corporation.
+Copyright 2014 Intel Corporation
diff --git a/plugins/cordova-plugin-crosswalk-webview/README.md b/plugins/cordova-plugin-crosswalk-webview/README.md
new file mode 100644
index 00000000..c2b25f57
--- /dev/null
+++ b/plugins/cordova-plugin-crosswalk-webview/README.md
@@ -0,0 +1,83 @@
+
+
+Apache Cordova Crosswalk Engine
+===
+
+Cordova Crosswalk Engine is a [Crosswalk WebView](https://crosswalk-project.org/) based engine to work with [Apache Cordova](http://cordova.apache.org/) for Android. This currently works with master branch of [Cordova Android](https://github.com/apache/cordova-android) on GitHub, and it will work with Apache Cordova Android 4.0.0 release.
+
+### Directions:
+#### Android-only:
+* Pull down the Cordova Android
+```
+$ git clone https://github.com/apache/cordova-android.git
+```
+* Generate a project, e.g creating HelloWorld
+```
+$ /path/to/cordova-android/bin/create hello com.example.hello HelloWorld
+```
+* Navigate to the project folder
+```
+$ cd hello
+```
+* Install Crosswalk engine plugin by plugman (version >= 0.22.17)
+```
+$ plugman install --platform android --plugin https://github.com/MobileChromeApps/cordova-crosswalk-engine.git --project .
+```
+* Build
+```
+$ ./cordova/build
+```
+The build script will automatically fetch the Crosswalk WebView libraries from Crosswalk project download site (https://download.01.org/crosswalk/releases/crosswalk/android/) and build for both X86 and ARM architectures. 
+
+For example, building HelloWorld generates:
+
+```
+/path/to/hello/build/outputs/apk/hello-x86-debug.apk
+/path/to/hello/build/outputs/apk/hello-armv7-debug.apk
+```
+
+#### Cordova CLI:
+(It will be updated after cordova-android 4.0.0 release with CLI)
+
+* Install the latest version of the Cordova CLI from npm (version >= 4.2.0)
+```
+$ npm install -g cordova
+```
+* Create a project with cordova create, e.g creating HelloWorld
+```
+$ cordova create hello com.example.hello HelloWorld
+```
+* Navigate to the project folder
+```
+$ cd hello
+```
+* Add the Android platform @4.0.0-dev
+```
+$ cordova platform add https://github.com/apache/cordova-android.git
+```
+* Add the Crosswalk engine plugin
+```
+$ cordova plugin add  https://github.com/MobileChromeApps/cordova-crosswalk-engine.git
+```
+* Build
+```
+$ cordova build android
+```
+The build script will automatically fetch the Crosswalk WebView libraries from Crosswalk project download site (https://download.01.org/crosswalk/releases/crosswalk/android/) and build for both X86 and ARM architectures.
+
+For example, building android with Crosswalk generates:
+
+```
+/path/to/hello/platforms/android/build/outputs/apk/hello-x86-debug.apk
+/path/to/hello/platforms/android/build/outputs/apk/hello-armv7-debug.apk
+```
+
+Note that it is also possible to publish a multi-APK application on the Play Store that uses Crosswalk for Pre-L devices, and the (updatable) system webview for L+:
+
+To build Crosswalk-enabled apks, add this plugin and run:
+
+    $ cordova build --release
+
+To build System-webview apk, remove this plugin and run:
+
+    $ cordova build --release -- --android-minSdkVersion=21
diff --git a/plugins/cordova-plugin-crosswalk-webview/package.json b/plugins/cordova-plugin-crosswalk-webview/package.json
new file mode 100644
index 00000000..e67c6413
--- /dev/null
+++ b/plugins/cordova-plugin-crosswalk-webview/package.json
@@ -0,0 +1,40 @@
+{
+  "name": "cordova-plugin-crosswalk-webview",
+  "version": "1.0.1-dev",
+  "description": "Changes the default WebView to CrossWalk",
+  "cordova": {
+    "id": "cordova-plugin-crosswalk-webview",
+    "platforms": [
+      "android"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MobileChromeApps/cordova-crosswalk-engine.git"
+  },
+  "keywords": [
+    "cordova",
+    "chromium",
+    "crosswalk",
+    "webview",
+    "engine",
+    "ecosystem:cordova",
+    "cordova-android"
+  ],
+  "engines": [
+    {
+      "name": "cordova-android",
+      "version": ">=4"
+    },
+    {
+      "name": "cordova-plugman",
+      "version": ">=4.2.0"
+    }
+  ],
+  "author": "",
+  "license": "Apache 2.0",
+  "bugs": {
+    "url": "https://github.com/MobileChromeApps/cordova-crosswalk-engine/issues"
+  },
+  "homepage": "https://github.com/MobileChromeApps/cordova-crosswalk-engine"
+}
diff --git a/plugins/cordova-plugin-crosswalk-webview/plugin.xml b/plugins/cordova-plugin-crosswalk-webview/plugin.xml
new file mode 100644
index 00000000..8fd3e478
--- /dev/null
+++ b/plugins/cordova-plugin-crosswalk-webview/plugin.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
+           id="cordova-plugin-crosswalk-webview"
+      version="1.0.1-dev">
+
+    <name>Crosswalk WebView Engine</name>
+    <description>Changes the default WebView to CrossWalk</description>
+    <license>Apache 2.0</license>
+    <keywords>cordova,chromium,crosswalk,webview</keywords>
+    <repo>https://github.com/MobileChromeApps/cordova-crosswalk-engine.git</repo>
+    <issue>https://github.com/MobileChromeApps/cordova-crosswalk-engine/issues</issue>
+
+    <engines>
+      <engine name="cordova-android" version=">=4" />
+      <engine name="cordova-plugman" version=">=4.2.0" /><!-- needed for gradleReference support -->
+    </engines>
+
+    <platform name="android">
+        <config-file target="res/xml/config.xml" parent="/*">
+            <preference name="webView" value="org.crosswalk.engine.XWalkWebViewEngine" />
+        </config-file>
+
+        <source-file src="src/android/XWalkWebViewEngine.java" target-dir="src/org/crosswalk/engine" />
+        <source-file src="src/android/XWalkExposedJsApi.java" target-dir="src/org/crosswalk/engine" />
+        <source-file src="src/android/XWalkCordovaResourceClient.java" target-dir="src/org/crosswalk/engine" />
+        <source-file src="src/android/XWalkCordovaUiClient.java" target-dir="src/org/crosswalk/engine" />
+        <source-file src="src/android/XWalkCordovaView.java" target-dir="src/org/crosswalk/engine" />
+        <source-file src="src/android/XWalkCordovaCookieManager.java" target-dir="src/org/crosswalk/engine" />
+
+        <framework src="libs/xwalk_core_library" custom="true" />
+    </platform>
+</plugin>
diff --git a/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkCordovaCookieManager.java b/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkCordovaCookieManager.java
new file mode 100644
index 00000000..43f170d2
--- /dev/null
+++ b/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkCordovaCookieManager.java
@@ -0,0 +1,53 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+package org.crosswalk.engine;
+
+import org.apache.cordova.ICordovaCookieManager;
+import org.xwalk.core.internal.XWalkCookieManager;
+
+class XWalkCordovaCookieManager implements ICordovaCookieManager {
+
+    protected XWalkCookieManager cookieManager = null;
+
+    public XWalkCordovaCookieManager() {
+        cookieManager = new XWalkCookieManager();
+    }
+
+    public void setCookiesEnabled(boolean accept) {
+        cookieManager.setAcceptCookie(accept);
+    }
+
+    public void setCookie(final String url, final String value) {
+        cookieManager.setCookie(url, value);
+    }
+
+    public String getCookie(final String url) {
+        return cookieManager.getCookie(url);
+    }
+
+    public void clearCookies() {
+        cookieManager.removeAllCookie();
+    }
+
+    public void flush() {
+        cookieManager.flushCookieStore();
+    }
+};
+
+
diff --git a/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkCordovaResourceClient.java b/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkCordovaResourceClient.java
new file mode 100644
index 00000000..57d0b0f9
--- /dev/null
+++ b/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkCordovaResourceClient.java
@@ -0,0 +1,231 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+package org.crosswalk.engine;
+
+import android.net.Uri;
+import android.webkit.WebResourceResponse;
+
+import org.apache.cordova.CordovaResourceApi;
+import org.apache.cordova.CordovaResourceApi.OpenForReadResult;
+import org.apache.cordova.LOG;
+import org.chromium.net.NetError;
+import org.xwalk.core.XWalkResourceClient;
+import org.xwalk.core.XWalkView;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+public class XWalkCordovaResourceClient extends XWalkResourceClient {
+
+	private static final String TAG = "XWalkCordovaResourceClient";
+    protected XWalkWebViewEngine parentEngine;
+
+    // Success
+    public static final int ERROR_OK = 0;
+    // Generic error
+    public static final int ERROR_UNKNOWN = -1;
+    // Server or proxy hostname lookup failed
+    public static final int ERROR_HOST_LOOKUP = -2;
+    // Unsupported authentication scheme (not basic or digest)
+    public static final int ERROR_UNSUPPORTED_AUTH_SCHEME = -3;
+    // User authentication failed on server
+    public static final int ERROR_AUTHENTICATION = -4;
+    // User authentication failed on proxy
+    public static final int ERROR_PROXY_AUTHENTICATION = -5;
+    // Failed to connect to the server
+    public static final int ERROR_CONNECT = -6;
+    // Failed to read or write to the server
+    public static final int ERROR_IO = -7;
+    // Connection timed out
+    public static final int ERROR_TIMEOUT = -8;
+    // Too many redirects
+    public static final int ERROR_REDIRECT_LOOP = -9;
+    // Unsupported URI scheme
+    public static final int ERROR_UNSUPPORTED_SCHEME = -10;
+    // Failed to perform SSL handshake
+    public static final int ERROR_FAILED_SSL_HANDSHAKE = -11;
+    // Malformed URL
+    public static final int ERROR_BAD_URL = -12;
+    // Generic file error
+    public static final int ERROR_FILE = -13;
+    // File not found
+    public static final int ERROR_FILE_NOT_FOUND = -14;
+    // Too many requests during this load
+    public static final int ERROR_TOO_MANY_REQUESTS = -15;
+
+    public XWalkCordovaResourceClient(XWalkWebViewEngine parentEngine) {
+        super(parentEngine.webView);
+        this.parentEngine = parentEngine;
+    }
+
+    // Map XWalk error code about loading a page to Android specific ones.
+    // XWalk shares the error code with chromium currently.
+    static int convertErrorCode(int netError) {
+        // Note: many NetError.Error constants don't have an obvious mapping.
+        // These will be handled by the default case, ERROR_UNKNOWN.
+        switch (netError) {
+            case NetError.ERR_UNSUPPORTED_AUTH_SCHEME:
+                return ERROR_UNSUPPORTED_AUTH_SCHEME;
+
+            case NetError.ERR_INVALID_AUTH_CREDENTIALS:
+            case NetError.ERR_MISSING_AUTH_CREDENTIALS:
+            case NetError.ERR_MISCONFIGURED_AUTH_ENVIRONMENT:
+                return ERROR_AUTHENTICATION;
+
+            case NetError.ERR_TOO_MANY_REDIRECTS:
+                return ERROR_REDIRECT_LOOP;
+
+            case NetError.ERR_UPLOAD_FILE_CHANGED:
+                return ERROR_FILE_NOT_FOUND;
+
+            case NetError.ERR_INVALID_URL:
+                return ERROR_BAD_URL;
+
+            case NetError.ERR_DISALLOWED_URL_SCHEME:
+            case NetError.ERR_UNKNOWN_URL_SCHEME:
+                return ERROR_UNSUPPORTED_SCHEME;
+
+            case NetError.ERR_IO_PENDING:
+            case NetError.ERR_NETWORK_IO_SUSPENDED:
+                return ERROR_IO;
+
+            case NetError.ERR_CONNECTION_TIMED_OUT:
+            case NetError.ERR_TIMED_OUT:
+                return ERROR_TIMEOUT;
+
+            case NetError.ERR_FILE_TOO_BIG:
+                return ERROR_FILE;
+
+            case NetError.ERR_HOST_RESOLVER_QUEUE_TOO_LARGE:
+            case NetError.ERR_INSUFFICIENT_RESOURCES:
+            case NetError.ERR_OUT_OF_MEMORY:
+                return ERROR_TOO_MANY_REQUESTS;
+
+            case NetError.ERR_CONNECTION_CLOSED:
+            case NetError.ERR_CONNECTION_RESET:
+            case NetError.ERR_CONNECTION_REFUSED:
+            case NetError.ERR_CONNECTION_ABORTED:
+            case NetError.ERR_CONNECTION_FAILED:
+            case NetError.ERR_SOCKET_NOT_CONNECTED:
+                return ERROR_CONNECT;
+
+            case NetError.ERR_INTERNET_DISCONNECTED:
+            case NetError.ERR_ADDRESS_INVALID:
+            case NetError.ERR_ADDRESS_UNREACHABLE:
+            case NetError.ERR_NAME_NOT_RESOLVED:
+            case NetError.ERR_NAME_RESOLUTION_FAILED:
+                return ERROR_HOST_LOOKUP;
+
+            case NetError.ERR_SSL_PROTOCOL_ERROR:
+            case NetError.ERR_SSL_CLIENT_AUTH_CERT_NEEDED:
+            case NetError.ERR_TUNNEL_CONNECTION_FAILED:
+            case NetError.ERR_NO_SSL_VERSIONS_ENABLED:
+            case NetError.ERR_SSL_VERSION_OR_CIPHER_MISMATCH:
+            case NetError.ERR_SSL_RENEGOTIATION_REQUESTED:
+            case NetError.ERR_CERT_ERROR_IN_SSL_RENEGOTIATION:
+            case NetError.ERR_BAD_SSL_CLIENT_AUTH_CERT:
+            case NetError.ERR_SSL_NO_RENEGOTIATION:
+            case NetError.ERR_SSL_DECOMPRESSION_FAILURE_ALERT:
+            case NetError.ERR_SSL_BAD_RECORD_MAC_ALERT:
+            case NetError.ERR_SSL_UNSAFE_NEGOTIATION:
+            case NetError.ERR_SSL_WEAK_SERVER_EPHEMERAL_DH_KEY:
+            case NetError.ERR_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED:
+            case NetError.ERR_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY:
+                return ERROR_FAILED_SSL_HANDSHAKE;
+
+            case NetError.ERR_PROXY_AUTH_UNSUPPORTED:
+            case NetError.ERR_PROXY_AUTH_REQUESTED:
+            case NetError.ERR_PROXY_CONNECTION_FAILED:
+            case NetError.ERR_UNEXPECTED_PROXY_AUTH:
+                return ERROR_PROXY_AUTHENTICATION;
+
+            // The certificate errors are handled by onReceivedSslError
+            // and don't need to be reported here.
+            case NetError.ERR_CERT_COMMON_NAME_INVALID:
+            case NetError.ERR_CERT_DATE_INVALID:
+            case NetError.ERR_CERT_AUTHORITY_INVALID:
+            case NetError.ERR_CERT_CONTAINS_ERRORS:
+            case NetError.ERR_CERT_NO_REVOCATION_MECHANISM:
+            case NetError.ERR_CERT_UNABLE_TO_CHECK_REVOCATION:
+            case NetError.ERR_CERT_REVOKED:
+            case NetError.ERR_CERT_INVALID:
+            case NetError.ERR_CERT_WEAK_SIGNATURE_ALGORITHM:
+            case NetError.ERR_CERT_NON_UNIQUE_NAME:
+                return ERROR_OK;
+
+            default:
+                return ERROR_UNKNOWN;
+        }
+    }
+
+    /**
+    * Report an error to the host application. These errors are unrecoverable (i.e. the main resource is unavailable).
+    * The errorCode parameter corresponds to one of the ERROR_* constants.
+    *
+    * @param view          The WebView that is initiating the callback.
+    * @param errorCode     The error code corresponding to an ERROR_* value.
+    * @param description   A String describing the error.
+    * @param failingUrl    The url that failed to load.
+    */
+    @Override
+    public void onReceivedLoadError(XWalkView view, int errorCode, String description,
+           String failingUrl) {
+        LOG.d(TAG, "CordovaWebViewClient.onReceivedError: Error code=%s Description=%s URL=%s", errorCode, description, failingUrl);
+
+        // Convert the XWalk error code to Cordova error code, which follows the Android spec,
+        // http://developer.android.com/reference/android/webkit/WebViewClient.html.
+        errorCode = XWalkCordovaResourceClient.convertErrorCode(errorCode);
+        parentEngine.client.onReceivedError(errorCode, description, failingUrl);
+    }
+
+    @Override
+    public WebResourceResponse shouldInterceptLoadRequest(XWalkView view, String url) {
+        try {
+            // Check the against the white-list.
+            if (!parentEngine.pluginManager.shouldAllowRequest(url)) {
+                LOG.w(TAG, "URL blocked by whitelist: " + url);
+                // Results in a 404.
+                return new WebResourceResponse("text/plain", "UTF-8", null);
+            }
+
+            CordovaResourceApi resourceApi = parentEngine.resourceApi;
+            Uri origUri = Uri.parse(url);
+            // Allow plugins to intercept WebView requests.
+            Uri remappedUri = resourceApi.remapUri(origUri);
+
+            if (!origUri.equals(remappedUri)) {
+                OpenForReadResult result = resourceApi.openForRead(remappedUri, true);
+                return new WebResourceResponse(result.mimeType, "UTF-8", result.inputStream);
+            }
+            // If we don't need to special-case the request, let the browser load it.
+            return null;
+        } catch (IOException e) {
+            if (!(e instanceof FileNotFoundException)) {
+                LOG.e(TAG, "Error occurred while loading a file (returning a 404).", e);
+            }
+            // Results in a 404.
+            return new WebResourceResponse("text/plain", "UTF-8", null);
+        }
+    }
+
+    @Override
+    public boolean shouldOverrideUrlLoading(XWalkView view, String url) {
+        return parentEngine.client.onNavigationAttempt(url);
+    }
+}
diff --git a/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkCordovaUiClient.java b/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkCordovaUiClient.java
new file mode 100644
index 00000000..a5a20b70
--- /dev/null
+++ b/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkCordovaUiClient.java
@@ -0,0 +1,193 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+package org.crosswalk.engine;
+
+import android.app.Activity;
+import android.content.ActivityNotFoundException;
+import android.content.Intent;
+import android.net.Uri;
+import android.util.Log;
+import android.webkit.ValueCallback;
+
+import org.apache.cordova.CordovaDialogsHelper;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.LOG;
+import org.xwalk.core.XWalkJavascriptResult;
+import org.xwalk.core.XWalkUIClient;
+import org.xwalk.core.XWalkView;
+
+public class XWalkCordovaUiClient extends XWalkUIClient {
+    private static final String TAG = "XWalkCordovaUiClient";
+    protected final CordovaDialogsHelper dialogsHelper;
+    protected final XWalkWebViewEngine parentEngine;
+
+    private static final int FILECHOOSER_RESULTCODE = 5173;
+
+    public XWalkCordovaUiClient(XWalkWebViewEngine parentEngine) {
+        super(parentEngine.webView);
+        this.parentEngine = parentEngine;
+        dialogsHelper = new CordovaDialogsHelper(parentEngine.webView.getContext());
+    }
+
+    @Override
+    public boolean onJavascriptModalDialog(XWalkView view, JavascriptMessageType type, String url,
+                                           String message, String defaultValue, XWalkJavascriptResult result) {
+        switch (type) {
+            case JAVASCRIPT_ALERT:
+                return onJsAlert(view, url, message, result);
+            case JAVASCRIPT_CONFIRM:
+                return onJsConfirm(view, url, message, result);
+            case JAVASCRIPT_PROMPT:
+                return onJsPrompt(view, url, message, defaultValue, result);
+            case JAVASCRIPT_BEFOREUNLOAD:
+                // Reuse onJsConfirm to show the dialog.
+                return onJsConfirm(view, url, message, result);
+            default:
+                break;
+        }
+        assert (false);
+        return false;
+    }
+
+    /**
+     * Tell the client to display a javascript alert dialog.
+     */
+    private boolean onJsAlert(XWalkView view, String url, String message,
+                              final XWalkJavascriptResult result) {
+        dialogsHelper.showAlert(message, new CordovaDialogsHelper.Result() {
+            @Override
+            public void gotResult(boolean success, String value) {
+                if (success) {
+                    result.confirm();
+                } else {
+                    result.cancel();
+                }
+            }
+        });
+        return true;
+    }
+
+    /**
+     * Tell the client to display a confirm dialog to the user.
+     */
+    private boolean onJsConfirm(XWalkView view, String url, String message,
+                                final XWalkJavascriptResult result) {
+        dialogsHelper.showConfirm(message, new CordovaDialogsHelper.Result() {
+            @Override
+            public void gotResult(boolean success, String value) {
+                if (success) {
+                    result.confirm();
+                } else {
+                    result.cancel();
+                }
+            }
+        });
+        return true;
+    }
+
+    /**
+     * Tell the client to display a prompt dialog to the user.
+     * If the client returns true, WebView will assume that the client will
+     * handle the prompt dialog and call the appropriate JsPromptResult method.
+     * <p/>
+     * Since we are hacking prompts for our own purposes, we should not be using them for
+     * this purpose, perhaps we should hack console.log to do this instead!
+     */
+    private boolean onJsPrompt(XWalkView view, String origin, String message, String defaultValue,
+                               final XWalkJavascriptResult result) {
+        // Unlike the @JavascriptInterface bridge, this method is always called on the UI thread.
+        String handledRet = parentEngine.bridge.promptOnJsPrompt(origin, message, defaultValue);
+        if (handledRet != null) {
+            result.confirmWithResult(handledRet);
+        } else {
+            dialogsHelper.showPrompt(message, defaultValue, new CordovaDialogsHelper.Result() {
+                @Override
+                public void gotResult(boolean success, String value) {
+                    if (success) {
+                        result.confirmWithResult(value);
+                    } else {
+                        result.cancel();
+                    }
+                }
+            });
+
+        }
+        return true;
+    }
+
+    /**
+     * Notify the host application that a page has started loading.
+     * This method is called once for each main frame load so a page with iframes or framesets will call onPageStarted
+     * one time for the main frame. This also means that onPageStarted will not be called when the contents of an
+     * embedded frame changes, i.e. clicking a link whose target is an iframe.
+     *
+     * @param view The webView initiating the callback.
+     * @param url  The url of the page.
+     */
+    @Override
+    public void onPageLoadStarted(XWalkView view, String url) {
+
+        // Only proceed if this is a top-level navigation
+        if (view.getUrl() != null && view.getUrl().equals(url)) {
+            // Flush stale messages.
+            parentEngine.client.onPageStarted(url);
+            parentEngine.bridge.reset();
+        }
+    }
+
+    /**
+     * Notify the host application that a page has stopped loading.
+     * This method is called only for main frame. When onPageLoadStopped() is called, the rendering picture may not be updated yet.
+     *
+     * @param view   The webView initiating the callback.
+     * @param url    The url of the page.
+     * @param status The load status of the webView, can be FINISHED, CANCELLED or FAILED.
+     */
+    @Override
+    public void onPageLoadStopped(XWalkView view, String url, LoadStatus status) {
+        LOG.d(TAG, "onPageFinished(" + url + ")");
+        if (status == LoadStatus.FINISHED) {
+            parentEngine.client.onPageFinishedLoading(url);
+        } else if (status == LoadStatus.FAILED) {
+            // TODO: Should this call parentEngine.client.onReceivedError()?
+            // Right now we call this from ResourceClient, but maybe that is just for sub-resources?
+        }
+    }
+
+    // File Chooser
+    @Override
+    public void openFileChooser(XWalkView view, final ValueCallback<Uri> uploadFile, String acceptType, String capture) {
+        Intent i = new Intent(Intent.ACTION_GET_CONTENT);
+        i.addCategory(Intent.CATEGORY_OPENABLE);
+        i.setType("*/*"); // TODO: wire this to acceptType.
+        Intent intent = Intent.createChooser(i, "File Browser");
+        try {
+            parentEngine.cordova.startActivityForResult(new CordovaPlugin() {
+                @Override
+                public void onActivityResult(int requestCode, int resultCode, Intent intent) {
+                    Uri result = intent == null || resultCode != Activity.RESULT_OK ? null : intent.getData();
+                    uploadFile.onReceiveValue(result);
+                }
+            }, intent, FILECHOOSER_RESULTCODE);
+        } catch (ActivityNotFoundException e) {
+            Log.w("No activity found to handle file chooser intent.", e);
+            uploadFile.onReceiveValue(null);
+        }
+    }
+}
diff --git a/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkCordovaView.java b/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkCordovaView.java
new file mode 100644
index 00000000..0be2e998
--- /dev/null
+++ b/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkCordovaView.java
@@ -0,0 +1,108 @@
+package org.crosswalk.engine;
+
+import org.apache.cordova.CordovaPreferences;
+import org.xwalk.core.XWalkPreferences;
+import org.xwalk.core.XWalkResourceClient;
+import org.xwalk.core.XWalkUIClient;
+import org.xwalk.core.XWalkView;
+
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.util.AttributeSet;
+import android.view.KeyEvent;
+
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.CordovaWebViewEngine;
+
+public class XWalkCordovaView extends XWalkView implements CordovaWebViewEngine.EngineView {
+    protected XWalkCordovaResourceClient resourceClient;
+    protected XWalkCordovaUiClient uiClient;
+    protected XWalkWebViewEngine parentEngine;
+
+    private static boolean hasSetStaticPref;
+    // This needs to run before the super's constructor.
+    private static Context setGlobalPrefs(Context context, CordovaPreferences preferences) {
+        if (!hasSetStaticPref) {
+            hasSetStaticPref = true;
+            ApplicationInfo ai = null;
+            try {
+                ai = context.getPackageManager().getApplicationInfo(context.getApplicationContext().getPackageName(), PackageManager.GET_META_DATA);
+            } catch (PackageManager.NameNotFoundException e) {
+                throw new RuntimeException(e);
+            }
+            boolean prefAnimatable = preferences == null ? false : preferences.getBoolean("CrosswalkAnimatable", false);
+            boolean manifestAnimatable = ai.metaData == null ? false : ai.metaData.getBoolean("CrosswalkAnimatable");
+            if (prefAnimatable || manifestAnimatable) {
+                // Slows it down a bit, but allows for it to be animated by Android View properties.
+                XWalkPreferences.setValue(XWalkPreferences.ANIMATABLE_XWALK_VIEW, true);
+            }
+            if ((ai.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
+                XWalkPreferences.setValue(XWalkPreferences.REMOTE_DEBUGGING, true);
+            }
+            XWalkPreferences.setValue(XWalkPreferences.JAVASCRIPT_CAN_OPEN_WINDOW, true);
+            XWalkPreferences.setValue(XWalkPreferences.ALLOW_UNIVERSAL_ACCESS_FROM_FILE, true);
+        }
+        return context;
+    }
+
+    public XWalkCordovaView(Context context, CordovaPreferences preferences) {
+        super(setGlobalPrefs(context, preferences), (AttributeSet)null);
+    }
+
+    public XWalkCordovaView(Context context, AttributeSet attrs) {
+        super(setGlobalPrefs(context, null), attrs);
+    }
+
+    void init(XWalkWebViewEngine parentEngine) {
+        this.parentEngine = parentEngine;
+        if (resourceClient == null) {
+            setResourceClient(new XWalkCordovaResourceClient(parentEngine));
+        }
+        if (uiClient == null) {
+            setUIClient(new XWalkCordovaUiClient(parentEngine));
+        }
+    }
+
+    @Override
+    public void setResourceClient(XWalkResourceClient client) {
+        // XWalk calls this method from its constructor.
+        if (client instanceof XWalkCordovaResourceClient) {
+            this.resourceClient = (XWalkCordovaResourceClient)client;
+        }
+        super.setResourceClient(client);
+    }
+
+    @Override
+    public void setUIClient(XWalkUIClient client) {
+        // XWalk calls this method from its constructor.
+        if (client instanceof XWalkCordovaUiClient) {
+            this.uiClient = (XWalkCordovaUiClient)client;
+        }
+        super.setUIClient(client);
+    }
+
+    @Override
+    public boolean dispatchKeyEvent(KeyEvent event) {
+        Boolean ret = parentEngine.client.onDispatchKeyEvent(event);
+        if (ret != null) {
+            return ret.booleanValue();
+        }
+        return super.dispatchKeyEvent(event);
+    }
+
+    @Override
+    public void pauseTimers() {
+        // This is called by XWalkViewInternal.onActivityStateChange().
+        // We don't want them paused by default though.
+    }
+
+    public void pauseTimersForReal() {
+        super.pauseTimers();
+    }
+
+    @Override
+    public CordovaWebView getCordovaWebView() {
+        return parentEngine == null ? null : parentEngine.getCordovaWebView();
+    }
+}
diff --git a/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkExposedJsApi.java b/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkExposedJsApi.java
new file mode 100644
index 00000000..25715216
--- /dev/null
+++ b/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkExposedJsApi.java
@@ -0,0 +1,52 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+package org.crosswalk.engine;
+
+import android.os.Looper;
+
+import org.apache.cordova.CordovaBridge;
+import org.apache.cordova.ExposedJsApi;
+import org.json.JSONException;
+import org.xwalk.core.JavascriptInterface;
+
+class XWalkExposedJsApi implements ExposedJsApi {
+    private final CordovaBridge bridge;
+
+    XWalkExposedJsApi(CordovaBridge bridge) {
+        this.bridge = bridge;
+    }
+
+    @JavascriptInterface
+    public String exec(int bridgeSecret, String service, String action, String callbackId, String arguments) throws JSONException, IllegalAccessException {
+        if (Looper.myLooper() == null) {
+            Looper.prepare();
+        }
+        return bridge.jsExec(bridgeSecret, service, action, callbackId, arguments);
+    }
+
+    @JavascriptInterface
+    public void setNativeToJsBridgeMode(int bridgeSecret, int value) throws IllegalAccessException {
+        bridge.jsSetNativeToJsBridgeMode(bridgeSecret, value);
+    }
+
+    @JavascriptInterface
+    public String retrieveJsMessages(int bridgeSecret, boolean fromOnlineEvent) throws IllegalAccessException {
+        return bridge.jsRetrieveJsMessages(bridgeSecret, fromOnlineEvent);
+    }
+}
diff --git a/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkWebViewEngine.java b/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkWebViewEngine.java
new file mode 100644
index 00000000..7e5a4f1c
--- /dev/null
+++ b/plugins/cordova-plugin-crosswalk-webview/src/android/XWalkWebViewEngine.java
@@ -0,0 +1,185 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+
+package org.crosswalk.engine;
+
+import android.content.Context;
+import android.view.View;
+
+import org.apache.cordova.CordovaBridge;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPreferences;
+import org.apache.cordova.CordovaResourceApi;
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.CordovaWebViewEngine;
+import org.apache.cordova.ICordovaCookieManager;
+import org.apache.cordova.NativeToJsMessageQueue;
+import org.apache.cordova.PluginManager;
+import org.xwalk.core.XWalkNavigationHistory;
+import org.xwalk.core.XWalkView;
+
+/**
+ * Glue class between CordovaWebView (main Cordova logic) and XWalkCordovaView (the actual View).
+ */
+public class XWalkWebViewEngine implements CordovaWebViewEngine {
+
+    public static final String TAG = "XWalkWebViewEngine";
+
+    protected final XWalkCordovaView webView;
+    protected XWalkCordovaCookieManager cookieManager;
+    protected CordovaBridge bridge;
+    protected CordovaWebViewEngine.Client client;
+    protected CordovaWebView parentWebView;
+    protected CordovaInterface cordova;
+    protected PluginManager pluginManager;
+    protected CordovaResourceApi resourceApi;
+    protected NativeToJsMessageQueue nativeToJsMessageQueue;
+
+    /** Used when created via reflection. */
+    public XWalkWebViewEngine(Context context, CordovaPreferences preferences) {
+        this(new XWalkCordovaView(context, preferences));
+    }
+
+    public XWalkWebViewEngine(XWalkCordovaView webView) {
+        this.webView = webView;
+        cookieManager = new XWalkCordovaCookieManager();
+    }
+
+    // Use two-phase init so that the control will work with XML layouts.
+
+    @Override
+    public void init(CordovaWebView parentWebView, CordovaInterface cordova, CordovaWebViewEngine.Client client,
+                     CordovaResourceApi resourceApi, PluginManager pluginManager,
+                     NativeToJsMessageQueue nativeToJsMessageQueue) {
+        if (this.cordova != null) {
+            throw new IllegalStateException();
+        }
+        this.parentWebView = parentWebView;
+        this.cordova = cordova;
+        this.client = client;
+        this.resourceApi = resourceApi;
+        this.pluginManager = pluginManager;
+        this.nativeToJsMessageQueue = nativeToJsMessageQueue;
+
+        webView.init(this);
+        initWebViewSettings();
+
+        nativeToJsMessageQueue.addBridgeMode(new NativeToJsMessageQueue.OnlineEventsBridgeMode(new NativeToJsMessageQueue.OnlineEventsBridgeMode.OnlineEventsBridgeModeDelegate() {
+            @Override
+            public void setNetworkAvailable(boolean value) {
+                webView.setNetworkAvailable(value);
+            }
+            @Override
+            public void runOnUiThread(Runnable r) {
+                XWalkWebViewEngine.this.cordova.getActivity().runOnUiThread(r);
+            }
+        }));
+        bridge = new CordovaBridge(pluginManager, nativeToJsMessageQueue);
+        exposeJsInterface(webView, bridge);
+    }
+
+    @Override
+    public CordovaWebView getCordovaWebView() {
+        return parentWebView;
+    }
+
+    @Override
+    public View getView() {
+        return webView;
+    }
+
+    private void initWebViewSettings() {
+        webView.setVerticalScrollBarEnabled(false);
+    }
+
+    private static void exposeJsInterface(XWalkView webView, CordovaBridge bridge) {
+        XWalkExposedJsApi exposedJsApi = new XWalkExposedJsApi(bridge);
+        webView.addJavascriptInterface(exposedJsApi, "_cordovaNative");
+    }
+
+    // TODO(ningxin): XWalkViewUIClient should provide onScrollChanged callback
+    /*
+    public void onScrollChanged(int l, int t, int oldl, int oldt)
+    {
+        super.onScrollChanged(l, t, oldl, oldt);
+        //We should post a message that the scroll changed
+        ScrollEvent myEvent = new ScrollEvent(l, t, oldl, oldt, this);
+        this.postMessage("onScrollChanged", myEvent);
+    }
+    */
+
+    @Override
+    public boolean canGoBack() {
+        return this.webView.getNavigationHistory().canGoBack();
+    }
+
+    @Override
+    public boolean goBack() {
+        if (this.webView.getNavigationHistory().canGoBack()) {
+            this.webView.getNavigationHistory().navigate(XWalkNavigationHistory.Direction.BACKWARD, 1);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void setPaused(boolean value) {
+        if (value) {
+            // TODO: I think this has been fixed upstream and we don't need to override pauseTimers() anymore.
+            webView.pauseTimersForReal();
+        } else {
+            webView.resumeTimers();
+        }
+    }
+
+    @Override
+    public void destroy() {
+        webView.onDestroy();
+    }
+
+    @Override
+    public void clearHistory() {
+    	this.webView.getNavigationHistory().clear();
+    }
+
+    @Override
+    public void stopLoading() {
+        this.webView.stopLoading();
+    }
+
+    @Override
+    public void clearCache() {
+        webView.clearCache(true);
+    }
+
+    @Override
+    public String getUrl() {
+        return this.webView.getUrl();
+    }
+
+    @Override
+    public ICordovaCookieManager getCookieManager() {
+        return cookieManager;
+    }
+
+    @Override
+    public void loadUrl(String url, boolean clearNavigationStack) {
+        webView.load(url, null);
+    }
+}